@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/locations/auto-connect-reconciler.ts

@@ -101,12 +101,7 @@ export class ZLinkAutoConnectReconciler {
   }
 
   async tick(signal?: AbortSignal): Promise<void> {
-    try {
-      await this.publishLocal(signal);
-    } catch {
-      await this.recordStoreFailure();
-      return;
-    }
+    if (!(await this.publishLocalForTick(signal))) return;
 
     if (!this.reconcilePeers) {
       await this.lane.run(() => {
@@ -125,8 +120,9 @@ export class ZLinkAutoConnectReconciler {
         },
         signal
       );
+      signal?.throwIfAborted();
     } catch {
-      await this.recordStoreFailure();
+      await this.recordStoreFailure(signal);
       return;
     }
 
@@ -144,16 +140,7 @@ export 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();
-        return;
-      }
+      if (!(await this.publishLocalForTick(signal))) return;
     }
 
     if (await this.lane.run(() => this.storeFailedValue)) {
@@ -323,21 +310,44 @@ export class ZLinkAutoConnectReconciler {
     this.executor.disconnect(target);
   }
 
+  private async publishLocalForTick(signal?: AbortSignal): Promise<boolean> {
+    let published: boolean;
+    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;
+  }
+
   private async publishLocal(signal?: AbortSignal): Promise<boolean> {
+    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,
       ZLinkLocationWriteIntent.NewClaim,
       signal
     );
     if (claimed.status === 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(
         {
@@ -348,6 +358,7 @@ export class ZLinkAutoConnectReconciler {
         signal
       );
       return await this.lane.run(() => {
+        signal?.throwIfAborted();
         this.localPublished = renewed.status === ZLinkLocationWriteStatus.Stored;
         return this.localPublished;
       });
@@ -397,8 +408,10 @@ export class ZLinkAutoConnectReconciler {
       : undefined;
   }
 
-  private async recordStoreFailure(): Promise<void> {
-    const retryTargets = await this.lane.run(() => this.beginStoreFailureCore());
+  private async recordStoreFailure(signal?: AbortSignal): Promise<void> {
+    const retryTargets = await this.lane.run(() =>
+      signal?.aborted === true ? undefined : this.beginStoreFailureCore()
+    );
     if (retryTargets === undefined) return;
     for (const [key, target] of retryTargets) {
       await this.connectTarget(target, async () => {

package/src/runtime/locations/in-memory-authority-store.ts

@@ -230,10 +230,15 @@ export class ZLinkInMemoryAuthorityStore {
       actor?.currentSpotKind === ZLinkSpotKind.User &&
       (previousActor?.currentSpotKind !== 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)
@@ -322,15 +327,30 @@ export class ZLinkInMemoryAuthorityStore {
   }
 
   acceptsUserSpotMembership(spotId: string, objectGeneration: bigint): boolean {
+    return this.userSpotMembershipFailure(spotId, objectGeneration) === undefined;
+  }
+
+  private userSpotMembershipFailure(
+    spotId: string,
+    objectGeneration: bigint
+  ): ZLinkFrameworkErrorKind.NotFound | ZLinkFrameworkErrorKind.Unavailable | undefined {
     const row = this.rows.get(encodeAuthorityKey('user_spot', spotId).value);
-    return (
-      row !== undefined &&
+    if (row === undefined) return ZLinkFrameworkErrorKind.NotFound;
+    return ![...this.aggregates.values()].some(
+      (aggregate) =>
+        aggregate.state === 'prepared' &&
+        aggregate.request.participants.some(
+          (participant) =>
+            participant.authorityKey.value === encodeAuthorityKey('user_spot', spotId).value
+        )
+    ) &&
       row.snapshot.allocation.objectKind === 'user_spot' &&
       row.snapshot.allocation.state === 'active' &&
       row.snapshot.objectGeneration === objectGeneration &&
       decodeServiceReadySpotAuthority(row.snapshot.payload)?.kind === 'user_spot' &&
       this.isOwnerLive(row.snapshot)
-    );
+      ? undefined
+      : ZLinkFrameworkErrorKind.Unavailable;
   }
 
   private tryReleaseEndedReservation(

package/src/runtime/locations/in-memory-location-store.ts

@@ -1054,52 +1054,7 @@ export class ZLinkInMemoryLocationStore
     ) {
       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(ZLinkLocationKind.Peer, row.meshName);
-      removed++;
-    }
-    removed += this.removeByOwner(
-      this.peers,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Peer,
-      (row) => row.meshName
-    );
-    removed += this.removeByOwner(
-      this.spots,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Spot,
-      (row) => row.meshName
-    );
-    removed += this.removeByOwner(
-      this.actors,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Actor,
-      () => undefined
-    );
-    removed += this.removeByOwner(
-      this.routes,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Route,
-      () => undefined
-    );
-    removed += this.removeByOwner(
-      this.clientServers,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.ClientServer,
-      (row) => row.channelName
-    );
-    removed += this.removeFanoutByOwner(owner);
-    return BigInt(removed);
+    return this.authority.removeAllByOwner(owner, signal);
   }
 
   private claimEntrySpotIdentity(
@@ -1247,24 +1202,6 @@ export class ZLinkInMemoryLocationStore
     return stored(owner.leaseGeneration, this.now());
   }
 
-  private removeByOwner<TRow>(
-    table: RowTable<TRow>,
-    ownerId: string,
-    ownerOf: (row: TRow) => string,
-    kind: ZLinkLocationKind,
-    meshOf: (row: TRow) => string | undefined
-  ): number {
-    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;
-  }
-
   private liveOwnerLease(ownerId: string, now: Date): InMemoryOwnerLease | undefined {
     const lease = this.leases.get(ownerId);
     return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
@@ -1279,16 +1216,6 @@ export class ZLinkInMemoryLocationStore
     }
   }
 
-  private removeFanoutByOwner(owner: ZLinkLocationOwnerToken): number {
-    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;
-  }
-
   private bumpScope(scope: ZLinkLocationChangeStampScope): void {
     const key = stampKey(scope);
     this.stamps.set(key, (this.stamps.get(key) ?? 0n) + 1n);

package/src/runtime/locations/lifecycle.ts

@@ -125,7 +125,8 @@ export class ZLinkLocationLifecycle {
     spotId: RoutingId,
     spotGeneration: bigint,
     spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User,
-    ownerNodeGeneration: bigint
+    ownerNodeGeneration: bigint,
+    signal?: AbortSignal
   ): Promise<void> {
     await this.actorClaims.commitMembership(
       actorType,
@@ -134,7 +135,8 @@ export class ZLinkLocationLifecycle {
       spotId,
       spotGeneration,
       spotKind,
-      ownerNodeGeneration
+      ownerNodeGeneration,
+      signal
     );
   }