rivetkit 2.3.30 → 3.0.0-preview.2

package/dist/browser/client.d.ts

@@ -51,7 +51,13 @@ interface SqliteTransactionOptions {
  * to change without notice.
  */
 interface SqliteProfilingOptions {
-    enabled?: boolean;
+    /** Exact SQL statements to give fingerprint labels. Profiling defaults to actor
+     * aggregates without fingerprint labels. Profile logs remain enabled.
+     * RIVETKIT_SQLITE_PROFILING overrides selection with a JSON object containing
+     * queries and/or fingerprints arrays. An empty object clears fingerprint selection. */
+    queries?: string[];
+    /** Exact query fingerprints to label separately, as reported in profile logs. */
+    fingerprints?: string[];
     maxTrackedStatementFingerprints?: number;
     maxTrackedTransactionFingerprints?: number;
     maxPrometheusSeries?: number;
@@ -753,6 +759,8 @@ interface RuntimeServeConfig {
     engineBinaryPath?: string;
     startServices?: boolean;
     servicesBinaryPath?: string;
+    /** Whether config resolution selected a managed local development engine. */
+    engineSpawn?: boolean;
     engineHost?: string;
     enginePort?: number;
     handleInspectorHttpInRuntime?: boolean;
@@ -841,7 +849,12 @@ interface CoreRuntime {
     createCancellationToken(): CancellationTokenHandle;
     cancellationTokenAborted(token: CancellationTokenHandle): boolean;
     cancelCancellationToken(token: CancellationTokenHandle): void;
-    onCancellationTokenCancelled(token: CancellationTokenHandle, callback: (...args: unknown[]) => unknown): void;
+    /**
+     * Calls `callback` once when `token` is cancelled. Returns a release
+     * function that drops the registration without calling `callback`; call it
+     * once cancellation no longer matters so the native listener is freed.
+     */
+    onCancellationTokenCancelled(token: CancellationTokenHandle, callback: (...args: unknown[]) => unknown): () => void;
     actorState(ctx: ActorContextHandle): RuntimeBytes;
     actorBeginOnStateChange(ctx: ActorContextHandle): void;
     actorEndOnStateChange(ctx: ActorContextHandle): void;
@@ -1231,6 +1244,27 @@ declare class ActorConnRaw {
  */
 type ActorConn<AD extends AnyActorDefinition> = Omit<ActorConnRaw, "send" | "on" | "once"> & ActorDefinitionQueueSend<AD> & ActorDefinitionEventSubscriptions<AD> & ActorDefinitionActions<AD>;
 
+/** How many retries a client may spend, as a share of the requests it sends. */
+interface RetryBudgetOptions {
+    /** Retries allowed per 100 requests (default 10). */
+    percent?: number;
+    /** Retries the client can bank for a burst of refusals; the budget starts full (default 100). */
+    maxTokens?: number;
+}
+/**
+ * Bounds the client's retries of refused requests. Each request adds a fraction of a token and
+ * each retry spends one, so retries stay a fixed share of traffic while the service sheds load
+ * instead of multiplying it.
+ */
+declare class RetryBudget {
+    #private;
+    constructor(options?: RetryBudgetOptions);
+    /** Credits one request sent. */
+    deposit(): void;
+    /** Spends one token. Returns `false` when the budget is spent. */
+    tryWithdraw(): boolean;
+}
+
 /**
  * Provides underlying functions for stateless {@link ActorHandle} for action calls.
  * Similar to ActorConnRaw but doesn't maintain a connection.
@@ -1246,7 +1280,7 @@ declare class ActorHandleRaw {
      *
      * @protected
      */
-    constructor(client: any, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions, signal?: AbortSignal, currentActorInvocation?: CurrentActorInvocation, startCallSpan?: StartCallSpan);
+    constructor(client: any, driver: EngineControlClient, params: unknown, getParams: (() => Promise<unknown>) | undefined, encoding: Encoding, actorResolutionState: ActorResolutionState, gatewayOptions?: ActorGatewayOptions, signal?: AbortSignal, currentActorInvocation?: CurrentActorInvocation, startCallSpan?: StartCallSpan, retryBudget?: RetryBudget);
     send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
     send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
     /**
@@ -1330,6 +1364,10 @@ declare const ClientConfigSchema: z$1.ZodPipe<z$1.ZodObject<{
         skipReadyWait: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
     }, z$1.core.$strip>>>;
     getUpgradeWebSocket: z$1.ZodOptional<z$1.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
+    retryBudget: z$1.ZodOptional<z$1.ZodObject<{
+        percent: z$1.ZodOptional<z$1.ZodNumber>;
+        maxTokens: z$1.ZodOptional<z$1.ZodNumber>;
+    }, z$1.core.$strip>>;
     fetch: z$1.ZodOptional<z$1.ZodCustom<typeof fetch, typeof fetch>>;
     disableMetadataLookup: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
     maxInputSize: z$1.ZodDefault<z$1.ZodNumber>;
@@ -1349,6 +1387,10 @@ declare const ClientConfigSchema: z$1.ZodPipe<z$1.ZodObject<{
     devtools: boolean;
     getToken?: GetToken | undefined;
     getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+    retryBudget?: {
+        percent?: number | undefined;
+        maxTokens?: number | undefined;
+    } | undefined;
     fetch?: typeof fetch | undefined;
 }, {
     endpoint: string;
@@ -1365,6 +1407,10 @@ declare const ClientConfigSchema: z$1.ZodPipe<z$1.ZodObject<{
     devtools: boolean;
     getToken?: GetToken | undefined;
     getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+    retryBudget?: {
+        percent?: number | undefined;
+        maxTokens?: number | undefined;
+    } | undefined;
     fetch?: typeof fetch | undefined;
 }>>;
 type ClientConfigInput = z$1.input<typeof ClientConfigSchema>;
@@ -1513,6 +1559,8 @@ declare const CREATE_ACTOR_CONN_PROXY: unique symbol;
 interface ClientRawOptions {
     encoding?: Encoding;
     gateway?: ActorGatewayOptions;
+    /** Bounds retries of refused requests across every handle of this client. */
+    retryBudget?: RetryBudgetOptions;
 }
 /** Runtime-supplied wiring for clients created inside an actor. Set only by the native runtime. */
 interface ActorClientRuntimeOptions {
@@ -2308,11 +2356,11 @@ declare const RegistryConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
         publicEndpoint: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
         publicToken: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
     }, z$2.core.$strip>>>;
-    envoy: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodObject<{
+    node: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodObject<{
         poolName: z$2.ZodDefault<z$2.ZodString>;
         version: z$2.ZodDefault<z$2.ZodNumber>;
         totalSlots: z$2.ZodDefault<z$2.ZodNumber>;
-        envoyKey: z$2.ZodOptional<z$2.ZodString>;
+        nodeKey: z$2.ZodOptional<z$2.ZodString>;
     }, z$2.core.$strip>>>;
     shutdown: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodObject<{
         gracePeriodMs: z$2.ZodOptional<z$2.ZodNumber>;
@@ -2323,6 +2371,7 @@ declare const RegistryConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
         backend: "local" | "remote";
     } | undefined;
     endpoint: string | undefined;
+    engineSpawn: boolean;
     startServices: boolean;
     namespace: string;
     token: string | undefined;
@@ -2362,11 +2411,11 @@ declare const RegistryConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
     engineHost: string;
     enginePort: number;
     engineVersion: string;
-    envoy: {
+    node: {
         poolName: string;
         version: number;
         totalSlots: number;
-        envoyKey?: string | undefined;
+        nodeKey?: string | undefined;
     };
     shutdown: {
         disableSignalHandlers: boolean;
@@ -2423,11 +2472,11 @@ declare const RegistryConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
         publicEndpoint: string | undefined;
         publicToken: string | undefined;
     };
-    envoy: {
+    node: {
         poolName: string;
         version: number;
         totalSlots: number;
-        envoyKey?: string | undefined;
+        nodeKey?: string | undefined;
     };
     shutdown: {
         disableSignalHandlers: boolean;

package/dist/browser/client.js

@@ -230,7 +230,7 @@ function noopNext() {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "2.3.30",
+  version: "3.0.0-preview.2",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -440,7 +440,6 @@ var package_default = {
   dependencies: {
     "@hono/zod-openapi": "^1.1.5",
     "@opentelemetry/api": "^1.1.0",
-    "@rivet-dev/services": "^0.2.3",
     "@rivetkit/bare-ts": "^0.6.2",
     "@rivetkit/engine-api-full": "workspace:*",
     "@rivetkit/engine-cli": "workspace:*",
@@ -1152,6 +1151,22 @@ function deserializeActorKey(keyString) {
   }
   return parts;
 }
+var CANONICAL_SEPARATOR = ",";
+var CANONICAL_EMPTY_PART = "\\0";
+function encodeActorKey(key) {
+  return key.map((part) => {
+    if (part === "") {
+      return CANONICAL_EMPTY_PART;
+    }
+    return part.replace(/\\/g, "\\\\").replace(/,/g, "\\,");
+  }).join(CANONICAL_SEPARATOR);
+}
+function actorKeyToGatewayQuery(key) {
+  if (key.length === 0) {
+    return void 0;
+  }
+  return encodeActorKey(key);
+}
 
 // src/client/token-provider.ts
 function isInvalidToken(group, code) {
@@ -1464,6 +1479,14 @@ var ClientConfigSchemaBase = z3.object({
   // This is required in the client config in order to support
   // `proxyWebSocket`
   getUpgradeWebSocket: z3.custom().optional(),
+  /**
+   * Bounds retries of refused requests: `percent` retries per 100 requests (default 10), with
+   * up to `maxTokens` banked for bursts (default 100). A refusal past the budget is thrown.
+   */
+  retryBudget: z3.object({
+    percent: z3.number().min(0).max(100).optional(),
+    maxTokens: z3.number().int().min(0).optional()
+  }).optional(),
   /** Replaces global fetch for actor HTTP gateway requests. */
   fetch: z3.custom().optional(),
   /** Whether to automatically perform health checks when the client is created. */
@@ -1780,8 +1803,9 @@ function buildActorQueryGatewayUrl(endpoint, namespace, query, token, path = "",
   return combineUrlPath(endpoint, gatewayPath);
 }
 function pushKeyQueryParams(params, key) {
-  if (key.length > 0) {
-    params.append("rvt-key", key.join(","));
+  const rvtKey = actorKeyToGatewayQuery(key);
+  if (rvtKey !== void 0) {
+    params.append("rvt-key", rvtKey);
   }
 }
 function pushInputQueryParam(params, input, maxInputSize) {
@@ -3870,17 +3894,22 @@ function internalClientError(message, opts) {
 }
 
 // src/client/utils.ts
+var RETRY_AFTER_SUFFIX = /^retry_after_ms=(\d+)$/;
 function parseWebSocketCloseReason(reason) {
-  const [mainPart, rayId] = reason.split("#");
+  const [mainPart, suffix] = reason.split("#");
   const [group, code] = mainPart.split(".");
   if (!group || !code) {
     logger2().warn({ msg: "failed to parse close reason", reason });
     return void 0;
   }
+  const retryAfter = suffix?.match(RETRY_AFTER_SUFFIX);
+  if (retryAfter) {
+    return { group, code, retryAfterMs: Number(retryAfter[1]) };
+  }
   return {
     group,
     code,
-    rayId
+    rayId: suffix
   };
 }
 function messageLength(message) {
@@ -4459,7 +4488,7 @@ var RemoteEngineControlClient = class {
           datacenter: region,
           name,
           key: serializeActorKey(key),
-          runner_name_selector: poolName ?? this.#config.poolName,
+          pool: poolName ?? this.#config.poolName,
           input: actorInput ? uint8ArrayToBase64(
             encodeCborCompat(actorInput)
           ) : void 0,
@@ -4512,7 +4541,7 @@ var RemoteEngineControlClient = class {
       (config) => createActor(config, {
         datacenter: region,
         name,
-        runner_name_selector: poolName ?? this.#config.poolName,
+        pool: poolName ?? this.#config.poolName,
         key: serializeActorKey(key),
         input: input ? uint8ArrayToBase64(
           encodeCborCompat(input)
@@ -4816,6 +4845,56 @@ async function checkForSchedulingError(group, code, actorId, query, driver, rayI
   return null;
 }
 
+// src/client/retry-budget.ts
+var DEFAULT_PERCENT = 10;
+var DEFAULT_MAX_TOKENS = 100;
+var RetryBudget = class {
+  #tokens;
+  #maxTokens;
+  #deposit;
+  constructor(options = {}) {
+    const percent = options.percent ?? DEFAULT_PERCENT;
+    const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    if (!(percent >= 0 && percent <= 100)) {
+      throw new Error("retryBudget.percent must be in 0..=100");
+    }
+    if (!(maxTokens >= 0)) {
+      throw new Error("retryBudget.maxTokens must be at least 0");
+    }
+    this.#maxTokens = maxTokens;
+    this.#tokens = maxTokens;
+    this.#deposit = percent / 100;
+  }
+  /** Credits one request sent. */
+  deposit() {
+    this.#tokens = Math.min(this.#maxTokens, this.#tokens + this.#deposit);
+  }
+  /** Spends one token. Returns `false` when the budget is spent. */
+  tryWithdraw() {
+    if (this.#tokens + 1e-9 < 1) {
+      return false;
+    }
+    this.#tokens = Math.max(0, this.#tokens - 1);
+    return true;
+  }
+};
+function retryAfterMs(error) {
+  if (!(error instanceof RivetError)) {
+    return void 0;
+  }
+  const metadata = error.metadata;
+  if (metadata === null || typeof metadata !== "object") {
+    return void 0;
+  }
+  const hint = metadata.retry_after_ms;
+  return typeof hint === "number" && hint >= 0 ? hint : void 0;
+}
+function retryDelayMs(attempt, opts) {
+  const backoff = Math.min(opts.initialDelayMs * 2 ** attempt, opts.maxDelayMs);
+  const jittered = backoff / 2 + Math.random() * (backoff / 2);
+  return Math.max(jittered, opts.hintMs ?? 0);
+}
+
 // src/client/lifecycle-errors.ts
 function* walkErrorChain(error, maxDepth = 8) {
   let current = error;
@@ -4993,6 +5072,7 @@ async function retryOnLifecycleBoundary(run, opts) {
   const maxAttempts = opts?.maxAttempts ?? 5;
   const initialDelayMs = opts?.initialDelayMs ?? 25;
   const maxDelayMs = opts?.maxDelayMs ?? 200;
+  opts?.budget?.deposit();
   let lastError;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
     throwIfAborted(opts?.signal);
@@ -5006,7 +5086,14 @@ async function retryOnLifecycleBoundary(run, opts) {
       if (attempt === maxAttempts - 1) {
         break;
       }
-      const delayMs = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
+      if (opts?.budget && !opts.budget.tryWithdraw()) {
+        break;
+      }
+      const delayMs = retryDelayMs(attempt, {
+        initialDelayMs,
+        maxDelayMs,
+        hintMs: retryAfterMs(error)
+      });
       await waitWithSignal(delayMs, opts?.signal);
     }
   }
@@ -5157,6 +5244,10 @@ function createQueueSender(senderOptions) {
 }
 
 // src/client/actor-conn.ts
+var CONNECT_TIMEOUT_MS = 2e4;
+function isConnectionOpenTimeout(error) {
+  return error instanceof RivetError && error.group === "client" && error.code === "connection_open_timeout";
+}
 var CONNECT_SYMBOL = /* @__PURE__ */ Symbol("connect");
 var ActorConnRaw = class {
   #disposed = false;
@@ -5184,6 +5275,8 @@ var ActorConnRaw = class {
   #keepNodeAliveInterval;
   /** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
   #onOpenPromise;
+  /** Sockets given up on by the connect timeout. Their late events are ignored. */
+  #abandonedSockets = /* @__PURE__ */ new WeakSet();
   #websocket;
   #authRetryAvailable = true;
   #client;
@@ -5371,12 +5464,16 @@ var ActorConnRaw = class {
       forever: true,
       minTimeout: 250,
       maxTimeout: 3e4,
-      onFailedAttempt: (error) => {
+      onFailedAttempt: async (error) => {
         logger2().warn({
           msg: "failed to reconnect",
           attempt: error.attemptNumber,
           error: stringifyError(error)
         });
+        const hintMs = retryAfterMs(error);
+        if (hintMs !== void 0) {
+          await new Promise((resolve) => setTimeout(resolve, hintMs));
+        }
       },
       // Cancel retry if aborted
       signal: this.#abortController.signal
@@ -5402,7 +5499,7 @@ var ActorConnRaw = class {
         })
       );
       await this.#connectWebSocket();
-      await this.#onOpenPromise.promise;
+      await this.#waitForOpen(this.#onOpenPromise.promise);
     } catch (error) {
       if (this.#shouldRetryConnectionOpenError(error)) {
         throw error;
@@ -5424,10 +5521,63 @@ var ActorConnRaw = class {
       this.#onOpenPromise = void 0;
     }
   }
+  /**
+   * Waits for the actor's Init on the current socket, up to {@link CONNECT_TIMEOUT_MS}. A socket
+   * can stay connecting with no open, error or close event, as when the engine holds the
+   * upgrade or a refused connect reports only an error. On timeout the socket is abandoned
+   * and closed, and the retryable `client.connection_open_timeout` starts the next attempt.
+   */
+  async #waitForOpen(open) {
+    let timer;
+    const timedOut = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new RivetError(
+            "client",
+            "connection_open_timeout",
+            `Connection did not open within ${CONNECT_TIMEOUT_MS} ms`
+          )
+        );
+      }, CONNECT_TIMEOUT_MS);
+    });
+    try {
+      await Promise.race([open, timedOut]);
+    } catch (error) {
+      if (isConnectionOpenTimeout(error)) {
+        this.#abandonCurrentSocket();
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  #abandonCurrentSocket() {
+    const ws = this.#websocket;
+    if (!ws) return;
+    this.#websocket = void 0;
+    this.#abandonedSockets.add(ws);
+    logger2().warn({
+      msg: "connection did not open in time, retrying",
+      connId: this.#connId,
+      readyState: ws.readyState,
+      timeoutMs: CONNECT_TIMEOUT_MS
+    });
+    try {
+      ws.close(1e3, "Connect timeout");
+    } catch (err) {
+      logger2().debug({
+        msg: "failed to close abandoned websocket",
+        error: stringifyError(err)
+      });
+    }
+  }
   #shouldRetryConnectionOpenError(error) {
     if (error instanceof ActorConnDisposed) {
       return false;
     }
+    if (isConnectionOpenTimeout(error)) {
+      return true;
+    }
     if (error instanceof RivetError && isInvalidToken(error.group, error.code) && this.#driver.refreshAuthToken && this.#authRetryAvailable) {
       this.#authRetryAvailable = false;
       return true;
@@ -5487,12 +5637,14 @@ var ActorConnRaw = class {
     });
     this.#websocket = ws;
     ws.addEventListener("open", () => {
+      if (this.#abandonedSockets.has(ws)) return;
       logger2().debug({
         msg: "client websocket open",
         connId: this.#connId
       });
     });
     ws.addEventListener("message", async (ev) => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         await this.#handleOnMessage(ev.data);
       } catch (err) {
@@ -5503,6 +5655,7 @@ var ActorConnRaw = class {
       }
     });
     ws.addEventListener("close", async (ev) => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         await this.#handleOnClose(ev);
       } catch (err) {
@@ -5513,6 +5666,7 @@ var ActorConnRaw = class {
       }
     });
     ws.addEventListener("error", () => {
+      if (this.#abandonedSockets.has(ws)) return;
       try {
         this.#handleOnError();
       } catch (err) {
@@ -5719,7 +5873,8 @@ var ActorConnRaw = class {
       const reason = closeEvent.reason || "";
       const parsed = parseWebSocketCloseReason(reason);
       if (parsed) {
-        const { group, code, rayId } = parsed;
+        const { group, code, rayId, retryAfterMs: retryAfterMs2 } = parsed;
+        const closeOptions = retryAfterMs2 === void 0 ? { rayId } : { rayId, metadata: { retry_after_ms: retryAfterMs2 } };
         if (isInvalidToken(group, code) && closeEvent.code === 1008 && failedSocket) {
           try {
             if (!await this.#driver.refreshAuthToken?.(
@@ -5741,7 +5896,7 @@ var ActorConnRaw = class {
               group,
               code,
               `Connection closed: ${reason}`,
-              { rayId }
+              closeOptions
             )
           );
           return;
@@ -5762,7 +5917,7 @@ var ActorConnRaw = class {
               group,
               code,
               `Connection closed: ${reason}`,
-              { rayId }
+              closeOptions
             );
           }
         } else {
@@ -5770,7 +5925,7 @@ var ActorConnRaw = class {
             group,
             code,
             `Connection closed: ${reason}`,
-            { rayId }
+            closeOptions
           );
         }
         this.#invalidateActorIfStale(group, code);
@@ -6454,6 +6609,7 @@ var ActorHandleRaw = class {
   #queueSendMutex = new AsyncMutex();
   #currentActorInvocation;
   #startCallSpan;
+  #retryBudget;
   /**
    * Do not call this directly.
    *
@@ -6461,7 +6617,7 @@ var ActorHandleRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal, currentActorInvocation, startCallSpan) {
+  constructor(client, driver, params, getParams, encoding, actorResolutionState, gatewayOptions = {}, signal, currentActorInvocation, startCallSpan, retryBudget = new RetryBudget()) {
     this.#client = client;
     this.#driver = driver;
     this.#encoding = encoding;
@@ -6472,6 +6628,7 @@ var ActorHandleRaw = class {
     this.#signal = signal;
     this.#currentActorInvocation = currentActorInvocation;
     this.#startCallSpan = startCallSpan;
+    this.#retryBudget = retryBudget;
   }
   async #resolveConnectionParams() {
     if (this.#getParams) {
@@ -6488,6 +6645,7 @@ var ActorHandleRaw = class {
       let useQueryTarget = isDynamicActorQuery(
         this.#actorResolutionState
       );
+      this.#retryBudget.deposit();
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         let actorId;
         try {
@@ -6521,8 +6679,17 @@ var ActorHandleRaw = class {
             metadata,
             attempt,
             maxAttempts
-          )) {
-            await this.#waitForRetryWindow();
+          ) && this.#retryBudget.tryWithdraw()) {
+            await new Promise(
+              (resolve) => setTimeout(
+                resolve,
+                retryDelayMs(attempt, {
+                  initialDelayMs: 25,
+                  maxDelayMs: 1e3,
+                  hintMs: retryAfterMs(err)
+                })
+              )
+            );
             continue;
           }
           if (await this.#shouldRetrySchedulingError(
@@ -6597,7 +6764,10 @@ var ActorHandleRaw = class {
       if (opts.name === "destroy") {
         return await run();
       }
-      return await retryOnLifecycleBoundary(run, { signal });
+      return await retryOnLifecycleBoundary(run, {
+        signal,
+        budget: this.#retryBudget
+      });
     };
     if (!call) {
       return await send();
@@ -7137,6 +7307,7 @@ var ClientRaw = class {
   #gatewayOptions;
   #currentActorInvocation;
   #startCallSpan;
+  #retryBudget;
   /**
    * Creates an instance of Client.
    */
@@ -7149,6 +7320,7 @@ var ClientRaw = class {
     this.#gatewayOptions = options.gateway ?? {};
     this.#currentActorInvocation = options.currentActorInvocation;
     this.#startCallSpan = options.startCallSpan;
+    this.#retryBudget = new RetryBudget(options.retryBudget);
   }
   /**
    * Gets a stateless handle to a actor by its ID.
@@ -7306,7 +7478,8 @@ var ClientRaw = class {
       this.#gatewayOptions,
       signal,
       this.#currentActorInvocation,
-      this.#startCallSpan
+      this.#startCallSpan,
+      this.#retryBudget
     );
   }
   [CREATE_ACTOR_CONN_PROXY](conn) {