@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/locations/in-memory-authority-store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkInMemoryAuthorityStore = void 0;
+const routing_id_1 = require("../routing-id");
 const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
@@ -210,6 +211,7 @@ class ZLinkInMemoryAuthorityStore {
                 ? request === undefined
                 : current.creation === undefined))
             return false;
+        let members = [];
         if (current.snapshot.allocation.state === 'active') {
             let unavailable = false;
             for (const aggregate of this.aggregates.values()) {
@@ -233,20 +235,10 @@ class ZLinkInMemoryAuthorityStore {
                         spot.stableType !== request.intent.stableType ||
                         spot.spotId !== request.key.globalId ||
                         spot.activationRecovery !== undefined;
-                if (spot?.kind === 'user_spot') {
-                    unavailable ||=
-                        this.validation.hasSpotMembers?.(spot.spotId, current.snapshot.objectGeneration) ===
-                            true;
-                    for (const row of this.rows.values()) {
-                        if (row.snapshot.allocation.objectKind !== 'actor')
-                            continue;
-                        const actor = (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(row.snapshot.payload));
-                        unavailable ||=
-                            actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User &&
-                                actor.currentSpotId === spot.spotId &&
-                                actor.currentSpotGeneration === current.snapshot.objectGeneration;
-                    }
-                }
+                if (spot?.kind === 'user_spot' &&
+                    !unavailable &&
+                    request?.actorRelocationPolicy === 'disabled')
+                    members = this.endedSpotMembers(key.value, current.snapshot, spot.spotId);
             }
             if (unavailable || request?.actorRelocationPolicy !== 'disabled')
                 throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Object owner lease is unavailable.');
@@ -258,11 +250,59 @@ class ZLinkInMemoryAuthorityStore {
             return false;
         this.adjustCapacity(current.snapshot.allocation.state === 'active' ? this.activeCapacity : this.pendingCapacity, current.snapshot.allocation, -1);
         this.rows.delete(key.value);
+        for (const memberKey of members) {
+            const member = this.rows.get(memberKey);
+            this.adjustCapacity(this.activeCapacity, member.snapshot.allocation, -1);
+            this.rows.delete(memberKey);
+        }
         if (current.snapshot.allocation.state === 'reserved' && current.creation !== undefined)
             this.creationTerminals.set(current.creation.reservationId, 'aborted');
         this.scanRevision++;
         return true;
     }
+    /**
+     * Every Actor membership of the old User Spot incarnation must belong to an ended-owner
+     * member (location runtime §6.1): a steady Ready, activated authority outside any aggregate
+     * with an invalid owner lease. The release must fit one provider batch; its key set mirrors
+     * the provider repository batch (authorities, owner leases, descriptor and capacity records).
+     */
+    endedSpotMembers(spotKey, spot, spotId) {
+        const descriptorKey = (descriptor) => `${descriptor.meshName}\0${String(descriptor.rid)}`;
+        const batchKeys = new Set([
+            `authority:${spotKey}`,
+            `owner:${spot.ownerId}`,
+            `descriptor:${descriptorKey(spot.allocation.descriptor)}`,
+            `capacity:${descriptorKey(spot.allocation.descriptor)}`
+        ]);
+        const members = [];
+        for (const [memberKey, row] of this.rows) {
+            if (row.snapshot.allocation.objectKind !== 'actor')
+                continue;
+            const actor = (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(row.snapshot.payload));
+            if (actor?.currentSpotKind !== contracts_2.ZLinkSpotKind.User ||
+                actor.currentSpotId !== spotId ||
+                actor.currentSpotGeneration !== spot.objectGeneration)
+                continue;
+            if (row.snapshot.allocation.state !== 'active' ||
+                [...this.aggregates.values()].some((aggregate) => aggregate.state === 'prepared' &&
+                    aggregate.request.participants.some((participant) => participant.authorityKey.value === memberKey)) ||
+                relocationAuthorityCodec.read(row.snapshot.payload) !== undefined ||
+                (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)(row.snapshot.payload)?.state !== 'ready')
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a relocating or unactivated member.');
+            if (this.validation.isOwnerLive({
+                ownerId: row.snapshot.ownerId,
+                leaseGeneration: row.snapshot.ownerLeaseGeneration
+            }))
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a member with a live owner lease.');
+            members.push(memberKey);
+            batchKeys.add(`authority:${memberKey}`);
+            batchKeys.add(`owner:${row.snapshot.ownerId}`);
+            batchKeys.add(`capacity:${descriptorKey(row.snapshot.allocation.descriptor)}`);
+        }
+        if (batchKeys.size > Stores_1.ZLINK_PROVIDER_MAX_WRITE_KEYS)
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot member release exceeds one Location Store batch.');
+        return members;
+    }
     async reserve(request, signal) {
         signal?.throwIfAborted();
         validateReserve(request);
@@ -882,7 +922,7 @@ function creationTarget(request) {
 }
 function sameCreationTarget(target, actual) {
     return (target.descriptor.meshName === actual.meshName &&
-        sameRid(target.descriptor.rid, actual.nodeRid) &&
+        (0, routing_id_1.routingIdsEqual)(target.descriptor.rid, actual.nodeRid) &&
         target.lifecycleGeneration === actual.nodeLifecycleGeneration &&
         sameOwner(target.owner, actual.owner));
 }
@@ -890,10 +930,7 @@ function sameOwner(left, right) {
     return left.ownerId === right.ownerId && left.leaseGeneration === right.leaseGeneration;
 }
 function sameDescriptor(left, right) {
-    return left.meshName === right.meshName && sameRid(left.rid, right.rid);
-}
-function sameRid(left, right) {
-    return String(left) === String(right);
+    return left.meshName === right.meshName && (0, routing_id_1.routingIdsEqual)(left.rid, right.rid);
 }
 function capacityEntries(descriptor, lifecycle, capacity) {
     return [

package/dist/runtime/locations/in-memory-location-store.js

@@ -63,16 +63,7 @@ class ZLinkInMemoryLocationStore {
                                     spotType.count <=
                                     typeCapacity.limit))));
             },
-            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey),
-            hasSpotMembers: (spotId, objectGeneration) => {
-                for (const actor of this.actors.rows.values()) {
-                    if (actor.spotKind === contracts_1.ZLinkSpotKind.User &&
-                        String(actor.spotId) === spotId &&
-                        actor.spotGeneration === objectGeneration)
-                        return true;
-                }
-                return false;
-            }
+            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
         }, now);
     }
     async readAuthority(key, signal) {

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

@@ -6,6 +6,7 @@ export * from './in-memory-provider-location-store';
 export * from './location-store-repository';
 export * from './in-memory-authority-store';
 export * from './lease-tracker';
+export * from './request-source-resolver';
 export * from './lifecycle';
 export * from './resolvers';
 export * from './runtime';

package/dist/runtime/locations/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./in-memory-provider-location-store"), exports);
 __exportStar(require("./location-store-repository"), exports);
 __exportStar(require("./in-memory-authority-store"), exports);
 __exportStar(require("./lease-tracker"), exports);
+__exportStar(require("./request-source-resolver"), exports);
 __exportStar(require("./lifecycle"), exports);
 __exportStar(require("./resolvers"), exports);
 __exportStar(require("./runtime"), exports);

package/dist/runtime/locations/lease-tracker.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLiveRowFilter = exports.ZLinkOwnerLeaseTracker = void 0;
 const Options_1 = require("../../contracts/Locations/Options");
-const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
-const detachedLeaseRefreshResource = new node_async_hooks_1.AsyncResource('zlink:owner-lease-tracker');
 class ZLinkOwnerLeaseTracker {
     lane = new state_lane_1.ZLinkStateLane();
     store;
@@ -65,7 +63,7 @@ class ZLinkOwnerLeaseTracker {
         if (prepared.snapshot !== undefined)
             return prepared.snapshot;
         if (prepared.start) {
-            void runDetachedLeaseRefresh(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
+            void (0, state_lane_1.startOutsideStateLane)(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
         }
         return await prepared.refresh.promise;
     }
@@ -148,6 +146,3 @@ class ZLinkLiveRowFilter {
     }
 }
 exports.ZLinkLiveRowFilter = ZLinkLiveRowFilter;
-function runDetachedLeaseRefresh(work) {
-    return detachedLeaseRefreshResource.runInAsyncScope(work);
-}

package/dist/runtime/locations/lifecycle.d.ts

@@ -19,8 +19,7 @@ export declare class ZLinkLocationLifecycle {
     claimActor(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setActorRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration?: bigint): Promise<void>;
     takeoverActorJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    notifyActorJoinedSpot(actorType: string, actorId: string, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
-    notifyActorLeftSpot(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
+    commitActorMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
     releaseActor(actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     ownsActor(actorType: string, actorId: string): boolean;
     actorLocationSnapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/lifecycle.js

@@ -34,11 +34,8 @@ class ZLinkLocationLifecycle {
     async takeoverActorJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate) {
         return await this.actorClaims.takeoverJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate);
     }
-    async notifyActorJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration);
-    }
-    async notifyActorLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration);
+    async commitActorMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+        await this.actorClaims.commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration);
     }
     async releaseActor(actorType, actorId, actorRef) {
         await this.actorClaims.release(actorType, actorId, actorRef);

package/dist/runtime/locations/location-store-repository.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkRuntimeMetrics } from '../diagnostics/runtime-metrics';
 import { type ZLinkClientServerServerDescriptor, type ZLinkClientServerServerDescriptorKey, type ZLinkFanoutPublisherDescriptor, type ZLinkFanoutPublisherDescriptorKey, type ZLinkLocationPage, type ZLinkLocationStore, type ZLinkMeshNodeDescriptor, type ZLinkMeshNodeDescriptorKey, type ZLinkPageRequest } from '../../contracts';
 import { ZLinkInMemoryLocationStore } from './in-memory-location-store';
 import { type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkLocationOwnerToken, type ZLinkLocationWriteResult, type ZLinkLocationWriteStatus, type ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkEndedOwnerReleaseIntent, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey, ZLinkLocationWriteIntent } from './internal-location-contracts';
@@ -10,49 +11,98 @@ import { type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActor
  */
 export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     private readonly nowProvider;
+    private readonly metrics?;
     private readonly provider;
+    private readonly confirmedCapacities;
     private readonly aggregateInventory;
-    constructor(provider: ZLinkLocationStore, nowProvider?: () => Date);
+    constructor(provider: ZLinkLocationStore, nowProvider?: () => Date, metrics?: ZLinkRuntimeMetrics | undefined);
+    private observeStore;
+    confirmedCapacity(key: ZLinkMeshNodeDescriptorKey, limits: ZLinkMeshNodeDescriptor['populationCapacity']): ZLinkMeshNodeDescriptor['populationCapacity'] | undefined;
     readAuthority(key: ZLinkAuthorityKey, signal?: AbortSignal): Promise<ZLinkAuthorityReadResult>;
+    private readAuthorityRequest;
     listAuthorities(prefix: string, cursor: ZLinkAuthorityScanCursor | undefined, limit: number, signal?: AbortSignal): Promise<ZLinkAuthorityScanResult>;
+    private listAuthoritiesRequest;
     compareExchangeAuthority(key: ZLinkAuthorityKey, expectedStoreVersion: ZLinkAuthorityStoreVersion, mutation: ZLinkAuthorityMutation, signal?: AbortSignal): Promise<ZLinkAuthorityCompareExchangeResult>;
+    private compareExchangeAuthorityRequest;
     prepareAggregate(request: ZLinkAggregatePrepareRequest, signal?: AbortSignal): Promise<ZLinkAggregatePrepareResult>;
+    private prepareAggregateRequest;
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;
+    private commitAggregateRequest;
     private commitAggregateCore;
     abortAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateAbortResult>;
+    private abortAggregateRequest;
     releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
+    private releaseEndedReservationRequest;
     private tryReleaseEndedReservation;
+    /**
+     * Reads every Actor membership of one User Spot incarnation from complete snapshot scans
+     * (location runtime §6.1), from Actor authorities alone. An expired snapshot
+     * discards the earlier pages and restarts; a Store failure propagates. A member authority
+     * that is relocating, part of an aggregate or not yet activated keeps the Spot.
+     */
+    private readEndedSpotMembers;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
+    private reserveRequest;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectCommitResult>;
+    private commitRequest;
     abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectAbortResult>;
+    private abortRequest;
     completeCreation(request: ZLinkObjectCreationCompleteRequest, signal?: AbortSignal): Promise<ZLinkObjectCreationCompleteResult>;
+    private completeCreationRequest;
     readCreationTerminal(operation: ZLinkCreationOperationIdentity, signal?: AbortSignal): Promise<ZLinkCreationTerminalReadResult>;
+    private readCreationTerminalRequest;
     claimOwnerLease(ownerId: string, leaseTtlMs: number, signal?: AbortSignal): Promise<ZLinkOwnerLeaseClaimResult>;
+    private claimOwnerLeaseRequest;
     readOwnerLease(ownerId: string, signal?: AbortSignal): Promise<ZLinkOwnerLeaseReadResult>;
+    private readOwnerLeaseRequest;
     renewOwnerLease(token: ZLinkLocationOwnerToken, leaseTtlMs: number, signal?: AbortSignal): Promise<ZLinkOwnerLeaseRenewResult>;
+    private renewOwnerLeaseRequest;
     releaseOwnerLease(token: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkOwnerLeaseReleaseResult>;
+    private releaseOwnerLeaseRequest;
     updateMeshNode(descriptor: ZLinkMeshNodeDescriptor, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateMeshNodeRequest;
     removeMeshNode(key: ZLinkMeshNodeDescriptorKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
+    private removeMeshNodeRequest;
     listMeshNodes(meshName: string, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkMeshNodeDescriptor>>;
+    private listMeshNodesRequest;
     updateClientServer(descriptor: ZLinkClientServerServerDescriptor, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateClientServerRequest;
     removeClientServer(key: ZLinkClientServerServerDescriptorKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
+    private removeClientServerRequest;
     listClientServers(channelName: string, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkClientServerServerDescriptor>>;
+    private listClientServersRequest;
     updateFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateFanoutPublisherRequest;
     removeFanoutPublisher(key: ZLinkFanoutPublisherDescriptorKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
+    private removeFanoutPublisherRequest;
     listFanoutPublishers(channelName: string, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkFanoutPublisherDescriptor>>;
+    private listFanoutPublishersRequest;
     updateSpot(location: ZLinkSpotLocation, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateSpotRequest;
     removeSpot(key: ZLinkSpotLocationKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
+    private removeSpotRequest;
     resolveSpot(key: ZLinkSpotLocationKey, signal?: AbortSignal): Promise<ZLinkSpotLocation | undefined>;
+    private resolveSpotRequest;
     listSpots(filter: ZLinkSpotLocationFilter, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkSpotLocation>>;
+    private listSpotsRequest;
     updateActor(location: ZLinkActorLocation, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateActorRequest;
     removeActor(key: ZLinkActorLocationKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
+    private removeActorRequest;
     resolveActor(key: ZLinkActorLocationKey, signal?: AbortSignal): Promise<ZLinkActorLocation | undefined>;
+    private resolveActorRequest;
     listActors(filter: ZLinkActorLocationFilter, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkActorLocation>>;
+    private listActorsRequest;
     updateRoute(location: ZLinkRouteLocation, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private updateRouteRequest;
     removeRoute(key: ZLinkRouteLocationKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
+    private removeRouteRequest;
     resolveRoute(key: ZLinkRouteLocationKey, signal?: AbortSignal): Promise<ZLinkRouteLocation | undefined>;
+    private resolveRouteRequest;
     listRoutes(filter: ZLinkRouteLocationFilter, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkRouteLocation>>;
+    private listRoutesRequest;
     removeAllByOwner(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<bigint>;
+    private removeAllByOwnerRequest;
     private removeOwnedAuthorities;
     private removeOwnerCleanupBatch;
     private updateDescriptor;