rivetkit 0.0.0-pr.4792.8c20f1a → 0.0.0-pr.4794.efd07f2

package/dist/browser/client.d.ts

@@ -451,7 +451,7 @@ declare class ActorConnRaw {
      *
      * @protected
      */
-    constructor(client: ClientRaw, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState);
+    constructor(client: ClientRaw, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, onResolvedActorId?: (actorId: string) => void);
     send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
     send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**

package/dist/browser/client.js

@@ -225,7 +225,7 @@ function noopNext() {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "0.0.0-pr.4792.8c20f1a",
+  version: "0.0.0-pr.4794.efd07f2",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -3700,7 +3700,7 @@ function getGatewayTarget(state) {
   return state;
 }
 function isStaleResolvedActorError(group, code) {
-  return group === "actor" && (code === "not_found" || code === "starting" || code === "stopping" || code.startsWith("destroyed_"));
+  return group === "actor" && (code === "not_found" || code === "starting" || code === "stopping" || code === "not_configured" || code === "dropped_reply" || code.startsWith("destroyed_"));
 }
 async function checkForSchedulingError(group, code, actorId, query, driver) {
   const name = getActorNameFromQuery(query);
@@ -3824,6 +3824,7 @@ var ActorConnRaw = class {
   #getParams;
   #encoding;
   #actorResolutionState;
+  #onResolvedActorId;
   // TODO: ws message queue
   /**
    * Do not call this directly.
@@ -3832,13 +3833,14 @@ var ActorConnRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, getParams, encoding, actorResolutionState) {
+  constructor(client, driver, params, getParams, encoding, actorResolutionState, onResolvedActorId) {
     this.#client = client;
     this.#driver = driver;
     this.#params = params;
     this.#getParams = getParams;
     this.#encoding = encoding;
     this.#actorResolutionState = actorResolutionState;
+    this.#onResolvedActorId = onResolvedActorId;
     this.#queueSender = createQueueSender({
       encoding: this.#encoding,
       params: this.#params,
@@ -4175,6 +4177,7 @@ var ActorConnRaw = class {
     if (response.body.tag === "Init") {
       this.#actorId = response.body.val.actorId;
       this.#connId = response.body.val.connectionId;
+      this.#onResolvedActorId?.(this.#actorId);
       logger2().trace({
         msg: "received init message",
         actorId: this.#actorId,
@@ -4798,6 +4801,33 @@ var ActorConnRaw = class {
   }
 };
 
+// src/common/database/shared.ts
+var AsyncMutex = class {
+  #locked = false;
+  #waiting = [];
+  async acquire() {
+    while (this.#locked) {
+      await new Promise((resolve) => this.#waiting.push(resolve));
+    }
+    this.#locked = true;
+  }
+  release() {
+    this.#locked = false;
+    const next = this.#waiting.shift();
+    if (next) {
+      next();
+    }
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+
 // src/client/raw-utils.ts
 async function rawHttpFetch(driver, target, params, input, init) {
   let path;
@@ -4945,7 +4975,9 @@ var ActorHandleRaw = class {
   #params;
   #getParams;
   #resolvedActorId;
+  #resolvedActorIdPinned = false;
   #resolvingActorId;
+  #queueSendMutex = new AsyncMutex();
   /**
    * Do not call this directly.
    *
@@ -4971,61 +5003,73 @@ var ActorHandleRaw = class {
     return this.#sendQueueMessage(name, body, options);
   }
   async #sendQueueMessage(name, body, options) {
-    const maxAttempts = this.#getDynamicQueryMaxAttempts();
-    let useQueryTarget = false;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      let actorId;
-      try {
-        const target = await this.#resolveActionTarget(useQueryTarget);
-        actorId = "directId" in target ? target.directId : void 0;
-        return await createQueueSender({
-          encoding: this.#encoding,
-          params: this.#params,
-          customFetch: async (request) => {
-            return await this.#driver.sendRequest(target, request);
+    return await this.#queueSendMutex.run(async () => {
+      const maxAttempts = this.#getDynamicQueryMaxAttempts();
+      let useQueryTarget = false;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        let actorId;
+        try {
+          const target = await this.#resolveActionTarget(useQueryTarget);
+          actorId = "directId" in target ? target.directId : void 0;
+          return await createQueueSender({
+            encoding: this.#encoding,
+            params: this.#params,
+            customFetch: async (request) => {
+              return await this.#driver.sendRequest(target, request);
+            }
+          }).send(name, body, options);
+        } catch (err) {
+          const { group, code, message, metadata } = deconstructError(
+            err,
+            logger2(),
+            {},
+            true
+          );
+          if (this.#shouldRetryQueueDispatchOverload(
+            group,
+            code,
+            metadata,
+            attempt,
+            maxAttempts
+          )) {
+            await this.#waitForRetryWindow();
+            continue;
           }
-        }).send(name, body, options);
-      } catch (err) {
-        const { group, code, message, metadata } = deconstructError(
-          err,
-          logger2(),
-          {},
-          true
-        );
-        if (await this.#shouldRetrySchedulingError(
-          group,
-          code,
-          actorId,
-          attempt,
-          maxAttempts
-        )) {
-          useQueryTarget = true;
-          await this.#waitForRetryWindow();
-          continue;
-        }
-        if (this.#shouldRetryDynamicLifecycleError(
-          group,
-          code,
-          attempt,
-          maxAttempts
-        )) {
-          this.#clearResolvedActorId();
-          useQueryTarget = true;
-          await this.#waitForRetryWindow();
-          continue;
-        }
-        const invalidated = this.#invalidateResolvedActorId(group, code);
-        if (invalidated && attempt < maxAttempts - 1) {
-          useQueryTarget = code === "starting" || code === "stopping" || code.startsWith("destroyed_");
-          if (useQueryTarget) {
+          if (await this.#shouldRetrySchedulingError(
+            group,
+            code,
+            actorId,
+            attempt,
+            maxAttempts
+          )) {
+            useQueryTarget = true;
             await this.#waitForRetryWindow();
+            continue;
           }
-          continue;
+          if (this.#shouldRetryDynamicLifecycleError(
+            group,
+            code,
+            attempt,
+            maxAttempts
+          )) {
+            this.#clearResolvedActorId();
+            useQueryTarget = true;
+            await this.#waitForRetryWindow();
+            continue;
+          }
+          const invalidated = this.#invalidateResolvedActorId(group, code);
+          if (invalidated && attempt < maxAttempts - 1) {
+            useQueryTarget = code === "starting" || code === "stopping" || code.startsWith("destroyed_");
+            if (useQueryTarget) {
+              await this.#waitForRetryWindow();
+            }
+            continue;
+          }
+          throw new RivetError(group, code, message, metadata);
         }
-        throw new RivetError(group, code, message, metadata);
       }
-    }
-    throw new Error("unreachable queue retry state");
+      throw new Error("unreachable queue retry state");
+    });
   }
   /**
    * Call a raw action. This method sends an HTTP request to invoke the named action.
@@ -5172,12 +5216,24 @@ var ActorHandleRaw = class {
     if (!isDynamicActorQuery(this.#actorResolutionState) || attempt >= maxAttempts - 1 || group !== "actor") {
       return false;
     }
-    return code === "not_found" || code === "starting" || code === "stopping" || code === "destroying" || code.startsWith("destroyed_");
+    return code === "not_found" || code === "starting" || code === "stopping" || code === "not_configured" || code === "dropped_reply" || code === "destroying" || code.startsWith("destroyed_");
+  }
+  #shouldRetryQueueDispatchOverload(group, code, metadata, attempt, maxAttempts) {
+    if (!isDynamicActorQuery(this.#actorResolutionState) || attempt >= maxAttempts - 1 || group !== "actor" || code !== "overloaded" || metadata === null || typeof metadata !== "object") {
+      return false;
+    }
+    const overload = metadata;
+    return overload.channel === "dispatch_inbox" && overload.operation === "dispatch_queue_send";
   }
   #clearResolvedActorId() {
     this.#resolvedActorId = void 0;
+    this.#resolvedActorIdPinned = false;
     this.#resolvingActorId = void 0;
   }
+  #setResolvedActorIdFromConnection(actorId) {
+    this.#resolvedActorId = actorId;
+    this.#resolvedActorIdPinned = true;
+  }
   async #shouldRetrySchedulingError(group, code, actorId, attempt, maxAttempts) {
     if (!isDynamicActorQuery(this.#actorResolutionState) || !isSchedulingError(group, code) || attempt >= maxAttempts - 1) {
       return false;
@@ -5219,6 +5275,9 @@ var ActorHandleRaw = class {
         this.#driver,
         this.#actorResolutionState
       ).then((actorId) => {
+        if (this.#resolvedActorIdPinned && this.#resolvedActorId) {
+          return this.#resolvedActorId;
+        }
         this.#resolvedActorId = actorId;
         return actorId;
       });
@@ -5248,7 +5307,10 @@ var ActorHandleRaw = class {
       connParams,
       getParams,
       this.#encoding,
-      this.#actorResolutionState
+      this.#actorResolutionState,
+      (actorId) => {
+        this.#setResolvedActorIdFromConnection(actorId);
+      }
     );
     return this.#client[CREATE_ACTOR_CONN_PROXY](
       conn