@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/host/spot-address-transport.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkHostSpotAddressTransport = void 0;
 exports.hasObjectClientCapability = hasObjectClientCapability;
+const request_runtime_1 = require("../foundation/request-runtime");
+const request_deadline_1 = require("../messaging/request-deadline");
+const request_result_1 = require("../messaging/request-result");
 const contracts_1 = require("../../contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const abort_1 = require("../abort");
@@ -19,8 +22,10 @@ function hasObjectClientCapability(role) {
 /** Owns global Spot authority lookup and Missing Instance placement. */
 class ZLinkHostSpotAddressTransport {
     options;
+    requests;
     constructor(options) {
         this.options = options;
+        this.requests = options.requests ?? new request_runtime_1.RequestRuntime();
     }
     sendToSpotAddress(spotId, message, call) {
         // Call-scoped flow (spec 27 §4): the envelope encoders and the
@@ -92,61 +97,71 @@ class ZLinkHostSpotAddressTransport {
     }
     async requestToSpotAddressScoped(spotId, request, call) {
         const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
-        const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
-        try {
-            const resolution = await this.resolveExisting(spotId, deadline.signal, call);
-            const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
-            if (resolution !== undefined && 'kind' in resolution)
-                call = this.reactivationCall(resolution, call);
-            deadline.requireRemaining();
-            if (existing === undefined) {
-                return await this.requestToMissingInstance(spotId, request, call, deadline, resolution);
-            }
-            this.validateExisting(existing, call);
+        return this.requests.request(timeoutMs, call.signal, async (requestOperation) => {
+            const deadline = createSpotAddressDeadline(requestOperation, call.signal);
             try {
-                return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
+                for (;;) {
+                    deadline.requireRemaining();
+                    const resolution = await (0, request_deadline_1.waitRequestReply)(this.resolveExisting(spotId, deadline.signal, call), 'Spot address resolve', requestOperation, () => deadline.close());
+                    const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+                    if (resolution !== undefined && 'kind' in resolution)
+                        call = this.reactivationCall(resolution, call);
+                    deadline.requireRemaining();
+                    try {
+                        if (existing === undefined) {
+                            return await this.requestToMissingInstance(spotId, request, call, deadline, resolution);
+                        }
+                        this.validateExisting(existing, call);
+                        return await this.requestToExistingSpot(spotId, request, call, existing, deadline);
+                    }
+                    catch (error) {
+                        if ((existing !== undefined || isPreAdmissionStaleRoute(error)) &&
+                            isSpotRouteRefreshError(error)) {
+                            this.options.resolver()?.invalidate?.(spotId);
+                        }
+                        // §9 keeps admission-before-stale-route handling in this logical request.
+                        if (call.instanceSpot && isPreAdmissionStaleRoute(error))
+                            continue;
+                        if (existing !== undefined) {
+                            this.reportInstanceRequestError(spotId, request, error, existing.routerChannelId, existing.targetNodeRid, existing.stableType, addressedInstanceErrorReason(error));
+                        }
+                        throw error;
+                    }
+                }
             }
             catch (error) {
-                if (isSpotRouteRefreshError(error)) {
-                    this.options.resolver()?.invalidate?.(spotId);
-                }
-                // Failover policy §4.4: SpotMoving is the owner's Ready owner-fence
-                // refusal, made before admission. With Instance intent, one authority
-                // read under the same deadline decides: Missing means Close released
-                // the incarnation, so the request activates a new one. Any other
-                // answer, and any message the owner admitted, keeps this terminal.
-                if (call.instanceSpot &&
-                    isOwnerFenceRefusal(error) &&
-                    (await this.resolveExisting(spotId, deadline.signal)) === undefined) {
-                    deadline.requireRemaining();
-                    return await this.requestToMissingInstance(spotId, request, call, deadline);
+                if (error instanceof contracts_1.ZLinkFrameworkException &&
+                    (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Spot request for '${String(spotId)}' exceeded its end-to-end deadline.`, true, error);
                 }
-                this.reportInstanceRequestError(spotId, request, error, existing.routerChannelId, existing.targetNodeRid, existing.stableType, addressedInstanceErrorReason(error));
                 throw error;
             }
-        }
-        catch (error) {
-            if (deadline.expired() &&
-                !(error instanceof contracts_1.ZLinkFrameworkException &&
-                    (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) ===
-                        framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound)) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Spot request for '${String(spotId)}' exceeded its end-to-end deadline.`, true, error);
+            finally {
+                deadline.close();
             }
-            throw error;
-        }
-        finally {
-            deadline.close();
-        }
+        });
     }
     async requestToExistingSpot(spotId, request, call, existing, deadline) {
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
-        const reply = await (0, abort_1.awaitWithAbort)(this.options.routed.requestToSpot(existing, request, {
-            instanceSpot: call.instanceSpot,
-            timeoutMs: deadline.requireRemaining(),
-            signal: deadline.signal,
-            metadata: call.metadata,
-            onAdmitted: call.onAdmitted
-        }), deadline.signal);
+        // The address request owns the terminal entry. Observe the wire stage so
+        // a pre-admission refusal can reach the authority decision in §9.
+        const stage = new Promise((resolve, reject) => {
+            const result = this.options.routed.requestToSpot(existing, request, {
+                instanceSpot: call.instanceSpot,
+                timeoutMs: deadline.requireRemaining(),
+                deadlineMs: deadline.deadlineMs,
+                signal: deadline.signal,
+                metadata: call.metadata,
+                onAdmitted: call.onAdmitted,
+                requestOperation: deadline.operation
+            }, {
+                operationCompleted: (_id, value) => resolve(value),
+                operationFailed: (_id, error) => reject(error)
+            });
+            if (result.operation === undefined)
+                void (0, request_result_1.mapZLinkRequestReply)(result).then(resolve, reject);
+        });
+        const reply = await (0, request_deadline_1.waitRequestReply)(stage, 'Spot request', deadline.operation);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
         return reply;
     }
@@ -174,9 +189,9 @@ class ZLinkHostSpotAddressTransport {
         const table = this.options.completions(selected.meshName);
         if (table === undefined)
             throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata, call.onAdmitted), deadline.signal);
+        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata, call.onAdmitted, deadline.operation), deadline.signal, deadline.operation);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, selected.meshName, selected.target.stableType, selected.target.targetNodeRid);
-        const completion = await (0, abort_1.awaitWithAbort)(completionPromise, deadline.signal);
+        const completion = await completionPromise;
         try {
             if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
                 const error = missingInstanceRequestFailure(completion.terminalResult, completion.failureErrno);
@@ -360,16 +375,16 @@ function isSpotRouteRefreshError(error) {
     if (!(error instanceof contracts_1.ZLinkFrameworkException))
         return false;
     const kind = (0, framework_errors_internal_1.internalFrameworkErrorKind)(error);
-    return (kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
-        kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
-        kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving ||
+    return (isPreAdmissionStaleRoute(error) ||
+        kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
         kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound ||
-        kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale ||
         kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected);
 }
-function isOwnerFenceRefusal(error) {
+function isPreAdmissionStaleRoute(error) {
     return (error instanceof contracts_1.ZLinkFrameworkException &&
-        (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving);
+        ((0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving ||
+            (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale ||
+            (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale));
 }
 function submitResultReason(status) {
     switch (status) {
@@ -421,34 +436,19 @@ function addressedInstanceErrorReason(error) {
     }
     return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException;
 }
-function createSpotAddressDeadline(timeoutMs, parent) {
+function createSpotAddressDeadline(operation, parent) {
     const startedAtMs = performance.now();
     const startedAtUnixMs = Date.now();
-    const deadlineMs = startedAtMs + Math.max(0, timeoutMs);
+    const deadlineMs = operation.deadlineMs ?? Number.POSITIVE_INFINITY;
     const controller = new AbortController();
-    let expired = false;
-    let timeout;
-    const expire = () => {
-        expired = true;
-        controller.abort();
-    };
-    const arm = () => {
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        const remainingMs = deadlineMs - performance.now();
-        if (remainingMs <= 0) {
-            expire();
-            return;
-        }
-        timeout = setTimeout(expire, remainingMs);
-    };
-    arm();
     const abort = () => controller.abort(parent?.reason);
     if (parent?.aborted === true)
         abort();
     else
         parent?.addEventListener('abort', abort, { once: true });
     return {
+        operation,
+        deadlineMs,
         get deadlineUnixMs() {
             return Math.round(startedAtUnixMs + (deadlineMs - startedAtMs));
         },
@@ -456,15 +456,12 @@ function createSpotAddressDeadline(timeoutMs, parent) {
         requireRemaining() {
             const remainingMs = deadlineMs - performance.now();
             if (remainingMs <= 0) {
-                expired = true;
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, 'Spot address operation exceeded its end-to-end deadline.', true);
             }
             return Math.max(1, Math.ceil(remainingMs));
         },
-        expired: () => expired,
         close() {
-            if (timeout !== undefined)
-                clearTimeout(timeout);
+            controller.abort();
             parent?.removeEventListener('abort', abort);
         }
     };

package/dist/runtime/host/spot-runtime-options-factory.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotRuntimeOptionsFactory = void 0;
+const Registration_1 = require("../../contracts/Configuration/Registration");
 const routing_id_1 = require("../routing-id");
 const contracts_1 = require("../../contracts");
 const actors_1 = require("../actors");
@@ -14,6 +15,7 @@ class ZLinkSpotRuntimeOptionsFactory {
     create(actorTransferRuntime) {
         const spotRouterChannelIdForMesh = this.options.meshRouters.spotRouterChannelIdByMesh();
         return {
+            defaultRequestTimeoutMs: this.options.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS,
             nodeRid: undefined,
             nodeRidProvider: (meshName) => this.meshNodeRoutingId(meshName),
             nodeGenerationProvider: (meshName) => this.options.spotNodeRuntime()?.meshNode(meshName)?.status().lifecycleGeneration,

package/dist/runtime/host/user-spot-creation-coordinator.d.ts

@@ -1,12 +1,14 @@
 import { type RoutingId, type SpotRef, type ZLinkSpotCreateResult } from '../../contracts';
 import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
 import type { ServiceDirectSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../foundation/service-stateful-wire-codec';
+import type { ZLinkOwnerLeaseTracker } from '../locations/lease-tracker';
 import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
 import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
 import type { ZLinkLocalSpotCreateResult } from '../spots/spot-manager-internal-contracts';
 export interface ZLinkUserSpotCreationCoordinatorOptions {
-    readonly relocationPolicy?: (meshName: string, stableType: string) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
+    readonly relocationPolicy?: (meshName: string | undefined, stableType: string) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
     readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
+    readonly leaseTracker: Pick<ZLinkOwnerLeaseTracker, 'isOwnerTokenLive'>;
     readonly target: (request: Pick<ZLinkUserSpotCreationRequest, 'meshName' | 'stableType'>, signal?: AbortSignal, excludedNodeRids?: ReadonlySet<string>) => Promise<{
         readonly meshName: string;
         readonly nodeRid: RoutingId;

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -35,6 +35,17 @@ class ZLinkUserSpotCreationCoordinator {
         let target;
         let reserved;
         for (;;) {
+            try {
+                const spot = await this.awaitReady(request, signal);
+                if (spot !== undefined) {
+                    deadline.close();
+                    return { result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing }, spot };
+                }
+            }
+            catch (error) {
+                deadline.close();
+                throw error;
+            }
             try {
                 target = await this.options.target(request, signal, excludedNodeRids);
             }
@@ -45,6 +56,15 @@ class ZLinkUserSpotCreationCoordinator {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'User Spot placement provider failed.', false, error);
             }
             if (target === undefined) {
+                try {
+                    const current = await this.options.store.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(request.spotId)), signal);
+                    if (current.kind !== 'missing')
+                        continue;
+                }
+                catch (error) {
+                    deadline.close();
+                    throw error;
+                }
                 deadline.close();
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, 'No eligible User Spot placement target is ready.', true);
             }
@@ -98,28 +118,11 @@ class ZLinkUserSpotCreationCoordinator {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'User Spot reservation Store operation failed.', false, error);
             }
             if (reserved.kind === 'alreadyExists' ||
-                (reserved.kind === 'conflict' &&
-                    reserved.current.kind === 'snapshot' &&
-                    reserved.current.allocation.objectKind === 'user_spot' &&
-                    reserved.current.allocation.stableType === request.stableType)) {
-                if (request.generatedIdentity === true) {
-                    deadline.close();
-                    throw spotIdConflict(request.spotId);
-                }
-                try {
-                    const spot = await this.awaitReady(request, signal);
-                    if (spot !== undefined) {
-                        deadline.close();
-                        return { result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing }, spot };
-                    }
-                }
-                catch (error) {
-                    deadline.close();
-                    throw error;
-                }
+                (reserved.kind === 'conflict' && reserved.current.kind === 'snapshot'))
                 continue;
-            }
-            if (reserved.kind !== 'placementCapacityExhausted')
+            if (reserved.kind === 'placementCapacityExhausted')
+                continue;
+            if (!(reserved.kind === 'conflict' && reserved.current.kind === 'missing'))
                 break;
             excludedNodeRids.add((0, routing_id_1.encodeRoutingIdStorageHex)(target.nodeRid));
         }
@@ -426,10 +429,35 @@ class ZLinkUserSpotCreationCoordinator {
             const current = await this.options.store.readAuthority(key, signal);
             if (current.kind === 'missing')
                 return undefined;
+            if (request.generatedIdentity === true)
+                throw spotIdConflict(request.spotId);
             if (current.allocation.objectKind !== 'user_spot' ||
                 current.allocation.stableType !== request.stableType) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `User Spot '${String(request.spotId)}' has another stable type.`);
             }
+            const ownerLive = await this.options.leaseTracker.isOwnerTokenLive({
+                ownerId: current.ownerId,
+                leaseGeneration: current.ownerLeaseGeneration
+            }, signal);
+            if (!ownerLive || current.allocation.state !== 'active') {
+                const release = this.options.store.releaseEndedReservation;
+                if (release === undefined) {
+                    throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.NotConfigured, 'User Spot creation requires repository ended-owner release support.');
+                }
+                if (await release.call(this.options.store, key, current.storeVersion.value, signal, {
+                    key: { kind: 'user_spot', globalId: String(request.spotId) },
+                    intent: { stableType: request.stableType },
+                    actorRelocationPolicy: this.options.relocationPolicy?.(request.meshName, request.stableType)
+                }))
+                    continue;
+                const confirmed = await this.options.store.readAuthority(key, signal);
+                if (confirmed.kind === 'missing' ||
+                    confirmed.storeVersion.value !== current.storeVersion.value)
+                    continue;
+                if (!ownerLive) {
+                    throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot authority owner lease is unavailable.');
+                }
+            }
             if (current.allocation.state === 'active' &&
                 (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(current.payload) === undefined) {
                 return spotRef(current, request);

package/dist/runtime/internal-observation.d.ts

@@ -0,0 +1 @@
+export declare const inspectRuntime: unique symbol;

package/dist/runtime/internal-observation.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectRuntime = void 0;
+// Internal snapshots are available only through this module, not a package entry.
+exports.inspectRuntime = Symbol('zlink.internal.runtime-observation');

package/dist/runtime/locations/actor-location-claims.d.ts

@@ -32,7 +32,7 @@ export declare class ZLinkActorLocationClaims {
     claim(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration: bigint): Promise<void>;
     takeoverJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    commitMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
+    commitMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint, signal?: AbortSignal): Promise<void>;
     release(_actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     owns(_actorType: string, actorId: string): boolean;
     snapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/actor-location-claims.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorLocationClaims = exports.ZLinkActorClaimStatus = void 0;
+const Errors_1 = require("../../contracts/Errors");
 const internal_location_contracts_1 = require("./internal-location-contracts");
 const Spots_1 = require("../../contracts/Spots");
 const key_codec_1 = require("./key-codec");
@@ -150,7 +151,7 @@ class ZLinkActorLocationClaims {
         });
         return { status: ZLinkActorClaimStatus.Claimed, claimed, generation: result.generation };
     }
-    async commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+    async commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration, signal) {
         const actorId = actorRef.actorId;
         const store = this.authorityStore;
         const owner = this.runtime.currentOwnerToken;
@@ -158,12 +159,12 @@ class ZLinkActorLocationClaims {
             throw new Error('Actor membership commit requires Location Store authority and owner.');
         }
         const key = (0, authority_key_codec_1.encodeAuthorityKey)('actor', actorId);
-        const current = await store.readAuthority(key);
+        const current = await store.readAuthority(key, signal);
         if (!matchesActorAuthority(current, actorRef, owner) ||
             current.allocation.stableType !== actorType ||
             current.authorityOwnerGeneration !== authorityOwnerGeneration ||
             current.allocation.descriptorLifecycleGeneration !== ownerNodeGeneration) {
-            throw new Error(`Actor '${actorId}' membership authority fence does not match.`);
+            throw new Errors_1.ZLinkFrameworkException(classifyMembershipAuthorityFailure(current, actorRef), `Actor '${actorId}' membership authority fence does not match.`);
         }
         const identity = (0, actor_authority_publication_1.decodeActorAuthorityIdentity)(current.payload, current.objectGeneration);
         if (identity === undefined ||
@@ -173,15 +174,18 @@ class ZLinkActorLocationClaims {
             identity.owner.leaseGeneration !== owner.leaseGeneration ||
             !(0, routing_id_1.routingIdsEqual)(identity.actor.nodeRid, actorRef.nodeRid) ||
             identity.meshName !== actorRef.meshName) {
-            throw new Error(`Actor '${actorId}' membership authority identity does not match.`);
+            throw new Errors_1.ZLinkFrameworkException(Errors_1.ZLinkFrameworkErrorKind.Unavailable, `Actor '${actorId}' membership authority identity does not match.`);
         }
         const result = await store.compareExchangeAuthority(key, current.storeVersion, {
             kind: 'put',
             generationTransition: 'preserve',
             payload: (0, actor_authority_publication_1.rewriteActorAuthorityRoute)(current.payload, actorRef, String(spotId), spotGeneration, spotKind)
-        });
+        }, signal);
         if (result.kind !== 'stored') {
-            throw new Error(`Actor '${actorId}' membership commit was rejected with status ${result.kind}.`);
+            throw new Errors_1.ZLinkFrameworkException(result.kind === 'conflict'
+                ? (result.membershipFailure ??
+                    classifyMembershipAuthorityFailure(result.current, actorRef))
+                : Errors_1.ZLinkFrameworkErrorKind.InternalFailure, `Actor '${actorId}' membership commit was rejected with status ${result.kind}.`);
         }
     }
     async release(_actorType, actorId, actorRef) {
@@ -328,6 +332,11 @@ class ZLinkActorLocationClaims {
     }
 }
 exports.ZLinkActorLocationClaims = ZLinkActorLocationClaims;
+function classifyMembershipAuthorityFailure(current, actorRef) {
+    return current.kind === 'snapshot' && current.objectGeneration !== actorRef.objectGeneration
+        ? Errors_1.ZLinkFrameworkErrorKind.InvalidOperation
+        : Errors_1.ZLinkFrameworkErrorKind.Unavailable;
+}
 function matchesActorAuthority(current, actorRef, ownerToken) {
     return (current.kind === 'snapshot' &&
         current.ownerId === ownerToken.ownerId &&

package/dist/runtime/locations/auto-connect-loop.d.ts

@@ -13,7 +13,6 @@ export interface ZLinkAutoConnectLoopOptions {
     readonly clearTimer?: (handle: unknown) => void;
 }
 export declare class ZLinkAutoConnectLoop {
-    private readonly lane;
     private readonly reconciler;
     private readonly options;
     private readonly meshName;

package/dist/runtime/locations/auto-connect-loop.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkAutoConnectLoop = void 0;
 const Options_1 = require("../../contracts/Locations/Options");
-const state_lane_1 = require("../execution/state-lane");
 class ZLinkAutoConnectLoop {
-    lane = new state_lane_1.ZLinkStateLane();
     reconciler;
     options;
     meshName;
@@ -29,18 +27,21 @@ class ZLinkAutoConnectLoop {
         this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
     }
     async start(signal) {
-        if (await this.lane.run(() => this.controller !== undefined))
+        if (this.controller !== undefined)
             return;
-        await this.tick(signal);
-        const started = await this.lane.run(() => {
-            if (this.controller !== undefined)
-                return false;
-            this.controller = new AbortController();
-            return true;
-        });
-        if (!started)
-            return;
-        this.scheduleNext();
+        // Reserve the lifecycle before yielding so stop also owns the first publication.
+        const controller = new AbortController();
+        this.controller = controller;
+        try {
+            await this.tick(signal);
+        }
+        catch (error) {
+            if (this.controller === controller) {
+                await this.prepareTransportShutdown();
+            }
+            throw error;
+        }
+        this.scheduleNext(controller);
     }
     async requestPeerReconcile(meshName, _peerRid) {
         const controller = this.controller;
@@ -74,9 +75,14 @@ class ZLinkAutoConnectLoop {
     }
     async tick(signal) {
         const controller = this.controller;
+        const tickSignal = controller === undefined
+            ? signal
+            : signal === undefined
+                ? controller.signal
+                : AbortSignal.any([signal, controller.signal]);
         await this.enqueueTick(async () => {
-            if (controller?.signal.aborted !== true)
-                await this.tickCore(signal ?? controller?.signal);
+            if (tickSignal?.aborted !== true)
+                await this.tickCore(tickSignal);
         });
     }
     enqueueTick(operation) {
@@ -118,15 +124,15 @@ class ZLinkAutoConnectLoop {
         this.lastTickFailed = this.reconciler.storeFailed;
         return this.lastTickFailed;
     }
-    scheduleNext() {
-        if (this.controller === undefined || this.controller.signal.aborted) {
+    scheduleNext(controller) {
+        if (this.controller !== controller || controller.signal.aborted) {
             return;
         }
         this.timer = this.setTimer(() => {
             this.timer = undefined;
-            void this.tick(this.controller?.signal)
+            void this.tick(controller.signal)
                 .catch(() => undefined)
-                .finally(() => this.scheduleNext());
+                .finally(() => this.scheduleNext(controller));
         }, this.options.pollingIntervalMs);
     }
 }

package/dist/runtime/locations/auto-connect-planner.js

@@ -94,12 +94,9 @@ function targetOf(peer) {
     };
 }
 function isAutoConnectSelf(local, peer) {
-    if (local.nodeRid !== undefined &&
+    return (local.nodeRid !== undefined &&
         peer.nodeRid !== undefined &&
-        (0, routing_id_1.routingIdsEqual)(local.nodeRid, peer.nodeRid)) {
-        return true;
-    }
-    return peer.endpoint === local.endpoint;
+        (0, routing_id_1.routingIdsEqual)(local.nodeRid, peer.nodeRid));
 }
 function shouldDialAutoConnectPeer(local, peer) {
     switch (local.autoConnectType) {

package/dist/runtime/locations/auto-connect-reconciler.d.ts

@@ -47,6 +47,7 @@ export declare class ZLinkAutoConnectReconciler {
     disconnectPeers(): void;
     unpublishLocal(signal?: AbortSignal): Promise<void>;
     private disconnectIfNeeded;
+    private publishLocalForTick;
     private publishLocal;
     private prepareUnpublishLocalCore;
     private preparePublishLocalCore;