@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -66,13 +66,8 @@ class ZLinkAutoConnectReconciler {
         return this.meshMemberRidHexes.has(encodeRoutingIdHex(nodeRid));
     }
     async tick(signal) {
-        try {
-            await this.publishLocal(signal);
-        }
-        catch {
-            await this.recordStoreFailure();
+        if (!(await this.publishLocalForTick(signal)))
             return;
-        }
         if (!this.reconcilePeers) {
             await this.lane.run(() => {
                 this.storeFailedValue = false;
@@ -86,9 +81,10 @@ class ZLinkAutoConnectReconciler {
                 autoConnectType: this.local.autoConnectType,
                 meshName: this.local.meshName
             }, signal);
+            signal?.throwIfAborted();
         }
         catch {
-            await this.recordStoreFailure();
+            await this.recordStoreFailure(signal);
             return;
         }
         // A restarted Store can accept commands and return an empty live set
@@ -103,17 +99,8 @@ class ZLinkAutoConnectReconciler {
             await this.lane.run(() => {
                 this.localPublished = false;
             });
-            try {
-                const republished = await this.publishLocal(signal);
-                if (!republished) {
-                    await this.recordStoreFailure();
-                    return;
-                }
-            }
-            catch {
-                await this.recordStoreFailure();
+            if (!(await this.publishLocalForTick(signal)))
                 return;
-            }
         }
         if (await this.lane.run(() => this.storeFailedValue)) {
             await this.lane.run(() => {
@@ -267,21 +254,46 @@ class ZLinkAutoConnectReconciler {
             return;
         this.executor.disconnect(target);
     }
+    async publishLocalForTick(signal) {
+        let published;
+        try {
+            published = await this.publishLocal(signal);
+            signal?.throwIfAborted();
+        }
+        catch {
+            await this.recordStoreFailure(signal);
+            return false;
+        }
+        if (!published) {
+            await this.recordStoreFailure(signal);
+            return false;
+        }
+        return true;
+    }
     async publishLocal(signal) {
+        signal?.throwIfAborted();
         const prepared = await this.lane.run(() => this.preparePublishLocalCore());
-        if (prepared === undefined)
-            return await this.lane.run(() => this.localPublished);
+        if (prepared === undefined) {
+            return this.localRow === undefined || (await this.lane.run(() => this.localPublished));
+        }
         const claimed = await this.runtime.writePeer(prepared.row, internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim, signal);
         if (claimed.status === internal_location_contracts_1.ZLinkLocationWriteStatus.Stored) {
-            return await this.lane.run(() => this.completePublishClaimCore(claimed.generation));
+            return await this.lane.run(() => {
+                signal?.throwIfAborted();
+                return this.completePublishClaimCore(claimed.generation);
+            });
         }
-        const renewal = await this.lane.run(() => this.preparePublishRenewalCore(prepared.row, claimed.status));
+        const renewal = await this.lane.run(() => {
+            signal?.throwIfAborted();
+            return this.preparePublishRenewalCore(prepared.row, claimed.status);
+        });
         if (renewal !== undefined) {
             const renewed = await this.runtime.writePeer({
                 ...prepared.row,
                 generation: renewal
             }, internal_location_contracts_1.ZLinkLocationWriteIntent.Renew, signal);
             return await this.lane.run(() => {
+                signal?.throwIfAborted();
                 this.localPublished = renewed.status === internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
                 return this.localPublished;
             });
@@ -317,8 +329,8 @@ class ZLinkAutoConnectReconciler {
             ? this.localGeneration
             : undefined;
     }
-    async recordStoreFailure() {
-        const retryTargets = await this.lane.run(() => this.beginStoreFailureCore());
+    async recordStoreFailure(signal) {
+        const retryTargets = await this.lane.run(() => signal?.aborted === true ? undefined : this.beginStoreFailureCore());
         if (retryTargets === undefined)
             return;
         for (const [key, target] of retryTargets) {

package/dist/runtime/locations/in-memory-authority-store.d.ts

@@ -29,6 +29,7 @@ export declare class ZLinkInMemoryAuthorityStore {
     removeAllByOwner(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<bigint>;
     releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
     acceptsUserSpotMembership(spotId: string, objectGeneration: bigint): boolean;
+    private userSpotMembershipFailure;
     private tryReleaseEndedReservation;
     /**
      * Every Actor membership of the old User Spot incarnation must belong to an ended-owner

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

@@ -121,9 +121,11 @@ class ZLinkInMemoryAuthorityStore {
         if (actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User &&
             (previousActor?.currentSpotKind !== contracts_2.ZLinkSpotKind.User ||
                 previousActor.currentSpotId !== actor.currentSpotId ||
-                previousActor.currentSpotGeneration !== actor.currentSpotGeneration) &&
-            !this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration))
-            return { kind: 'conflict', current: this.read(keyValue) };
+                previousActor.currentSpotGeneration !== actor.currentSpotGeneration)) {
+            const membershipFailure = this.userSpotMembershipFailure(actor.currentSpotId, actor.currentSpotGeneration);
+            if (membershipFailure !== undefined)
+                return { kind: 'conflict', current: this.read(keyValue), membershipFailure };
+        }
         if (mutation.generationTransition === 'reincarnate' &&
             (this.objectGeneration >= MAX_GENERATION || this.ownerGeneration >= MAX_GENERATION)) {
             return { kind: 'generationExhausted' };
@@ -195,13 +197,21 @@ class ZLinkInMemoryAuthorityStore {
         return this.tryReleaseEndedReservation(key, expectedStoreVersion, request);
     }
     acceptsUserSpotMembership(spotId, objectGeneration) {
+        return this.userSpotMembershipFailure(spotId, objectGeneration) === undefined;
+    }
+    userSpotMembershipFailure(spotId, objectGeneration) {
         const row = this.rows.get((0, authority_key_codec_1.encodeAuthorityKey)('user_spot', spotId).value);
-        return (row !== undefined &&
+        if (row === undefined)
+            return contracts_1.ZLinkFrameworkErrorKind.NotFound;
+        return ![...this.aggregates.values()].some((aggregate) => aggregate.state === 'prepared' &&
+            aggregate.request.participants.some((participant) => participant.authorityKey.value === (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', spotId).value)) &&
             row.snapshot.allocation.objectKind === 'user_spot' &&
             row.snapshot.allocation.state === 'active' &&
             row.snapshot.objectGeneration === objectGeneration &&
             (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(row.snapshot.payload)?.kind === 'user_spot' &&
-            this.isOwnerLive(row.snapshot));
+            this.isOwnerLive(row.snapshot)
+            ? undefined
+            : contracts_1.ZLinkFrameworkErrorKind.Unavailable;
     }
     tryReleaseEndedReservation(key, expectedStoreVersion, request) {
         const current = this.rows.get(key.value);

package/dist/runtime/locations/in-memory-location-store.d.ts

@@ -71,9 +71,7 @@ export declare class ZLinkInMemoryLocationStore implements ZLinkDomainLocationSt
     private write;
     private transitionActorTransfer;
     private remove;
-    private removeByOwner;
     private liveOwnerLease;
     private bump;
-    private removeFanoutByOwner;
     private bumpScope;
 }

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

@@ -596,23 +596,7 @@ class ZLinkInMemoryLocationStore {
             lease.leaseExpiresAt.getTime() <= this.now().getTime()) {
             return 0n;
         }
-        const ownerId = owner.ownerId;
-        let removed = Number(await this.authority.removeAllByOwner(owner, signal));
-        for (const [key, row] of [...this.meshNodes.rows]) {
-            if (row.ownerId !== owner.ownerId)
-                continue;
-            this.meshNodes.rows.delete(key);
-            this.releaseEntrySpotIdentity(row);
-            this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, row.meshName);
-            removed++;
-        }
-        removed += this.removeByOwner(this.peers, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Peer, (row) => row.meshName);
-        removed += this.removeByOwner(this.spots, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Spot, (row) => row.meshName);
-        removed += this.removeByOwner(this.actors, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Actor, () => undefined);
-        removed += this.removeByOwner(this.routes, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Route, () => undefined);
-        removed += this.removeByOwner(this.clientServers, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.ClientServer, (row) => row.channelName);
-        removed += this.removeFanoutByOwner(owner);
-        return BigInt(removed);
+        return this.authority.removeAllByOwner(owner, signal);
     }
     claimEntrySpotIdentity(descriptor, descriptorKey) {
         if (descriptor.entrySpotId === undefined)
@@ -710,17 +694,6 @@ class ZLinkInMemoryLocationStore {
         this.bump(kind, meshName);
         return stored(owner.leaseGeneration, this.now());
     }
-    removeByOwner(table, ownerId, ownerOf, kind, meshOf) {
-        let removed = 0;
-        for (const [key, row] of [...table.rows.entries()]) {
-            if (ownerOf(row) === ownerId) {
-                table.rows.delete(key);
-                this.bump(kind, meshOf(row));
-                removed++;
-            }
-        }
-        return removed;
-    }
     liveOwnerLease(ownerId, now) {
         const lease = this.leases.get(ownerId);
         return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
@@ -733,16 +706,6 @@ class ZLinkInMemoryLocationStore {
             this.bumpScope({ kind });
         }
     }
-    removeFanoutByOwner(owner) {
-        let removed = 0;
-        for (const [key, row] of this.fanoutPublishers.rows) {
-            if (row.ownerId !== owner.ownerId)
-                continue;
-            this.fanoutPublishers.rows.delete(key);
-            removed++;
-        }
-        return removed;
-    }
     bumpScope(scope) {
         const key = stampKey(scope);
         this.stamps.set(key, (this.stamps.get(key) ?? 0n) + 1n);

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

@@ -19,7 +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>;
-    commitActorMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
+    commitActorMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint, signal?: AbortSignal): 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,8 +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 commitActorMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
-        await this.actorClaims.commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration);
+    async commitActorMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration, signal) {
+        await this.actorClaims.commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration, signal);
     }
     async releaseActor(actorType, actorId, actorRef) {
         await this.actorClaims.release(actorType, actorId, actorRef);

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

@@ -104,7 +104,6 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     removeAllByOwner(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<bigint>;
     private removeAllByOwnerRequest;
     private removeOwnedAuthorities;
-    private removeOwnerCleanupBatch;
     private updateDescriptor;
     private writeDescriptorWithReconciliation;
     private removeDescriptor;