@zlink-systems/framework 0.30.0 → 0.30.2

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
                         }
                     }),
@@ -251,6 +248,10 @@ class ZLinkLocalNativeActorJoin {
             admission.parts[0]?.close();
             throw error;
         }
+        if (relocated.sourceCleanup !== undefined) {
+            admission.parts[0]?.close();
+            return { accepted: false, sourceCleanup: relocated.sourceCleanup };
+        }
         state.setNativeActorRef(relocated.actorRef);
         if (entrySpot) {
             state.clearJoinedSpot();

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

@@ -14,8 +14,34 @@ class ZLinkActorSerialExecutor {
         this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runRecord(record), options, sharedOwner);
     }
     execute(operation, workOptions) {
+        const initial = (0, application_job_queue_scope_1.currentApplicationJobPermit)();
+        if (initial !== undefined &&
+            workOptions?.lane !== 'lifecycle' &&
+            this.scheduler.hasPendingDurableApplication) {
+            let prepared;
+            const cancel = () => {
+                prepared?.releaseAfterInternalProcessing();
+                prepared = undefined;
+            };
+            const terminal = this.scheduler.admitDurablePrefix(() => (0, application_job_queue_scope_1.runWithApplicationJobPermit)(prepared, () => (0, actor_execution_context_1.runZLinkActorExecution)(this.actorId, this.sourceSpotId, operation)), workOptions, undefined, {
+                prepare: async (signal) => {
+                    if (initial.reacquire === undefined) {
+                        throw new Error('Durable Actor ingress requires its host permit source.');
+                    }
+                    prepared = await initial.reacquire(signal);
+                    if (signal.aborted) {
+                        cancel();
+                        throw signal.reason;
+                    }
+                    prepared.markApplicationQueued();
+                },
+                cancel
+            });
+            initial.releaseAfterInternalProcessing();
+            return terminal;
+        }
         const boundOperation = (0, application_job_queue_scope_1.bindApplicationJobPermit)(() => (0, actor_execution_context_1.runZLinkActorExecution)(this.actorId, this.sourceSpotId, operation));
-        return (0, application_job_queue_scope_1.hasApplicationJobPermit)()
+        return initial !== undefined
             ? this.scheduler.submitPreAdmitted(boundOperation, workOptions)
             : this.scheduler.submit(boundOperation, workOptions);
     }

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

@@ -78,7 +78,9 @@ class ZLinkActorNativeJoinCoordinator {
         return this.withDeferredJoinFinalizer(actor, state, target, result, completionOperationId);
     }
     withDeferredJoinFinalizer(actor, state, target, result, operationId) {
-        if (operationId === undefined || this.options.sourceTransfer === undefined)
+        if (result.sourceCleanup !== undefined ||
+            operationId === undefined ||
+            this.options.sourceTransfer === undefined)
             return result;
         return {
             ...result,

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-reply.d.ts

@@ -0,0 +1,4 @@
+import { encodeFrameworkPayload } from '../messaging/payload-codec';
+import { ZLinkStreamMessageKind } from '../streams/protocol';
+/** Ordinary dispatch and relocation use the same typed Actor reply envelope. */
+export declare function encodeActorReply(requestHeaderBytes: Uint8Array, kind: ZLinkStreamMessageKind.Response | ZLinkStreamMessageKind.Error, payload: unknown, serializers: Parameters<typeof encodeFrameworkPayload>[1], flowEnabled: boolean): readonly Buffer[];

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeActorReply = encodeActorReply;
+const payload_codec_1 = require("../messaging/payload-codec");
+const protocol_1 = require("../streams/protocol");
+/** Ordinary dispatch and relocation use the same typed Actor reply envelope. */
+function encodeActorReply(requestHeaderBytes, kind, payload, serializers, flowEnabled) {
+    const requestHeader = (0, protocol_1.decodeStreamHeader)(requestHeaderBytes, flowEnabled);
+    const encoded = kind === protocol_1.ZLinkStreamMessageKind.Response
+        ? (0, payload_codec_1.encodeFrameworkPayload)(payload, serializers, requestHeader.name, 'reply')
+        : (0, payload_codec_1.encodeFrameworkPayload)(payload);
+    try {
+        const frame = (0, protocol_1.encodeStreamFrame)({
+            kind,
+            codec: (0, protocol_1.streamCodecForContentType)(encoded.contentType),
+            flags: protocol_1.ZLinkStreamHeaderFlags.None,
+            requestSeq: requestHeader.requestSeq,
+            name: '',
+            metadata: new Map(),
+            correlationId: requestHeader.correlationId,
+            flowId: requestHeader.flowId,
+            flowOrigin: requestHeader.flowOrigin
+        }, encoded.message.data());
+        return [Buffer.from(frame.buffer, frame.byteOffset, frame.byteLength)];
+    }
+    finally {
+        encoded.message.close();
+    }
+}

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/actor-runtime-contracts.d.ts

@@ -8,6 +8,8 @@ import type { ZLinkActorTransferRegistry } from './actor-transfer-registry';
 import type { ZLinkRuntimeAdmissionGate } from '../admission';
 import type { ZLinkActivationAdmission } from '../activation-admission';
 export interface ZLinkActorJoinRuntimeResult<TReply> {
+    /** Relay-ready transferred completion; this continuation only releases source work. */
+    readonly sourceCleanup?: () => Promise<void>;
     readonly accepted: boolean;
     readonly actor?: import('../../contracts').ActorRef;
     readonly reply?: TReply;

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,9 +51,14 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     publishRelocationActor(actorId: string): void;
     abortRelocationActor(actorId: string): Promise<void>;
     completeRelocationSource(actorId: string, sourceActorRef?: ZLinkBackendActorRef): Promise<void>;
-    private removeRelocationActor;
-    completeCoreRelocationSource(actorId: string): 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, 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; } });
@@ -118,7 +117,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
         };
@@ -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;
@@ -302,7 +305,7 @@ class DefaultZLinkActorManager {
             }
             state.setLocationGeneration(authorityOwnerGeneration);
             if (spotId !== undefined)
-                state.setJoinedSpot(spotId, undefined, membershipEpoch);
+                state.setJoinedSpot(spotId, undefined, membershipEpoch, spotGeneration);
             return actor;
         }
         catch (error) {
@@ -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;
         }
     }
@@ -321,26 +324,42 @@ 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);
+    }
+    /** 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)
+            .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;
+        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);
@@ -351,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)
@@ -364,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;
@@ -378,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);
         }
     }
@@ -632,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/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

@@ -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: () => 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;