@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -30,14 +30,8 @@ function sameRemoteSessionOwnerLifecycle(left, right) {
         right.sessionNodeRid !== undefined &&
         left.sessionOwnerNodeGeneration !== undefined &&
         right.sessionOwnerNodeGeneration !== undefined &&
-        left.sessionOwnerId !== undefined &&
-        right.sessionOwnerId !== undefined &&
-        left.sessionOwnerLeaseGeneration !== undefined &&
-        right.sessionOwnerLeaseGeneration !== undefined &&
         (0, routing_id_1.routingIdsEqual)(left.sessionNodeRid, right.sessionNodeRid) &&
-        left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration &&
-        left.sessionOwnerId === right.sessionOwnerId &&
-        left.sessionOwnerLeaseGeneration === right.sessionOwnerLeaseGeneration);
+        left.sessionOwnerNodeGeneration === right.sessionOwnerNodeGeneration);
 }
 function sameRemoteSessionOwner(left, right) {
     return (left.sessionRid !== undefined &&
@@ -296,19 +290,7 @@ class ZLinkActorRuntimeState {
             target.bindingGeneration === undefined) {
             throw new TypeError('An installed bound Session target requires its binding identity.');
         }
-        const current = this.boundSessionValue;
-        if (current !== undefined && sameRemoteSessionOwnerLifecycle(current, target)) {
-            // A duplicate or late older command for the exact physical Session
-            // leaves the current binding; a newer generation of the same Session
-            // replaces it. A different Session in the same owner lifecycle must
-            // advance that lifecycle's generation; a late equal/lower one is stale.
-            const advances = current.bindingGeneration === undefined ||
-                target.bindingGeneration > current.bindingGeneration;
-            if (!advances)
-                return sameRemoteSessionOwner(current, target);
-        }
-        // Binding generations are scoped to a Session-owner lifecycle. A restarted
-        // owner can legitimately reset its counter below the predecessor value.
+        // The service registry accepted this identity in the Actor owner turn.
         this.boundSessionValue = boundSessionIdentity(target);
         return true;
     }

package/dist/runtime/actors/actor-source-transfer.d.ts

@@ -1,27 +1,11 @@
-import type { ActorRef, ZLinkActor, ZLinkMessage } from '../../contracts';
+import type { ActorRef, ZLinkActor } from '../../contracts';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkActorRuntimeState } from './actor-runtime-state';
-import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult } from './actor-handoff';
-import type { ServiceWireOperationId } from '../foundation/service-stateful-wire-codec';
-export interface ZLinkPreparedActorSource {
-    readonly adapterKey?: string;
-    readonly state: ZLinkMessage;
-    readonly handoffBacklog: readonly ZLinkActorHandoffPacket[];
-    readonly sourceLeaveCompletion?: Promise<void>;
-    readonly sourceLeaveSubmitted?: Promise<void>;
-    onSourceLeaveSubmitted(notify: () => Promise<void>): void;
-    observeTargetAuthority(target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, signal?: AbortSignal): Promise<void>;
-    commit(target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, results: readonly ZLinkActorHandoffResult[], releaseLocation?: boolean): void;
-    rollback(): Promise<void>;
-}
 export interface ZLinkActorSourceTransfer {
     /** Starts the ingress handoff before target route lookup. */
     beginDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
-    /** Changes a provisional ingress fence into a relocation handoff. */
-    promoteDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
     /** Finishes a same-node deferred Join handoff after completion callback. */
     completeDeferredActorHandoff?(actor: ZLinkActor, target: ZLinkSpotRouteTarget, targetActorRef: ActorRef): Promise<void>;
     /** Releases an early handoff when Join cannot commit. */
     cancelDeferredActorHandoff?(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
-    prepareSource(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, lifecycleAuthority?: 'framework' | 'core', deferredJoin?: boolean, relocation?: ServiceWireOperationId): Promise<ZLinkPreparedActorSource>;
 }

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

@@ -2,7 +2,7 @@ import { type ActorRef, type RoutingId, type SpotRef, type ZLinkActor, type ZLin
 import type { ZLinkBackendActorRef, ZLinkBackendSpotNode } from '../backend/contracts';
 import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
 import { ZLinkActorRuntimeState } from './actor-runtime-state';
-export { DefaultZLinkActorClient, forwardEncodedActorPacket, type ZLinkActorClientOptions } from './actor-client';
+export { DefaultZLinkActorClient, type ZLinkActorClientOptions } from './actor-client';
 export { DefaultZLinkActorContext, ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME } from './actor-context';
 export { ZLinkActorSerialExecutor } from './actor-mailbox';
 export { DEFAULT_MESSAGE_FOLLOW_DURATION_MS, ZLinkActorHandoffCoordinator, decodeHandoffPacket, type ZLinkActorHandoffPacket, type ZLinkActorHandoffDispatch, type ZLinkActorHandoffPrefixAdmission, type ZLinkActorHandoffPrefixQueue, type ZLinkActorHandoffPrefixRecord, type ZLinkActorHandoffPreparedReplayAdmission, type ZLinkActorHandoffReplayAdmission, type ZLinkActorHandoffReplayPreparation, type ZLinkActorHandoffResult } from './actor-handoff';
@@ -51,10 +51,14 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     publishRelocationActor(actorId: string): void;
     abortRelocationActor(actorId: string): Promise<void>;
     completeRelocationSource(actorId: string, sourceActorRef?: ZLinkBackendActorRef): Promise<void>;
+    /** Commit removes current ownership; a Join profile may still own its leave callback. */
+    detachRelocationSource(state: ZLinkActorRuntimeState): void;
     releaseSpotActorMembers(meshName: string, spotId?: RoutingId): Promise<void>;
     private releaseLocalActor;
-    completeCoreRelocationSource(actorId: string): Promise<void>;
+    completeCoreRelocationSource(actorId: string, state?: ZLinkActorRuntimeState | undefined): Promise<void>;
+    private discardNativeRelocationSource;
     private finalizeActorState;
+    private detachActorStateRegistration;
     private finalizeDestroyedActor;
     private terminateActor;
     private awaitActorDestroy;

package/dist/runtime/actors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultZLinkActorManager = exports.ZLINK_ACTOR_LIFECYCLE_SNAPSHOT = exports.createActorMembership = exports.createActorJoinRequest = exports.actorJoinIdentity = exports.ZLinkRemoteBoundSessionFenceError = exports.isRemoteBoundSessionFenceError = exports.encodeRemoteBoundSessionNack = exports.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET = exports.ZLINK_REMOTE_BOUND_SESSION_RESPONSE_PACKET = exports.ZLINK_REMOTE_BOUND_SESSION_FENCE_NACK_CODE = exports.ZLINK_REMOTE_BOUND_SESSION_ERROR_PACKET = exports.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET = exports.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET = exports.decodeRemoteActorSourceLeaveTerminal = exports.ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET = exports.ZLinkActorTransferRegistry = exports.ZLinkActorNativeJoinCoordinator = exports.ZLinkSpotActorHandlerRegistryRuntime = exports.ZLinkSpotActorDispatcher = exports.ZLinkActorPacketKind = exports.publishInitialActorAuthority = exports.rewriteActorAuthorityOwner = exports.rewriteActorAuthorityRoute = exports.isActorAuthorityPayload = exports.encodeActorAuthorityIdentity = exports.decodeRelocatingActorAuthorityIdentity = exports.decodeActorAuthorityIdentity = exports.createDeferredJoinCompletion = exports.toFrameworkRoutingId = exports.toFrameworkActorRef = exports.ZLinkActorRuntimeState = exports.decodeActorMessageFollowContext = exports.attachActorMessageFollowContext = exports.actorMessageFollowContext = exports.decodeHandoffPacket = exports.ZLinkActorHandoffCoordinator = exports.DEFAULT_MESSAGE_FOLLOW_DURATION_MS = exports.ZLinkActorSerialExecutor = exports.ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME = exports.DefaultZLinkActorContext = exports.forwardEncodedActorPacket = exports.DefaultZLinkActorClient = void 0;
+exports.DefaultZLinkActorManager = exports.ZLINK_ACTOR_LIFECYCLE_SNAPSHOT = exports.createActorMembership = exports.createActorJoinRequest = exports.actorJoinIdentity = exports.ZLinkRemoteBoundSessionFenceError = exports.isRemoteBoundSessionFenceError = exports.encodeRemoteBoundSessionNack = exports.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET = exports.ZLINK_REMOTE_BOUND_SESSION_RESPONSE_PACKET = exports.ZLINK_REMOTE_BOUND_SESSION_FENCE_NACK_CODE = exports.ZLINK_REMOTE_BOUND_SESSION_ERROR_PACKET = exports.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET = exports.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET = exports.decodeRemoteActorSourceLeaveTerminal = exports.ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET = exports.ZLinkActorTransferRegistry = exports.ZLinkActorNativeJoinCoordinator = exports.ZLinkSpotActorHandlerRegistryRuntime = exports.ZLinkSpotActorDispatcher = exports.ZLinkActorPacketKind = exports.publishInitialActorAuthority = exports.rewriteActorAuthorityOwner = exports.rewriteActorAuthorityRoute = exports.isActorAuthorityPayload = exports.encodeActorAuthorityIdentity = exports.decodeRelocatingActorAuthorityIdentity = exports.decodeActorAuthorityIdentity = exports.createDeferredJoinCompletion = exports.toFrameworkRoutingId = exports.toFrameworkActorRef = exports.ZLinkActorRuntimeState = exports.decodeActorMessageFollowContext = exports.attachActorMessageFollowContext = exports.actorMessageFollowContext = exports.decodeHandoffPacket = exports.ZLinkActorHandoffCoordinator = exports.DEFAULT_MESSAGE_FOLLOW_DURATION_MS = exports.ZLinkActorSerialExecutor = exports.ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME = exports.DefaultZLinkActorContext = exports.DefaultZLinkActorClient = void 0;
 const contracts_1 = require("../../contracts");
 const Registration_1 = require("../../contracts/Configuration/Registration");
 const abort_1 = require("../abort");
@@ -20,7 +20,6 @@ const ACTOR_CREATION_RETRY_INTERVAL_MS = 5;
 const LOCAL_DIAGNOSTIC_NODE_RID = 'local';
 var actor_client_1 = require("./actor-client");
 Object.defineProperty(exports, "DefaultZLinkActorClient", { enumerable: true, get: function () { return actor_client_1.DefaultZLinkActorClient; } });
-Object.defineProperty(exports, "forwardEncodedActorPacket", { enumerable: true, get: function () { return actor_client_1.forwardEncodedActorPacket; } });
 var actor_context_1 = require("./actor-context");
 Object.defineProperty(exports, "DefaultZLinkActorContext", { enumerable: true, get: function () { return actor_context_1.DefaultZLinkActorContext; } });
 Object.defineProperty(exports, "ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME", { enumerable: true, get: function () { return actor_context_1.ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME; } });
@@ -262,6 +261,10 @@ class DefaultZLinkActorManager {
     }
     async findActor(actorId, signal) {
         (0, abort_1.throwIfAborted)(signal);
+        return this.resolveLocalActor(actorId);
+    }
+    /** @internal Uses the relocation owner's publication boundary for local dispatch. */
+    resolveLocalActor(actorId) {
         if (this.relocationStaged.has(actorId))
             return undefined;
         return this.states.get(actorId)?.actor;
@@ -310,7 +313,7 @@ class DefaultZLinkActorManager {
                 node.discardRelocatedActor?.(nativeRef);
             this.relocationStaged.delete(actorId);
             const failedState = this.states.get(actorId);
-            await this.finalizeActorState(actorId, failedState);
+            await this.finalizeActorState(failedState);
             throw error;
         }
     }
@@ -326,6 +329,12 @@ class DefaultZLinkActorManager {
     async completeRelocationSource(actorId, sourceActorRef) {
         await this.releaseLocalActor(actorId, sourceActorRef);
     }
+    /** Commit removes current ownership; a Join profile may still own its leave callback. */
+    detachRelocationSource(state) {
+        if (this.detachActorStateRegistration(state)) {
+            this.discardNativeRelocationSource(state.nativeActorRef);
+        }
+    }
     async releaseSpotActorMembers(meshName, spotId) {
         const results = await Promise.allSettled([...this.states.values()]
             .filter((state) => state.meshName === meshName && state.spotId === spotId)
@@ -340,19 +349,17 @@ class DefaultZLinkActorManager {
     }
     async releaseLocalActor(actorId, exactNativeActorRef) {
         const state = this.states.get(actorId);
-        const node = this.options.nativeActorNodeProvider?.() ?? this.options.nativeActorNode;
-        const nativeActorRef = exactNativeActorRef ?? state?.nativeActorRef;
+        if (state === undefined)
+            return;
         const failures = [];
         try {
-            if (nativeActorRef !== undefined) {
-                node?.discardRelocatedActor?.(nativeActorRef);
-            }
+            this.discardNativeRelocationSource(exactNativeActorRef ?? state.nativeActorRef);
         }
         catch (error) {
             failures.push(error);
         }
         try {
-            await this.completeCoreRelocationSource(actorId);
+            await this.completeCoreRelocationSource(actorId, state);
         }
         catch (error) {
             failures.push(error);
@@ -363,12 +370,17 @@ class DefaultZLinkActorManager {
                 : new AggregateError(failures, 'Actor relocation cleanup failed.');
         }
     }
-    async completeCoreRelocationSource(actorId) {
-        const state = this.states.get(actorId);
-        await this.finalizeActorState(actorId, state);
+    async completeCoreRelocationSource(actorId, state = this.states.get(actorId)) {
+        await this.finalizeActorState(state);
     }
-    async finalizeActorState(actorId, state) {
-        if (state === undefined || this.states.get(actorId) !== state)
+    discardNativeRelocationSource(nativeActorRef) {
+        if (nativeActorRef === undefined)
+            return;
+        const node = this.options.nativeActorNodeProvider?.() ?? this.options.nativeActorNode;
+        node?.discardRelocatedActor?.(nativeActorRef);
+    }
+    async finalizeActorState(state) {
+        if (state === undefined)
             return;
         try {
             if (state.actor !== undefined)
@@ -376,13 +388,17 @@ class DefaultZLinkActorManager {
         }
         finally {
             state.clearAfterDestroy();
-            if (this.states.get(actorId) === state) {
-                this.states.delete(actorId);
-                this.actorMeshNames.delete(actorId);
-                this.relocationStaged.delete(actorId);
-            }
+            this.detachActorStateRegistration(state);
         }
     }
+    detachActorStateRegistration(state) {
+        if (this.states.get(state.actorId) !== state)
+            return false;
+        this.states.delete(state.actorId);
+        this.actorMeshNames.delete(state.actorId);
+        this.relocationStaged.delete(state.actorId);
+        return true;
+    }
     async finalizeDestroyedActor(actorId, state) {
         if (this.states.get(actorId) !== state)
             return;
@@ -390,7 +406,7 @@ class DefaultZLinkActorManager {
             this.options.actorDestroyedCleanup?.(actorId);
         }
         finally {
-            await this.finalizeActorState(actorId, state);
+            await this.finalizeActorState(state);
             this.options.metrics?.change(runtime_metrics_1.METRIC_NAMES.ActorCount, -1);
         }
     }
@@ -644,7 +660,7 @@ class ZLinkActorCreateCallRuntime {
     yield(signal) {
         const turn = (0, execution_1.requireZLinkYieldTurn)(this.turn);
         const pending = this.executeOnce(signal);
-        return turn.yieldPromise(pending);
+        return turn.yieldFrameworkPromise(pending);
     }
     executeOnce(signal) {
         this.requireMutable();

package/dist/runtime/actors/session-disconnected-wire.d.ts

@@ -0,0 +1,8 @@
+import type { RoutingId } from '../../contracts';
+export interface SessionDisconnectedIdentity {
+    readonly sessionOwnerNodeRid: RoutingId;
+    readonly sessionOwnerNodeGeneration: bigint;
+    readonly bindingGeneration: bigint;
+}
+export declare function encodeSessionDisconnected(sessionOwnerNodeRid: RoutingId | undefined, sessionOwnerNodeGeneration: bigint | undefined, bindingGeneration: bigint | undefined): Buffer;
+export declare function decodeSessionDisconnected(bytes: Uint8Array): SessionDisconnectedIdentity | undefined;

package/dist/runtime/actors/session-disconnected-wire.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeSessionDisconnected = encodeSessionDisconnected;
+exports.decodeSessionDisconnected = decodeSessionDisconnected;
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const contracts_1 = require("../../contracts");
+const routing_id_1 = require("../routing-id");
+const RID_LENGTH_BYTES = 1;
+const GENERATION_BYTES = 8;
+const GENERATIONS_BYTES = GENERATION_BYTES * 2;
+function encodeSessionDisconnected(sessionOwnerNodeRid, sessionOwnerNodeGeneration, bindingGeneration) {
+    if (sessionOwnerNodeRid === undefined ||
+        sessionOwnerNodeGeneration === undefined ||
+        sessionOwnerNodeGeneration === 0n ||
+        bindingGeneration === undefined ||
+        bindingGeneration === 0n) {
+        throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'Session disconnect requires an exact binding identity.');
+    }
+    const rid = Buffer.from((0, routing_id_1.encodeRoutingIdStorageHex)(sessionOwnerNodeRid), 'hex');
+    if (rid.length === 0 || rid.length > CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES) {
+        throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'Invalid Session owner Node RID length.');
+    }
+    const payload = Buffer.allocUnsafe(RID_LENGTH_BYTES + rid.length + GENERATIONS_BYTES);
+    payload[0] = rid.length;
+    rid.copy(payload, RID_LENGTH_BYTES);
+    payload.writeBigUInt64BE(sessionOwnerNodeGeneration, RID_LENGTH_BYTES + rid.length);
+    payload.writeBigUInt64BE(bindingGeneration, RID_LENGTH_BYTES + rid.length + GENERATION_BYTES);
+    return payload;
+}
+function decodeSessionDisconnected(bytes) {
+    const payload = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (payload.length < RID_LENGTH_BYTES + 1 + GENERATIONS_BYTES)
+        return undefined;
+    const ridLength = payload[0];
+    if (ridLength === 0 || payload.length !== RID_LENGTH_BYTES + ridLength + GENERATIONS_BYTES)
+        return undefined;
+    const offset = RID_LENGTH_BYTES + ridLength;
+    const sessionOwnerNodeGeneration = payload.readBigUInt64BE(offset);
+    const bindingGeneration = payload.readBigUInt64BE(offset + GENERATION_BYTES);
+    if (sessionOwnerNodeGeneration === 0n || bindingGeneration === 0n)
+        return undefined;
+    const hex = payload.subarray(RID_LENGTH_BYTES, offset).toString('hex');
+    return {
+        sessionOwnerNodeRid: (0, routing_id_1.decodeRoutingId)(hex, hex),
+        sessionOwnerNodeGeneration,
+        bindingGeneration
+    };
+}

package/dist/runtime/admission.d.ts

@@ -1,4 +1,6 @@
 import { ZLinkFrameworkInternalErrorKind } from './framework-errors-internal';
+/** Runs host admission inside the domain's request completion boundary. */
+export type ZLinkMeshDispatchAdmission = (dispatch: () => void | Promise<void>, onRejected?: (error: unknown) => void | Promise<void>) => void | Promise<void>;
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 export declare function shouldCompactBackingArray(head: number, length: number): boolean;
 export declare class ZLinkRuntimeAdmissionGate {
@@ -16,7 +18,13 @@ 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: () => T | Promise<T>): Promise<T>;
+    /**
+     * Runs one admitted unit of work. Work that completes synchronously leaves
+     * admission in the same turn; asynchronous work leaves it from the single
+     * continuation on its result.
+     */
+    run<T>(meshName: string, operation: string, work: () => T | Promise<T>, onRejected?: (error: unknown) => T | Promise<T>): T | Promise<T>;
+    private enter;
     awaitZero(meshName: string, signal?: AbortSignal): Promise<void>;
     requireRequest(operation: string, meshName?: string): void;
     requireActorCreate(actorId: string, meshName?: string): void;

package/dist/runtime/admission.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRuntimeAdmissionGate = void 0;
 exports.shouldCompactBackingArray = shouldCompactBackingArray;
 const framework_errors_internal_1 = require("./framework-errors-internal");
+const abort_1 = require("./abort");
 const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 function shouldCompactBackingArray(head, length) {
@@ -57,44 +58,58 @@ class ZLinkRuntimeAdmissionGate {
         }
     }
     claim(meshName, operation) {
-        const state = this.requireState(meshName);
-        if (this.ownerAdmissionOpen() && !state.sealed) {
-            state.active += 1;
-            let closed = false;
-            return {
-                close: () => {
-                    if (closed)
-                        return;
-                    closed = true;
-                    state.active -= 1;
-                    if (state.active === 0) {
-                        let resolve;
-                        while ((resolve = takeWaiter(state)) !== undefined)
-                            resolve();
-                    }
-                }
-            };
-        }
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because framework admission is closed.`);
+        const state = this.enter(meshName, operation);
+        let closed = false;
+        return {
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                exitAdmission(state);
+            }
+        };
     }
-    run(meshName, operation, work) {
-        let claim;
+    /**
+     * Runs one admitted unit of work. Work that completes synchronously leaves
+     * admission in the same turn; asynchronous work leaves it from the single
+     * continuation on its result.
+     */
+    run(meshName, operation, work, onRejected) {
+        let state;
+        let result;
         try {
-            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;
-            });
+            state = this.enter(meshName, operation);
         }
         catch (error) {
-            claim?.close();
+            // The domain owns admission rejection completion, just as it owns handler failure.
+            return onRejected === undefined ? Promise.reject(error) : onRejected(error);
+        }
+        try {
+            result = work();
+        }
+        catch (error) {
+            exitAdmission(state);
             return Promise.reject(error);
         }
+        if (!(0, abort_1.isPromiseLike)(result)) {
+            exitAdmission(state);
+            return result;
+        }
+        return Promise.resolve(result).then((value) => {
+            exitAdmission(state);
+            return value;
+        }, (error) => {
+            exitAdmission(state);
+            throw error;
+        });
+    }
+    enter(meshName, operation) {
+        const state = this.requireState(meshName);
+        if (this.ownerAdmissionOpen() && !state.sealed) {
+            state.active += 1;
+            return state;
+        }
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(state.sealedReason, `${operation} was rejected because framework admission is closed.`);
     }
     awaitZero(meshName, signal) {
         const state = this.requireState(meshName);
@@ -160,6 +175,14 @@ class ZLinkRuntimeAdmissionGate {
     }
 }
 exports.ZLinkRuntimeAdmissionGate = ZLinkRuntimeAdmissionGate;
+function exitAdmission(state) {
+    state.active -= 1;
+    if (state.active === 0) {
+        let resolve;
+        while ((resolve = takeWaiter(state)) !== undefined)
+            resolve();
+    }
+}
 function takeWaiter(state) {
     advanceWaiterHead(state);
     const waiter = state.waiters[state.waiterHead];

package/dist/runtime/application-jobs/application-job-queue-scope.d.ts

@@ -1,4 +1,15 @@
 import type { ApplicationJobOrigin, ApplicationJobPermitPort } from './contracts';
+/** Ends the internal processing of one record turn unless its handler detached the permit. */
+export declare function releaseApplicationJobPermitTurn(permit: ApplicationJobPermitPort | undefined): void;
+/**
+ * Makes `permit` the current record's permit for the synchronous part of a
+ * dispatch. The caller restores the returned previous scope with
+ * {@link leaveApplicationJobPermitScope} and releases the turn itself, so a
+ * dispatcher that already continues on the handler result needs no second
+ * continuation here.
+ */
+export declare function enterApplicationJobPermitScope(permit: ApplicationJobPermitPort): ApplicationJobPermitPort | undefined;
+export declare function leaveApplicationJobPermitScope(previous: ApplicationJobPermitPort | undefined): void;
 /**
  * Carries the host-owned queue permit through internal async dispatch without
  * leaking capacity ownership into public handler contracts.
@@ -9,6 +20,8 @@ export declare function runWithApplicationJobPermit<TResult, TFirst = undefined,
 export declare function releaseApplicationJobPermitBeforeHandler(): void;
 /** True while dispatch already owns the host-wide application job permit. */
 export declare function hasApplicationJobPermit(): boolean;
+/** The current ingress reservation; capacity remains owned by its host queue. */
+export declare function currentApplicationJobPermit(): ApplicationJobPermitPort | undefined;
 /** Keeps the ingress origin when a durable record later reacquires its permit. */
 export declare function currentApplicationJobOrigin(): ApplicationJobOrigin;
 /** Re-enters the captured permit scope when a serial executor runs later. */

package/dist/runtime/application-jobs/application-job-queue-scope.js

@@ -1,19 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseApplicationJobPermitTurn = releaseApplicationJobPermitTurn;
+exports.enterApplicationJobPermitScope = enterApplicationJobPermitScope;
+exports.leaveApplicationJobPermitScope = leaveApplicationJobPermitScope;
 exports.runWithApplicationJobPermit = runWithApplicationJobPermit;
 exports.releaseApplicationJobPermitBeforeHandler = releaseApplicationJobPermitBeforeHandler;
 exports.releaseApplicationJobPermitForDurableHandoff = releaseApplicationJobPermitForDurableHandoff;
 exports.hasApplicationJobPermit = hasApplicationJobPermit;
+exports.currentApplicationJobPermit = currentApplicationJobPermit;
 exports.currentApplicationJobOrigin = currentApplicationJobOrigin;
 exports.bindApplicationJobPermit = bindApplicationJobPermit;
 exports.detachApplicationJobPermit = detachApplicationJobPermit;
 const node_async_hooks_1 = require("node:async_hooks");
 const applicationJobPermitScope = new node_async_hooks_1.AsyncLocalStorage();
 function releasePermitTurn() {
-    const permit = applicationJobPermitScope.getStore();
+    releaseApplicationJobPermitTurn(applicationJobPermitScope.getStore());
+}
+/** Ends the internal processing of one record turn unless its handler detached the permit. */
+function releaseApplicationJobPermitTurn(permit) {
     if (permit !== undefined && !permit.detachedForHandlerTurn)
         permit.releaseAfterInternalProcessing();
 }
+/**
+ * Makes `permit` the current record's permit for the synchronous part of a
+ * dispatch. The caller restores the returned previous scope with
+ * {@link leaveApplicationJobPermitScope} and releases the turn itself, so a
+ * dispatcher that already continues on the handler result needs no second
+ * continuation here.
+ */
+function enterApplicationJobPermitScope(permit) {
+    const previous = applicationJobPermitScope.getStore();
+    applicationJobPermitScope.enterWith(permit);
+    return previous;
+}
+function leaveApplicationJobPermitScope(previous) {
+    applicationJobPermitScope.enterWith(previous);
+}
 function releasePermitSuccess(value) {
     releasePermitTurn();
     return value;
@@ -53,6 +75,10 @@ function releaseApplicationJobPermitForDurableHandoff() {
 function hasApplicationJobPermit() {
     return applicationJobPermitScope.getStore() !== undefined;
 }
+/** The current ingress reservation; capacity remains owned by its host queue. */
+function currentApplicationJobPermit() {
+    return applicationJobPermitScope.getStore();
+}
 /** Keeps the ingress origin when a durable record later reacquires its permit. */
 function currentApplicationJobOrigin() {
     return applicationJobPermitScope.getStore().origin;

package/dist/runtime/application-jobs/contracts.d.ts

@@ -1,5 +1,7 @@
 export type ApplicationJobOrigin = 'local' | 'remote';
 export interface ApplicationJobPermitPort {
+    /** Reacquires this record's host supply after durable FIFO ownership. */
+    reacquire?(signal: AbortSignal): Promise<ApplicationJobPermitPort>;
     readonly origin: ApplicationJobOrigin;
     readonly detachedForHandlerTurn: boolean;
     markApplicationQueued(): void;

package/dist/runtime/backend/contracts/index.d.ts

@@ -32,10 +32,17 @@ export type ZLinkBackendObjectPlacement = {
 } | {
     readonly kind: 'unavailable';
 };
+export type ZLinkBackendRequestSourceAcceptance = (nodeRid: string, nodeGeneration: bigint, nodeRidStorageHex: string, signal?: AbortSignal) => import('../../locations/request-source-resolver').ZLinkRequestSourceFence | undefined | Promise<import('../../locations/request-source-resolver').ZLinkRequestSourceFence | undefined>;
 export interface ZLinkBackendMeshNode {
+    acceptRelocatedActorTerminal?(operation: {
+        readonly high: bigint;
+        readonly low: bigint;
+    }, replyRouteId: bigint, result: import('../../foundation/service-stateful-runtime').ServiceStatefulResult): 'terminalReceived' | 'alreadyTerminal' | undefined;
     readonly routingId?: RoutingId;
+    cancelPendingOperations?(reason: unknown): void;
     completeClosedInstance?(spotId: string, objectGeneration: bigint): void;
     setDispatchErrorReporter?(reporter: import('../../channels/dispatch-error-reporter').ZLinkDispatchErrorReporter, meshName: string): void;
+    setSessionOwnerDescriptors?(source: import('../../foundation/service-stateful-runtime').ServiceSessionOwnerDescriptors): void;
     setRoutingId(routingId: unknown): void;
     setBind(endpoint: string): void;
     setAdvertiseHost(host: string): void;
@@ -52,9 +59,9 @@ export interface ZLinkBackendMeshNode {
     }) => void): void;
     setMessageFollowHandler?(handler: (record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
     sendMessageFollowNotification?(targetNodeRid: string, record: Omit<import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
-    shutdown(timeoutMs: number): RequestResult;
+    shutdown(timeoutMs: number): Promise<RequestResult>;
     publishDraining?(): Promise<void>;
-    close(): void;
+    close(): Promise<void>;
     addChannelName(name: string): void;
     setChannelWeight(name: string, weight: number): Promise<void>;
     setPlacementWeight(weight: number): Promise<void>;
@@ -97,10 +104,16 @@ export interface ZLinkBackendMeshNode {
         readonly securityIdentity?: string;
         readonly lifecycleGeneration: bigint;
     }): void;
+    /**
+     * Installs the source request owner check the first accepting owner runs on Actor and Spot
+     * ingress (Location runtime §9.3). Undefined from the check ends the request Unavailable.
+     */
+    setRequestSourceAcceptance?(acceptance: ZLinkBackendRequestSourceAcceptance): void;
     isObjectClientNodeDirectTarget?(targetRid: unknown): boolean;
     observePeerRoute?(targetRid: unknown): import('../../foundation/durable-service-request').PeerRouteObservation;
     hasPeerRouteOrConnectionIntent?(targetRid: unknown, endpoint: string): boolean;
     isPeerRouteReady?(targetRid: unknown, lifecycleGeneration?: bigint): boolean;
+    waitForPeerRoute?(targetRid: unknown, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
     sendToNode(targetRid: unknown, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
     }): SubmitResult | Promise<SubmitResult>;
@@ -172,7 +185,8 @@ export interface ZLinkBackendMeshNode {
     forgetSpotRoute?(spot: ServiceDirectSpotRouteFence['spot'], authorityOwnerGeneration: bigint, storeVersion?: string): void;
     sealSpotMessageFollowIngress?(source: ServiceDirectSpotRouteFence): ServiceSpotMessageFollowSeal | undefined;
     abortSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal): boolean;
-    commitSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
+    /** A null target consumes the committed seal without installing a Follow route. */
+    commitSpotMessageFollowIngress?(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence | null, durationMs: number): Promise<boolean>;
     joinActorSpot(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, timeoutMs?: number): MeshOperationId;
     joinActorSpotCanonical(actor: ZLinkBackendActorRef, targetNodeRid: unknown, targetSpotId: unknown, targetSpotGeneration: bigint, request: ServiceApplicationPayload, actorFence: {
         readonly targetNodeGeneration: bigint;
@@ -193,12 +207,14 @@ export interface ZLinkBackendMeshNode {
     }, timeoutMs?: number): MeshOperationId;
     sendToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
+        routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
     }): Promise<SubmitResult>;
     requestToActor(actor: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;
         timeoutMs?: number;
         applicationMetadata?: Buffer;
         onAdmitted?: () => void;
+        routeFence?: import('../../foundation/service-stateful-wire-codec').ServiceActorRouteFence;
     }): MeshOperationId;
     actorSendToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         flags?: number;

package/dist/runtime/backend/mesh-actor-session-node-adapter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meshActorSessionNodeAdapter = meshActorSessionNodeAdapter;
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const mesh_completion_table_1 = require("./mesh-completion-table");
 function meshActorSessionNodeAdapter(node, completions) {
@@ -16,8 +17,7 @@ function meshActorSessionNodeAdapter(node, completions) {
             const completion = await completions.submit(() => node.closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs), signal);
             try {
                 if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
-                    throw new Error(`Actor '${actor.actorId}' bound-session close failed with result ` +
-                        `'${completion.terminalResult}' and errno '${completion.failureErrno}'.`);
+                    throw (0, framework_errors_internal_1.wireReplyFailureException)(completion.terminalResult, completion.failureErrno, `Actor '${actor.actorId}' bound-session close failed.`);
                 }
             }
             finally {

package/dist/runtime/backend/mesh-completion-table.js

@@ -49,7 +49,12 @@ class ZLinkMeshCompletionTable {
             this.slots.push(slot);
             this.free = index;
         }
+        // New slots hold no identity yet. Only a larger bucket array needs the
+        // pending identities placed again; it doubles, so growth to N pending
+        // operations re-indexes O(N) slots in total.
         const minimumBuckets = this.slots.length * COMPLETION_HASH_BUCKETS_PER_SLOT;
+        if (minimumBuckets <= this.buckets.length)
+            return;
         this.buckets = new Int32Array(2 ** Math.ceil(Math.log2(minimumBuckets))).fill(-1);
         for (let index = 0; index < this.slots.length; index++) {
             const slot = this.slots[index];