effect 4.0.0-beta.99 → 4.0.0-rc.109

package/dist/unstable/cluster/ShardId.js.map

@@ -1 +1 @@
-{"version":3,"file":"ShardId.js","names":["Equal","Hash","hasProperty","PrimaryKey","S","SchemaGetter","TypeId","isShardId","u","ShardId","declare","toCodecJson","link","Struct","group","String","id","Number","decode","transform","make","encode","passthrough","key","shardId","shardIdCache","get","makeProto","set","Map","self","Object","create","ShardIdProto","symbol","that","string","toString","fromStringEncoded","s","index","lastIndexOf","Error","substring","isNaN","fromString","encoded"],"sources":["../../../src/unstable/cluster/ShardId.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"ShardId.js","names":[],"sources":["../../../src/unstable/cluster/ShardId.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/unstable/cluster/Sharding.d.ts

@@ -47,7 +47,7 @@ declare const Sharding_base: Context.ServiceClass<Sharding, "effect/cluster/Shar
      * Constructs a `RpcClient` which can be used to send messages to the
      * specified `Entity`.
      */
-    readonly makeClient: <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>) => Effect.Effect<(entityId: string) => RpcClient.RpcClient.From<Rpcs, MailboxFull | AlreadyProcessingMessage | PersistenceError>>;
+    readonly makeClient: <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>) => Effect.Effect<(entityId: string) => RpcClient.RpcClient.From<Rpcs, MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner>>;
     /**
      * Registers a new entity with the runner.
      */
@@ -72,7 +72,7 @@ declare const Sharding_base: Context.ServiceClass<Sharding, "effect/cluster/Shar
     /**
      * Sends an outgoing message
      */
-    readonly sendOutgoing: (message: Message.Outgoing<any>, discard: boolean) => Effect.Effect<void, MailboxFull | AlreadyProcessingMessage | PersistenceError>;
+    readonly sendOutgoing: (message: Message.Outgoing<any>, discard: boolean) => Effect.Effect<void, MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner>;
     /**
      * Notify sharding that a message has been persisted to storage.
      */

package/dist/unstable/cluster/Sharding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sharding.d.ts","sourceRoot":"","sources":["../../../src/unstable/cluster/Sharding.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Sharding.d.ts","sourceRoot":"","sources":["../../../src/unstable/cluster/Sharding.ts"],"names":[],"mappings":"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"}

package/dist/unstable/cluster/Sharding.js

@@ -21,6 +21,7 @@ import * as Fiber from "../../Fiber.js";
 import * as FiberMap from "../../FiberMap.js";
 import { constant, flow } from "../../Function.js";
 import * as HashRing from "../../HashRing.js";
+import * as InternalRecord from "../../internal/record.js";
 import * as Latch from "../../Latch.js";
 import * as Layer from "../../Layer.js";
 import * as MutableHashMap from "../../MutableHashMap.js";
@@ -47,6 +48,7 @@ import { EntityReaper } from "./internal/entityReaper.js";
 import { hashString } from "./internal/hash.js";
 import { internalInterruptors } from "./internal/interruptors.js";
 import { ResourceMap } from "./internal/resourceMap.js";
+import { effectiveInterval } from "./internal/shardLock.js";
 import * as Message from "./Message.js";
 import * as MessageStorage from "./MessageStorage.js";
 import * as Reply from "./Reply.js";
@@ -75,6 +77,7 @@ import * as Snowflake from "./Snowflake.js";
 export class Sharding extends /*#__PURE__*/Context.Service()("effect/cluster/Sharding") {}
 const make = /*#__PURE__*/Effect.gen(function* () {
   const config = yield* ShardingConfig;
+  const shardLockInterval = effectiveInterval(config);
   const shardGroups = shardGroupConfig(config);
   const getRunnerAddress = () => Option.getOrUndefined(config.runnerAddress);
   const clock = yield* Clock;
@@ -89,8 +92,12 @@ const make = /*#__PURE__*/Effect.gen(function* () {
   const storageEnabled = storage !== MessageStorage.noop;
   const runnerStorage = yield* RunnerStorage;
   const entityManagers = new Map();
+  let entityRegistrationStartMillis;
+  let entityRegistrationFallbackStartMillis;
   const shardAssignments = MutableHashMap.empty();
   const selfShards = MutableHashSet.empty();
+  // open while shard lock storage is healthy
+  const shardLocksHealthyLatch = Latch.makeUnsafe(true);
   // the active shards are the ones that we have acquired the lock for
   const acquiredShards = MutableHashSet.empty();
   const activeShardsLatch = yield* Latch.make(false);
@@ -117,6 +124,9 @@ const make = /*#__PURE__*/Effect.gen(function* () {
   // This should be shutdown last, when all entities have been shutdown, to
   // allow them to move to another runner.
   const releasingShards = MutableHashSet.empty();
+  // Shards whose entities must be force interrupted and locks fully released
+  // before normal reacquisition.
+  const forceReleasingShards = MutableHashSet.empty();
   const initialRunnerAddress = getRunnerAddress();
   if (initialRunnerAddress) {
     const selfAddress = initialRunnerAddress;
@@ -125,26 +135,66 @@ const make = /*#__PURE__*/Effect.gen(function* () {
       return Effect.ignore(runnerStorage.releaseAll(selfAddress));
     });
     const releaseShardsMap = yield* FiberMap.make();
-    const releaseShard = Effect.fnUntraced(function* (shardId) {
+    let forcedShardReleaseRunning = false;
+    // Interrupt the shards' entities, wait for lock health, run the storage
+    // release, then clear the shards' bookkeeping.
+    const runShardRelease = Effect.fnUntraced(function* (shardIds, force, release) {
       const fibers = Arr.empty();
-      for (const state of entityManagers.values()) {
-        if (state.status === "closed") continue;
-        fibers.push(yield* Effect.forkScoped(state.manager.interruptShard(shardId)));
+      for (const shardId of shardIds) {
+        for (const state of entityManagers.values()) {
+          if (state.status === "closed") continue;
+          fibers.push(yield* Effect.forkScoped(state.manager.interruptShard(shardId, {
+            force
+          })));
+        }
       }
       yield* Fiber.joinAll(fibers);
-      yield* runnerStorage.release(selfAddress, shardId);
-      MutableHashSet.remove(releasingShards, shardId);
-      yield* storage.unregisterShardReplyHandlers(shardId);
-    }, Effect.sandbox, (effect, shardId) => effect.pipe(Effect.tapError(cause => Effect.logDebug(`Could not release shard, retrying`, cause).pipe(Effect.annotateLogs({
+      yield* shardLocksHealthyLatch.await;
+      yield* release;
+      for (const shardId of shardIds) {
+        MutableHashSet.remove(releasingShards, shardId);
+        MutableHashSet.remove(forceReleasingShards, shardId);
+        yield* storage.unregisterShardReplyHandlers(shardId);
+      }
+    });
+    const retryShardRelease = annotations => effect => effect.pipe(Effect.sandbox, Effect.tapError(cause => Effect.logDebug(`Could not release shards, retrying`, cause).pipe(Effect.annotateLogs({
       module: "effect/cluster/Sharding",
-      fiber: "releaseShard",
       runner: selfAddress,
+      ...annotations
+    }),
+    // Effect.eventually retries immediately, so space failures to
+    // avoid hot-looping while storage is unavailable.
+    Effect.andThen(Effect.sleep(50)))), Effect.eventually);
+    const releaseShard = Effect.fnUntraced(function* (shardId) {
+      yield* runShardRelease([shardId], MutableHashSet.has(forceReleasingShards, shardId), runnerStorage.release(selfAddress, shardId));
+    }, (effect, shardId) => effect.pipe(retryShardRelease({
+      fiber: "releaseShard",
       shardId
-    }))), Effect.eventually, FiberMap.run(releaseShardsMap, shardId, {
+    }), FiberMap.run(releaseShardsMap, shardId, {
       onlyIfMissing: true
     })));
+    // The forced release ends with `runnerStorage.releaseAll`, which drops
+    // every lock held by this runner. Shards must not be reacquired through the
+    // normal path while it is pending, otherwise the bulk release wipes a lock
+    // the runner already considers acquired.
+    const forcedShardReleasePending = () => forcedShardReleaseRunning || MutableHashSet.size(forceReleasingShards) > 0;
+    const releaseForcedShards = Effect.suspend(() => {
+      if (forcedShardReleaseRunning || MutableHashSet.size(forceReleasingShards) === 0) {
+        return Effect.void;
+      }
+      forcedShardReleaseRunning = true;
+      const shardIds = [...forceReleasingShards];
+      return runShardRelease(shardIds, true, runnerStorage.releaseAll(selfAddress)).pipe(retryShardRelease({
+        fiber: "releaseForcedShards"
+      }), Effect.ensuring(Effect.sync(() => {
+        forcedShardReleaseRunning = false;
+        activeShardsLatch.openUnsafe();
+      })), Effect.forkIn(shardingScope), Effect.asVoid);
+    });
     const releaseShards = Effect.gen(function* () {
+      yield* releaseForcedShards;
       for (const shardId of releasingShards) {
+        if (MutableHashSet.has(forceReleasingShards, shardId)) continue;
         if (FiberMap.hasUnsafe(releaseShardsMap, shardId)) continue;
         yield* releaseShard(shardId);
       }
@@ -160,10 +210,18 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           MutableHashSet.remove(acquiredShards, shardId);
           MutableHashSet.add(releasingShards, shardId);
         }
-        if (MutableHashSet.size(releasingShards) > 0) {
+        if (MutableHashSet.size(releasingShards) > 0 || MutableHashSet.size(forceReleasingShards) > 0) {
           yield* Effect.forkIn(syncSingletons, shardingScope);
           yield* releaseShards;
         }
+        if (!shardLocksHealthyLatch.isOpen()) {
+          continue;
+        }
+        // Wait for the pending bulk release before reacquiring, so it cannot
+        // drop a lock acquired here. `releaseForcedShards` reopens the latch.
+        if (forcedShardReleasePending()) {
+          continue;
+        }
         // if a shard has been assigned to this runner, we acquire it
         const unacquiredShards = MutableHashSet.empty();
         for (const shardId of selfShards) {
@@ -173,15 +231,19 @@ const make = /*#__PURE__*/Effect.gen(function* () {
         if (MutableHashSet.size(unacquiredShards) === 0) {
           continue;
         }
-        const oacquired = yield* runnerStorage.acquire(selfAddress, unacquiredShards).pipe(Effect.timeoutOption(config.shardLockRefreshInterval));
+        const oacquired = yield* runnerStorage.acquire(selfAddress, unacquiredShards).pipe(Effect.timeoutOption(shardLockInterval));
         if (Option.isNone(oacquired)) {
           activeShardsLatch.openUnsafe();
           continue;
         }
         const acquired = oacquired.value;
-        yield* storage.resetShards(acquired).pipe(Effect.ignore, Effect.timeoutOption(config.shardLockRefreshInterval));
+        yield* storage.resetShards(acquired).pipe(Effect.ignore, Effect.timeoutOption(shardLockInterval));
+        // A forced release can start while `acquire` is in flight, so re-check
+        // it here as well as before acquiring.
+        const forcedReleasePending = forcedShardReleasePending();
         for (const shardId of acquired) {
-          if (MutableHashSet.has(releasingShards, shardId) || !MutableHashSet.has(selfShards, shardId)) {
+          if (!shardLocksHealthyLatch.isOpen() || forcedReleasePending || MutableHashSet.has(releasingShards, shardId) || !MutableHashSet.has(selfShards, shardId)) {
+            MutableHashSet.add(releasingShards, shardId);
             continue;
           }
           MutableHashSet.add(acquiredShards, shardId);
@@ -200,8 +262,47 @@ const make = /*#__PURE__*/Effect.gen(function* () {
       fiber: "Shard acquisition loop",
       runner: selfAddress
     }), Effect.forkIn(shardingScope));
-    // refresh the shard locks every `shardLockRefreshInterval`
-    yield* Effect.suspend(() => runnerStorage.refresh(selfAddress, [...acquiredShards, ...releasingShards])).pipe(Effect.flatMap(acquired => {
+    const markShardLocksUnhealthy = cause => Effect.suspend(() => {
+      if (!shardLocksHealthyLatch.closeUnsafe()) return Effect.void;
+      const affectedShards = MutableHashSet.fromIterable([...acquiredShards, ...releasingShards]);
+      MutableHashSet.clear(selfShards);
+      MutableHashSet.clear(acquiredShards);
+      for (const shardId of affectedShards) {
+        MutableHashSet.add(releasingShards, shardId);
+        MutableHashSet.add(forceReleasingShards, shardId);
+      }
+      ClusterMetrics.shards.updateUnsafe(BigInt(0), Context.empty());
+      activeShardsLatch.openUnsafe();
+      return Effect.gen(function* () {
+        yield* Effect.logError("Shard lock storage is unhealthy", cause);
+        yield* Effect.forkIn(syncSingletons, shardingScope, {
+          startImmediately: true
+        });
+        for (const shardId of affectedShards) {
+          for (const state of entityManagers.values()) {
+            if (state.status === "closed") continue;
+            yield* Effect.forkIn(state.manager.interruptShard(shardId, {
+              force: true
+            }), shardingScope, {
+              startImmediately: true
+            });
+          }
+        }
+        activeShardsLatch.openUnsafe();
+      });
+    });
+    const markShardLocksHealthy = Effect.suspend(() => {
+      if (!shardLocksHealthyLatch.openUnsafe()) return Effect.void;
+      MutableHashSet.clear(selfShards);
+      MutableHashMap.forEach(shardAssignments, (runner, shardId) => {
+        if (isLocalRunner(runner)) {
+          MutableHashSet.add(selfShards, shardId);
+        }
+      });
+      activeShardsLatch.openUnsafe();
+      return Effect.logInfo("Shard lock storage has recovered");
+    });
+    const refreshShardLocks = Effect.suspend(() => runnerStorage.refresh(selfAddress, [...acquiredShards, ...releasingShards])).pipe(Effect.flatMap(acquired => {
       for (const shardId of acquiredShards) {
         if (!acquired.includes(shardId)) {
           MutableHashSet.remove(acquiredShards, shardId);
@@ -219,14 +320,14 @@ const make = /*#__PURE__*/Effect.gen(function* () {
     }), Effect.retry({
       times: 5,
       schedule: Schedule.spaced(50)
-    }), Effect.catchCause(cause => Effect.logError("Could not refresh shard locks", cause).pipe(Effect.andThen(clearSelfShards))), Effect.repeat(Schedule.fixed(config.shardLockRefreshInterval)), Effect.forever, Effect.forkIn(shardingScope));
+    }), Effect.timeout(shardLockInterval), Effect.catchCause(markShardLocksUnhealthy));
+    const probeShardLocks = runnerStorage.refresh(selfAddress, []).pipe(Effect.timeout(shardLockInterval), Effect.andThen(markShardLocksHealthy), Effect.catchCause(() => Effect.void));
+    // Refresh shard locks at the lease-safe interval, or probe storage while
+    // lock ownership is uncertain.
+    yield* Effect.suspend(() => shardLocksHealthyLatch.isOpen() ? refreshShardLocks : probeShardLocks).pipe(Effect.repeat(Schedule.fixed(shardLockInterval)), Effect.forever, Effect.forkIn(shardingScope));
     // open the shard latch every poll interval
     yield* activeShardsLatch.open.pipe(Effect.delay(config.entityMessagePollInterval), Effect.forever, Effect.forkIn(shardingScope));
   }
-  const clearSelfShards = Effect.sync(() => {
-    MutableHashSet.clear(selfShards);
-    activeShardsLatch.openUnsafe();
-  });
   // --- Storage inbox ---
   //
   // Responsible for reading unprocessed messages from storage and sending them
@@ -241,22 +342,56 @@ const make = /*#__PURE__*/Effect.gen(function* () {
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open));
   const storageReadLock = Semaphore.makeUnsafe(1);
   const withStorageReadLock = storageReadLock.withPermits(1);
+  // --- Entity residency ---
+  //
+  // A runner-wide counter that bounds how many entities can be resident at
+  // the same time. Entity managers reserve a slot before spawning an entity,
+  // so the sequential storage read loop and concurrent volatile sends share
+  // the same cap.
+  const maxResidentEntities = config.maxResidentEntities;
+  let residentEntityCount = 0;
+  const residencyAtCapacityUnsafe = () => maxResidentEntities !== "unbounded" && residentEntityCount >= maxResidentEntities;
+  const residency = {
+    admitUnsafe() {
+      if (residencyAtCapacityUnsafe()) return false;
+      residentEntityCount++;
+      return true;
+    },
+    releaseUnsafe() {
+      residentEntityCount--;
+      // a slot has freed up, so the storage read loop can admit messages for
+      // entities it previously had to skip
+      if (maxResidentEntities !== "unbounded") {
+        storageReadLatch.openUnsafe();
+      }
+    }
+  };
   if (storageEnabled && initialRunnerAddress) {
     const selfAddress = initialRunnerAddress;
     const entityRegistrationTimeoutMillis = Duration.toMillis(Duration.fromInputUnsafe(config.entityRegistrationTimeout));
-    const storageStartMillis = clock.currentTimeMillisUnsafe();
     yield* Effect.gen(function* () {
       yield* Effect.logDebug("Starting");
       yield* Effect.addFinalizer(() => Effect.logDebug("Shutting down"));
       let index = 0;
       let messages = [];
+      let deliveredThisRead = false;
       const removableNotifications = new Set();
       const resetAddresses = MutableHashSet.empty();
+      const cappedAddresses = MutableHashSet.empty();
+      const markDelivered = Effect.sync(() => {
+        deliveredThisRead = true;
+      });
       const processMessages = Effect.whileLoop({
         while: () => index < messages.length,
         step: () => index++,
         body: () => send
       });
+      const readAndProcess = Effect.fnUntraced(function* (options) {
+        messages = yield* storage.unprocessedMessages(acquiredShards, options);
+        index = 0;
+        yield* processMessages;
+        return messages.length;
+      });
       const send = Effect.catchCause(Effect.suspend(() => {
         const message = messages[index];
         const address = message.envelope.address;
@@ -265,8 +400,12 @@ const make = /*#__PURE__*/Effect.gen(function* () {
         }
         const state = entityManagers.get(address.entityType);
         if (!state) {
-          const sinceStart = clock.currentTimeMillisUnsafe() - storageStartMillis;
-          if (sinceStart < entityRegistrationTimeoutMillis) {
+          const now = clock.currentTimeMillisUnsafe();
+          const registrationStarted = entityRegistrationStartMillis !== undefined;
+          const timeoutStartMillis = entityRegistrationStartMillis ?? (entityRegistrationFallbackStartMillis ??= now);
+          // If registration never starts, allow two intervals from the first missing read before failing.
+          const timeoutMillis = registrationStarted ? entityRegistrationTimeoutMillis : entityRegistrationTimeoutMillis * 2;
+          if (now - timeoutStartMillis < timeoutMillis) {
             // reset address in the case that the entity is slow to register
             MutableHashSet.add(resetAddresses, address);
             return Effect.void;
@@ -280,7 +419,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
         if (message._tag === "IncomingEnvelope" && isProcessing) {
           // If the message might affect a currently processing request, we
           // send it to the entity manager to be processed.
-          return state.manager.send(message);
+          return Effect.tap(state.manager.send(message), markDelivered);
         } else if (isProcessing || state.status === "closing") {
           // If the request is already processing, we skip it.
           // Or if the entity is closing, we skip all incoming messages.
@@ -291,6 +430,13 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           removableNotifications.delete(entry);
           entry.resume(Effect.void);
         }
+        // The runner is at entity capacity, so messages for entities that
+        // are not already resident are skipped. Their claims are released
+        // after the read, so they stay eligible for once a slot frees up.
+        if (residencyAtCapacityUnsafe() && !state.manager.isResidentUnsafe(address)) {
+          MutableHashSet.add(cappedAddresses, address);
+          return Effect.void;
+        }
         // If the entity was resuming in another fiber, we add the message
         // id to the unprocessed set.
         const resumptionState = MutableHashMap.get(entityResumptionState, address);
@@ -301,7 +447,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           }
           return Effect.void;
         }
-        return state.manager.send(message);
+        return Effect.tap(state.manager.send(message), markDelivered);
       }), cause => {
         const message = messages[index];
         const error = Cause.findError(cause);
@@ -317,11 +463,22 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           }));
         }
         if (error.success._tag === "MailboxFull") {
+          const address = message.envelope.address;
+          const state = entityManagers.get(address.entityType);
+          // A resident entity has a full per-entity mailbox; its messages
+          // are resumed from storage once there is capacity again.
           // MailboxFull can only happen for requests, so this cast is safe
-          return resumeEntityFromStorage(message);
+          if (message._tag === "IncomingRequest" && state?.manager.isResidentUnsafe(address)) {
+            return resumeEntityFromStorage(message);
+          }
+          // Otherwise the runner ran out of entity slots while the message
+          // was in flight; leave it in storage.
+          MutableHashSet.add(cappedAddresses, address);
+          return Effect.void;
         }
         return Effect.void;
       });
+      const batchSize = Math.max(1, config.unprocessedMessageBatchSize);
       while (true) {
         // wait for the next poll interval, or if we get notified of a change
         yield* storageReadLatch.await;
@@ -336,19 +493,61 @@ const make = /*#__PURE__*/Effect.gen(function* () {
         if (pendingNotifications.size > 0) {
           pendingNotifications.forEach(entry => removableNotifications.add(entry));
         }
-        messages = yield* storage.unprocessedMessages(acquiredShards);
-        index = 0;
-        yield* processMessages;
-        if (removableNotifications.size > 0) {
-          removableNotifications.forEach(({
-            message,
-            resume
-          }) => {
-            pendingNotifications.delete(message.envelope.requestId);
-            resume(Effect.fail(new EntityNotAssignedToRunner({
-              address: message.envelope.address
-            })));
+        deliveredThisRead = false;
+        let readCount = 0;
+        let fullBatch = false;
+        let exhaustive = false;
+        // First deliver messages for entities that are already resident, so
+        // they keep making progress even when the runner is at entity
+        // capacity.
+        if (residencyAtCapacityUnsafe()) {
+          const residentAddresses = [];
+          for (const state of entityManagers.values()) {
+            if (state.status === "closed") continue;
+            for (const address of state.manager.residentAddressesUnsafe()) {
+              residentAddresses.push(address);
+            }
+          }
+          if (residentAddresses.length > 0) {
+            readCount = yield* readAndProcess({
+              limit: batchSize,
+              addresses: residentAddresses
+            });
+            fullBatch = readCount >= batchSize;
+          }
+        }
+        // Then walk the remaining messages, spawning new entities while the
+        // runner has entity slots left.
+        if (!residencyAtCapacityUnsafe() && readCount < batchSize) {
+          const limit = batchSize - readCount;
+          const read = yield* readAndProcess({
+            limit
           });
+          if (read >= limit) {
+            fullBatch = true;
+          } else if (MutableHashSet.size(cappedAddresses) === 0) {
+            exhaustive = true;
+          }
+        }
+        if (removableNotifications.size > 0) {
+          // On an exhaustive read, a message that was not seen is no longer
+          // processable by this runner. At the entity cap, the messages are
+          // safely persisted and delivered once a slot frees up, so persisted
+          // senders succeed instead of failing. Otherwise the read was
+          // truncated by the batch size and the notifications stay registered
+          // for the immediately following read.
+          const capped = MutableHashSet.size(cappedAddresses) > 0 || residencyAtCapacityUnsafe();
+          if (exhaustive || capped) {
+            removableNotifications.forEach(({
+              message,
+              resume
+            }) => {
+              pendingNotifications.delete(message.envelope.requestId);
+              resume(exhaustive ? Effect.fail(new EntityNotAssignedToRunner({
+                address: message.envelope.address
+              })) : Effect.void);
+            });
+          }
           removableNotifications.clear();
         }
         if (MutableHashSet.size(resetAddresses) > 0) {
@@ -360,8 +559,26 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           }
           MutableHashSet.clear(resetAddresses);
         }
+        // Capture claims skipped because of the entity cap. They are reset in
+        // one storage operation after releasing the read lock.
+        let cappedAddressesToReset;
+        if (MutableHashSet.size(cappedAddresses) > 0) {
+          cappedAddressesToReset = Arr.fromIterable(cappedAddresses);
+          MutableHashSet.clear(cappedAddresses);
+        }
         // let the resuming entities check if they are done
         yield* storageReadLock.release(1);
+        if (cappedAddressesToReset !== undefined) {
+          yield* Effect.ignore(storage.resetAddresses(cappedAddressesToReset));
+        }
+        // A full batch means more messages could be waiting; start the next
+        // read immediately, as long as this read made progress (a full batch
+        // of skipped messages must not spin the loop). When the runner is at
+        // capacity, the next read waits for an entity to be removed or the
+        // next poll interval instead.
+        if (fullBatch && deliveredThisRead) {
+          storageReadLatch.openUnsafe();
+        }
       }
     }).pipe(Effect.scoped, Effect.ensuring(storageReadLock.releaseAll), Effect.catchCause(cause => Effect.logWarning("Could not read messages from storage", cause)), Effect.forever, Effect.annotateLogs({
       module: "effect/cluster/Sharding",
@@ -394,6 +611,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
       const resumptionState = Option.getOrThrow(MutableHashMap.get(entityResumptionState, address));
       let done = false;
       while (!done) {
+        // oxlint-disable-line no-unmodified-loop-condition
         // if the shard is no longer assigned to this runner, we stop
         if (!MutableHashSet.has(acquiredShards, address.shardId)) {
           return;
@@ -533,12 +751,25 @@ const make = /*#__PURE__*/Effect.gen(function* () {
     });
   });
   function sendOutgoing(message, discard, retries) {
+    const isPersisted = Context.get(message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations, Persisted);
+    const shouldFail = !discard && (message._tag === "OutgoingRequest" || message.envelope._tag === "AckChunk");
+    const abandon = error => {
+      if (!isPersisted) {
+        return shouldFail ? Effect.fail(error) : Effect.logDebug("Abandoning outgoing message during shutdown", message.envelope.address);
+      }
+      const persist = message._tag === "OutgoingRequest" ? storage.saveRequest(message) : storage.saveEnvelope(message);
+      return Effect.catchTag(persist, "MalformedMessage", Effect.die).pipe(Effect.andThen(shouldFail ? Effect.fail(error) : Effect.logWarning("Persisting outgoing message abandoned during shutdown", message.envelope.address)));
+    };
     return Effect.catchFilter(Effect.suspend(() => {
       const address = message.envelope.address;
-      const isPersisted = Context.get(message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations, Persisted);
       if (isPersisted && !storageEnabled) {
         return Effect.die("Sharding.sendOutgoing: Persisted messages require MessageStorage");
       }
+      if (shouldFail && MutableRef.get(isShutdown)) {
+        return Effect.fail(new EntityNotAssignedToRunner({
+          address
+        }));
+      }
       const maybeRunner = MutableHashMap.get(shardAssignments, address.shardId);
       const runnerIsLocal = Option.isSome(maybeRunner) && isLocalRunner(maybeRunner.value);
       if (isPersisted) {
@@ -552,11 +783,23 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           address
         }));
       }
-      return runnerIsLocal ? sendLocal(message) : runnersService.send({
+      return runnerIsLocal ? sendLocal(message) : discard ? runnersService.notify({
+        address: maybeRunner,
+        message,
+        discard
+      }) : runnersService.send({
         address: maybeRunner.value,
         message
       });
     }), error => error._tag === "EntityNotAssignedToRunner" || error._tag === "RunnerUnavailable" ? Result.succeed(error) : Result.fail(error), error => {
+      // Abandon the message during teardown: retrying would loop forever once the runner is shutting down
+      if (error._tag === "EntityNotAssignedToRunner") {
+        const targetManager = entityManagers.get(message.envelope.address.entityType);
+        const cannotRecover = MutableRef.get(isShutdown) || targetManager !== undefined && targetManager.status !== "alive";
+        if (cannotRecover) {
+          return abandon(error);
+        }
+      }
       if (retries === 0) {
         return Effect.die(error);
       }
@@ -656,7 +899,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
             if (newAssignments) {
               const runner = newAssignments[i];
               MutableHashMap.set(shardAssignments, shard, runner);
-              if (isLocalRunner(runner)) {
+              if (shardLocksHealthyLatch.isOpen() && isLocalRunner(runner)) {
                 MutableHashSet.add(selfShards, shard);
               }
             } else {
@@ -722,7 +965,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
               if (!options.discard) {
                 const entry = {
                   rpc: rpc,
-                  context: fiber.currentContext,
+                  context: fiber.context,
                   message
                 };
                 clientRequests.set(id, entry);
@@ -799,12 +1042,14 @@ const make = /*#__PURE__*/Effect.gen(function* () {
           return entity.protocol.requests.has(p);
         },
         get(target, p) {
-          if (p in target) {
+          if (Object.hasOwn(target, p)) {
             return target[p];
           } else if (!entity.protocol.requests.has(p)) {
             return undefined;
           }
-          return target[p] = (payload, options) => clientFn(p, payload, options);
+          const method = (payload, options) => clientFn(p, payload, options);
+          InternalRecord.assignProperty(target, p, method);
+          return method;
         }
       });
     };
@@ -903,8 +1148,9 @@ const make = /*#__PURE__*/Effect.gen(function* () {
       ...options,
       storage,
       runnerAddress,
+      residency,
       sharding
-    }).pipe(Effect.provideContext(Context.mutate(services, services => services.pipe(Context.add(EntityReaper, reaper), Context.add(Scope.Scope, scope), Context.add(Snowflake.Generator, snowflakeGen)))));
+    }).pipe(Effect.provideContext(services.pipe(Context.add(EntityReaper, reaper), Context.add(Scope.Scope, scope), Context.add(Snowflake.Generator, snowflakeGen))));
     const state = {
       entity,
       status: "alive",
@@ -920,6 +1166,7 @@ const make = /*#__PURE__*/Effect.gen(function* () {
     // register entities while storage is idle
     // this ensures message order is preserved
     yield* withStorageReadLock(Effect.sync(() => {
+      entityRegistrationStartMillis ??= clock.currentTimeMillisUnsafe();
       entityManagers.set(entity.type, state);
       if (entityManagerLatches.has(entity.type)) {
         entityManagerLatches.get(entity.type).openUnsafe();