rivetkit 0.0.0-skip-ready-wait-flatten-client-options.1cae221 → 0.0.0-sqlite-uds.4e59a38

package/dist/browser/client.js

@@ -1,9 +1,16 @@
+// src/common/log.ts
+import {
+  pino,
+  stdTimeFunctions
+} from "pino";
+import { z } from "zod/v4";
+
 // src/actor/errors.ts
 var INTERNAL_ERROR_CODE = "internal_error";
 var INTERNAL_ERROR_DESCRIPTION = "An internal error occurred";
 var USER_ERROR_CODE = "user_error";
 function looksLikeRivetErrorOptions(value) {
-  return typeof value === "object" && value !== null && ("public" in value || "metadata" in value || "statusCode" in value || "cause" in value);
+  return typeof value === "object" && value !== null && ("public" in value || "metadata" in value || "statusCode" in value || "actor" in value || "cause" in value);
 }
 function isTypedErrorTag(value) {
   return value === "ActorError" || value === "RivetError";
@@ -22,6 +29,7 @@ var RivetError = class extends Error {
   public;
   metadata;
   statusCode;
+  actor;
   group;
   code;
   static isRivetError(error) {
@@ -39,6 +47,7 @@ var RivetError = class extends Error {
     this.public = normalized.public ?? false;
     this.metadata = normalized.metadata;
     this.statusCode = normalized.statusCode ?? (this.public ? 400 : 500);
+    this.actor = normalized.actor;
   }
   toString() {
     return this.message;
@@ -73,19 +82,6 @@ function actorNotFound(identifier) {
   );
 }
 
-// src/utils/env-vars.ts
-var getRivetEngine = () => getEnvUniversal("RIVET_ENGINE");
-var getRivetEndpoint = () => getEnvUniversal("RIVET_ENDPOINT");
-var getRivetToken = () => getEnvUniversal("RIVET_TOKEN");
-var getRivetNamespace = () => getEnvUniversal("RIVET_NAMESPACE");
-var getRivetPool = () => getEnvUniversal("RIVET_POOL");
-var getLogLevel = () => getEnvUniversal("RIVET_LOG_LEVEL") ?? getEnvUniversal("LOG_LEVEL");
-var getLogTarget = () => getEnvUniversal("RIVET_LOG_TARGET") === "1";
-var getLogTimestamp = () => getEnvUniversal("RIVET_LOG_TIMESTAMP") === "1";
-var getLogMessage = () => getEnvUniversal("RIVET_LOG_MESSAGE") === "1";
-var getLogErrorStack = () => getEnvUniversal("RIVET_LOG_ERROR_STACK") === "1";
-var getNextPhase = () => getEnvUniversal("NEXT_PHASE");
-
 // src/common/utils.ts
 function assertUnreachable(x) {
   throw new Error(`Unreachable case: ${x}`);
@@ -93,13 +89,14 @@ function assertUnreachable(x) {
 function isCanonicalStructuredRivetError(error) {
   return error instanceof RivetError || typeof error === "object" && error !== null && "__type" in error && error.__type === "RivetError" && "group" in error && typeof error.group === "string" && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
 }
-function deconstructError(error, logger4, extraLog, exposeInternalError = false) {
+function deconstructError(error, exposeInternalError = false) {
   let statusCode;
   let public_;
   let group;
   let code;
   let message;
   let metadata;
+  let actor;
   if (isCanonicalStructuredRivetError(error)) {
     statusCode = typeof error.statusCode === "number" ? error.statusCode : error.public ? 400 : 500;
     public_ = error.public ?? false;
@@ -107,14 +104,7 @@ function deconstructError(error, logger4, extraLog, exposeInternalError = false)
     code = error.code;
     message = error.message;
     metadata = error.metadata;
-    logger4.info({
-      msg: "structured error passthrough",
-      group,
-      code,
-      message,
-      ...EXTRA_ERROR_LOG,
-      ...extraLog
-    });
+    actor = error.actor;
   } else if (RivetError.isActorError(error) && error.public) {
     statusCode = "statusCode" in error && error.statusCode ? error.statusCode : 400;
     public_ = true;
@@ -122,14 +112,7 @@ function deconstructError(error, logger4, extraLog, exposeInternalError = false)
     code = error.code;
     message = getErrorMessage(error);
     metadata = error.metadata;
-    logger4.info({
-      msg: "public error",
-      group,
-      code,
-      message,
-      ...EXTRA_ERROR_LOG,
-      ...extraLog
-    });
+    actor = error.actor;
   } else if (exposeInternalError) {
     if (RivetError.isActorError(error)) {
       statusCode = 500;
@@ -138,30 +121,13 @@ function deconstructError(error, logger4, extraLog, exposeInternalError = false)
       code = error.code;
       message = getErrorMessage(error);
       metadata = error.metadata;
-      logger4.info({
-        msg: "internal error",
-        group,
-        code,
-        message,
-        stack: error?.stack,
-        ...EXTRA_ERROR_LOG,
-        ...extraLog
-      });
+      actor = error.actor;
     } else {
       statusCode = 500;
       public_ = false;
       group = "rivetkit";
       code = INTERNAL_ERROR_CODE;
       message = getErrorMessage(error);
-      logger4.info({
-        msg: "internal error",
-        group,
-        code,
-        message,
-        stack: error?.stack,
-        ...EXTRA_ERROR_LOG,
-        ...extraLog
-      });
     }
   } else {
     statusCode = 500;
@@ -169,16 +135,12 @@ function deconstructError(error, logger4, extraLog, exposeInternalError = false)
     group = "rivetkit";
     code = INTERNAL_ERROR_CODE;
     message = INTERNAL_ERROR_DESCRIPTION;
+    if (RivetError.isActorError(error)) {
+      actor = error.actor;
+    }
     metadata = {
-      //url: `https://hub.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
+      //url: `https://dashboard.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
     };
-    logger4.warn({
-      msg: "internal error",
-      error: getErrorMessage(error),
-      stack: error?.stack,
-      ...EXTRA_ERROR_LOG,
-      ...extraLog
-    });
   }
   return {
     __type: "ActorError",
@@ -187,7 +149,8 @@ function deconstructError(error, logger4, extraLog, exposeInternalError = false)
     group,
     code,
     message,
-    metadata
+    metadata,
+    actor
   };
 }
 function stringifyError(error) {
@@ -231,7 +194,7 @@ function noopNext() {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "0.0.0-skip-ready-wait-flatten-client-options.1cae221",
+  version: "0.0.0-sqlite-uds.4e59a38",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -303,6 +266,16 @@ var package_default = {
         default: "./dist/tsup/db/drizzle.cjs"
       }
     },
+    "./dynamic": {
+      import: {
+        types: "./dist/tsup/dynamic/mod.d.ts",
+        default: "./dist/tsup/dynamic/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/dynamic/mod.d.cts",
+        default: "./dist/tsup/dynamic/mod.cjs"
+      }
+    },
     "./client": {
       import: {
         browser: {
@@ -347,6 +320,16 @@ var package_default = {
         default: "./dist/tsup/inspector/mod.cjs"
       }
     },
+    "./inspector-tab": {
+      import: {
+        types: "./dist/tsup/inspector-tab/mod.d.ts",
+        default: "./dist/tsup/inspector-tab/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/inspector-tab/mod.d.cts",
+        default: "./dist/tsup/inspector-tab/mod.cjs"
+      }
+    },
     "./inspector/client": {
       import: {
         types: "./dist/browser/inspector/client.d.ts",
@@ -382,7 +365,7 @@ var package_default = {
     "./dist/tsup/chunk-*.cjs"
   ],
   scripts: {
-    build: "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/db/mod.ts src/db/drizzle.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
+    build: "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/inspector-tab/mod.ts src/db/mod.ts src/db/drizzle.ts src/dynamic/mod.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
     "build:browser": "tsup --config tsup.browser.config.ts",
     "check-types": "tsc --noEmit",
     lint: "biome check . && pnpm run check:test-skips && pnpm run check:wait-for-comments",
@@ -399,13 +382,12 @@ var package_default = {
     "actor-config-schema-gen": "tsx scripts/actor-config-schema-gen.ts"
   },
   dependencies: {
-    "@rivet-dev/agent-os-core": "^0.1.1",
-    "@hono/node-server": "^1.18.2",
-    "@hono/node-ws": "^1.1.1",
     "@hono/zod-openapi": "^1.1.5",
+    "@rivet-dev/agent-os-core": "^0.1.1",
     "@rivetkit/bare-ts": "^0.6.2",
     "@rivetkit/engine-cli": "workspace:*",
     "@rivetkit/engine-envoy-protocol": "workspace:*",
+    "@rivetkit/on-change": "6.0.1",
     "@rivetkit/rivetkit-napi": "workspace:*",
     "@rivetkit/rivetkit-wasm": "workspace:*",
     "@rivetkit/traces": "workspace:*",
@@ -413,7 +395,6 @@ var package_default = {
     "@rivetkit/workflow-engine": "workspace:*",
     "cbor-x": "^1.6.0",
     "drizzle-orm": "^0.44.2",
-    "get-port": "^7.1.0",
     hono: "^4.7.0",
     invariant: "^2.2.4",
     "p-retry": "^6.2.1",
@@ -423,14 +404,17 @@ var package_default = {
     zod: "^4.1.0"
   },
   devDependencies: {
+    "@biomejs/biome": "^2.3",
     "@copilotkit/llmock": "^1.6.0",
+    "@hono/node-server": "^1.18.2",
+    "@hono/node-ws": "^1.1.1",
     "@rivet-dev/agent-os-common": "*",
     "@rivet-dev/agent-os-pi": "^0.1.1",
-    "@biomejs/biome": "^2.3",
     "@standard-schema/spec": "^1.0.0",
     "@types/invariant": "^2",
     "@types/node": "^22.13.1",
     eventsource: "^4.0.0",
+    "get-port": "^7.1.0",
     tsup: "^8.4.0",
     tsx: "^4.19.4",
     typescript: "^5.7.3",
@@ -457,12 +441,81 @@ var package_default = {
   stableVersion: "0.8.0"
 };
 
+// src/utils.ts
+var VERSION = package_default.version;
+var _userAgent;
+function httpUserAgent() {
+  if (_userAgent !== void 0) {
+    return _userAgent;
+  }
+  let userAgent = `RivetKit/${VERSION}`;
+  const navigatorObj = typeof navigator !== "undefined" ? navigator : void 0;
+  if (navigatorObj?.userAgent) userAgent += ` ${navigatorObj.userAgent}`;
+  _userAgent = userAgent;
+  return userAgent;
+}
+function getEnvUniversal(key) {
+  if (typeof Deno !== "undefined") {
+    return Deno.env.get(key);
+  } else if (typeof process !== "undefined") {
+    return process.env[key];
+  }
+}
+function promiseWithResolvers(onReject) {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  promise.catch(onReject);
+  return { promise, resolve, reject };
+}
+function bufferToArrayBuffer(buf) {
+  return buf.buffer.slice(
+    buf.byteOffset,
+    buf.byteOffset + buf.byteLength
+  );
+}
+function combineUrlPath(endpoint, path, queryParams) {
+  const baseUrl = new URL(endpoint);
+  const pathParts = path.split("?");
+  const pathOnly = pathParts[0];
+  const existingQuery = pathParts[1] || "";
+  const basePath = baseUrl.pathname.replace(/\/$/, "");
+  const cleanPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+  const fullPath = (basePath + cleanPath).replace(/\/\//g, "/");
+  const queryParts = [];
+  if (existingQuery) {
+    queryParts.push(existingQuery);
+  }
+  if (queryParams) {
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (value !== void 0) {
+        queryParts.push(
+          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+        );
+      }
+    }
+  }
+  const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+  return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
+}
+
+// src/utils/env-vars.ts
+var getRivetEngine = () => getEnvUniversal("RIVET_ENGINE");
+var getRivetEndpoint = () => getEnvUniversal("RIVET_ENDPOINT");
+var getRivetToken = () => getEnvUniversal("RIVET_TOKEN");
+var getRivetNamespace = () => getEnvUniversal("RIVET_NAMESPACE");
+var getRivetPool = () => getEnvUniversal("RIVET_POOL");
+var getLogLevel = () => getEnvUniversal("RIVET_LOG_LEVEL") ?? getEnvUniversal("LOG_LEVEL");
+var getLogTarget = () => getEnvUniversal("RIVET_LOG_TARGET") === "1";
+var getLogTimestamp = () => getEnvUniversal("RIVET_LOG_TIMESTAMP") === "1";
+var getLogMessage = () => getEnvUniversal("RIVET_LOG_MESSAGE") === "1";
+var getLogErrorStack = () => getEnvUniversal("RIVET_LOG_ERROR_STACK") === "1";
+var getNextPhase = () => getEnvUniversal("NEXT_PHASE");
+
 // src/common/log.ts
-import {
-  pino,
-  stdTimeFunctions
-} from "pino";
-import { z } from "zod/v4";
 var baseLogger;
 var configuredLogLevel;
 var loggerCache = /* @__PURE__ */ new Map();
@@ -492,16 +545,14 @@ function getPinoLevel(logLevel) {
 function getIncludeTarget() {
   return getLogTarget();
 }
-function configureDefaultLogger(logLevel) {
-  if (logLevel) {
-    configuredLogLevel = logLevel;
-  }
-  baseLogger = pino(
+function makeDefaultLogger(logLevel) {
+  return pino(
     {
       level: getPinoLevel(logLevel),
       messageKey: "msg",
       // Do not include pid/hostname in output
       base: {},
+      errorKey: "error",
       // Keep the numeric level so the logfmt sink can match Pino's levels.
       formatters: {
         level(_label, number) {
@@ -512,6 +563,12 @@ function configureDefaultLogger(logLevel) {
     },
     createLogfmtDestination()
   );
+}
+function configureDefaultLogger(logLevel) {
+  if (logLevel) {
+    configuredLogLevel = logLevel;
+  }
+  baseLogger = makeDefaultLogger(logLevel);
   loggerCache.clear();
 }
 function getBaseLogger() {
@@ -606,79 +663,12 @@ function quoteLogfmtString(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
 }
 
-// src/utils.ts
-var VERSION = package_default.version;
-var _userAgent;
-function httpUserAgent() {
-  if (_userAgent !== void 0) {
-    return _userAgent;
-  }
-  let userAgent = `RivetKit/${VERSION}`;
-  const navigatorObj = typeof navigator !== "undefined" ? navigator : void 0;
-  if (navigatorObj?.userAgent) userAgent += ` ${navigatorObj.userAgent}`;
-  _userAgent = userAgent;
-  return userAgent;
-}
-function getEnvUniversal(key) {
-  if (typeof Deno !== "undefined") {
-    return Deno.env.get(key);
-  } else if (typeof process !== "undefined") {
-    return process.env[key];
-  }
-}
-function promiseWithResolvers(onReject) {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  promise.catch(onReject);
-  return { promise, resolve, reject };
-}
-function bufferToArrayBuffer(buf) {
-  return buf.buffer.slice(
-    buf.byteOffset,
-    buf.byteOffset + buf.byteLength
-  );
-}
-function combineUrlPath(endpoint, path, queryParams) {
-  const baseUrl = new URL(endpoint);
-  const pathParts = path.split("?");
-  const pathOnly = pathParts[0];
-  const existingQuery = pathParts[1] || "";
-  const basePath = baseUrl.pathname.replace(/\/$/, "");
-  const cleanPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-  const fullPath = (basePath + cleanPath).replace(/\/\//g, "/");
-  const queryParts = [];
-  if (existingQuery) {
-    queryParts.push(existingQuery);
-  }
-  if (queryParams) {
-    for (const [key, value] of Object.entries(queryParams)) {
-      if (value !== void 0) {
-        queryParts.push(
-          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
-        );
-      }
-    }
-  }
-  const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
-  return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
-}
-var EXTRA_ERROR_LOG = {
-  issues: "https://github.com/rivet-dev/rivet/issues",
-  support: "https://rivet.dev/discord",
-  version: VERSION
-};
-
 // src/devtools-loader/log.ts
 function logger() {
   return getLogger("devtools");
 }
 
 // src/devtools-loader/index.ts
-var DEFAULT_DEVTOOLS_URL = (version = VERSION) => `https://releases.rivet.dev/rivet/latest/devtools/mod.js?v=${version}`;
 var scriptId = "rivetkit-devtools-script";
 function injectDevtools(config) {
   if (!window) {
@@ -686,9 +676,10 @@ function injectDevtools(config) {
     return;
   }
   if (!document.getElementById(scriptId)) {
+    const src = `${config.endpoint?.replace(/\/$/, "")}/devtools/mod.js`;
     const script = document.createElement("script");
     script.id = scriptId;
-    script.src = DEFAULT_DEVTOOLS_URL();
+    script.src = src;
     script.async = true;
     document.head.appendChild(script);
   }
@@ -708,6 +699,7 @@ var KEYS = {
   INSPECTOR_TOKEN: Uint8Array.from([3]),
   KV: Uint8Array.from([4]),
   QUEUE_PREFIX: Uint8Array.from([5]),
+  LAST_PUSHED_ALARM: Uint8Array.from([6]),
   WORKFLOW_PREFIX: Uint8Array.from([6]),
   TRACES_PREFIX: Uint8Array.from([7])
 };
@@ -797,7 +789,7 @@ function deserializeActorKey(keyString) {
     }
   }
   if (escaping) {
-    parts.push(currentPart + "\\");
+    parts.push(`${currentPart}\\`);
   } else if (isEmptyStringMarker) {
     parts.push("");
   } else if (currentPart !== "" || parts.length > 0) {
@@ -815,18 +807,19 @@ var HEADER_CONN_PARAMS = "x-rivet-conn-params";
 var HEADER_RIVET_TOKEN = "x-rivet-token";
 var HEADER_RIVET_TARGET = "x-rivet-target";
 var HEADER_RIVET_ACTOR = "x-rivet-actor";
-var HEADER_RIVET_BYPASS_CONNECTABLE = "x-rivet-bypass-connectable";
+var HEADER_RIVET_SKIP_READY_WAIT = "x-rivet-skip-ready-wait";
 var WS_PROTOCOL_STANDARD = "rivet";
 var WS_PROTOCOL_TARGET = "rivet_target.";
 var WS_PROTOCOL_ACTOR = "rivet_actor.";
 var WS_PROTOCOL_ENCODING = "rivet_encoding.";
 var WS_PROTOCOL_CONN_PARAMS = "rivet_conn_params.";
-var WS_PROTOCOL_BYPASS_CONNECTABLE = "rivet_bypass_connectable";
+var WS_PROTOCOL_TOKEN = "rivet_token.";
+var WS_PROTOCOL_SKIP_READY_WAIT = "rivet_skip_ready_wait";
 var WS_PROTOCOL_TEST_ACK_HOOK = "rivet_test_ack_hook.";
 
 // src/engine-client/driver.ts
-function shouldBypassConnectable(options = {}) {
-  return options.bypassConnectable === true || options.skipReadyWait === true;
+function shouldSkipReadyWait(options = {}) {
+  return options.skipReadyWait === true;
 }
 
 // src/serde.ts
@@ -839,6 +832,10 @@ var JSON_COMPAT_BIGINT = "$BigInt";
 var JSON_COMPAT_ARRAY_BUFFER = "$ArrayBuffer";
 var JSON_COMPAT_UINT8_ARRAY = "$Uint8Array";
 var JSON_COMPAT_UNDEFINED = "$Undefined";
+var JSON_COMPAT_SET = "$Set";
+function isTypedArray(value) {
+  return value instanceof Uint8ClampedArray || value instanceof Uint16Array || value instanceof Uint32Array || value instanceof BigUint64Array || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array || value instanceof BigInt64Array || value instanceof Float32Array || value instanceof Float64Array;
+}
 var EncodingSchema = z2.enum(["json", "cbor", "bare"]);
 async function inputDataToBuffer(data) {
   if (typeof data === "string") {
@@ -873,9 +870,15 @@ function isPlainObject(value) {
   return proto === Object.prototype || proto === null;
 }
 function encodeJsonCompatValue(input) {
+  if (input === null) {
+    return input;
+  }
   if (input === void 0) {
     return [JSON_COMPAT_UNDEFINED, 0];
   }
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return input;
+  }
   if (typeof input === "bigint") {
     return [JSON_COMPAT_BIGINT, input.toString()];
   }
@@ -885,10 +888,34 @@ function encodeJsonCompatValue(input) {
   if (input instanceof Uint8Array) {
     return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(input)];
   }
+  if (isTypedArray(input)) {
+    return input;
+  }
+  if (input instanceof Date || input instanceof RegExp || input instanceof Error) {
+    return input;
+  }
+  if (input instanceof Set) {
+    const encoded = [...input.values()].map(
+      (v) => encodeJsonCompatValue(v)
+    );
+    return [JSON_COMPAT_SET, encoded];
+  }
+  if (input instanceof Map) {
+    const encoded = /* @__PURE__ */ new Map();
+    for (const [k, v] of input.entries()) {
+      encoded.set(
+        encodeJsonCompatValue(k),
+        encodeJsonCompatValue(v)
+      );
+    }
+    return encoded;
+  }
   if (Array.isArray(input)) {
-    const encoded = input.map((value) => encodeJsonCompatValue(value));
+    const encoded = input.map(
+      (value) => encodeJsonCompatValue(value)
+    );
     if (encoded.length === 2 && typeof encoded[0] === "string" && encoded[0].startsWith("$")) {
-      return ["$" + encoded[0], encoded[1]];
+      return [`$${encoded[0]}`, encoded[1]];
     }
     return encoded;
   }
@@ -899,7 +926,8 @@ function encodeJsonCompatValue(input) {
     }
     return encoded;
   }
-  return input;
+  const typeName = typeof input === "object" && input !== null ? input.constructor?.name ?? typeof input : typeof input;
+  throw new TypeError(`Value of type "${typeName}" is not CBOR serializable`);
 }
 function reviveJsonCompatValue(input, options = {}) {
   if (typeof input === "bigint") {
@@ -908,6 +936,16 @@ function reviveJsonCompatValue(input, options = {}) {
     }
     return input;
   }
+  if (input instanceof Map) {
+    const revived = /* @__PURE__ */ new Map();
+    for (const [k, v] of input.entries()) {
+      revived.set(
+        reviveJsonCompatValue(k, options),
+        reviveJsonCompatValue(v, options)
+      );
+    }
+    return revived;
+  }
   if (Array.isArray(input)) {
     if (input.length === 2 && typeof input[0] === "string" && input[0].startsWith("$")) {
       if (input[0] === JSON_COMPAT_BIGINT) {
@@ -922,6 +960,12 @@ function reviveJsonCompatValue(input, options = {}) {
       if (input[0] === JSON_COMPAT_UNDEFINED) {
         return void 0;
       }
+      if (input[0] === JSON_COMPAT_SET) {
+        const items = input[1].map(
+          (v) => reviveJsonCompatValue(v, options)
+        );
+        return new Set(items);
+      }
       if (input[0].startsWith("$$")) {
         return [
           input[0].substring(1),
@@ -963,19 +1007,13 @@ function jsonStringifyCompat(input) {
       return [JSON_COMPAT_BIGINT, value.toString()];
     }
     if (value instanceof ArrayBuffer) {
-      return [
-        JSON_COMPAT_ARRAY_BUFFER,
-        base64EncodeArrayBuffer(value)
-      ];
+      return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(value)];
     }
     if (value instanceof Uint8Array) {
-      return [
-        JSON_COMPAT_UINT8_ARRAY,
-        base64EncodeUint8Array(value)
-      ];
+      return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(value)];
     }
     if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0].startsWith("$")) {
-      return ["$" + value[0], value[1]];
+      return [`$${value[0]}`, value[1]];
     }
     return value;
   });
@@ -1087,7 +1125,7 @@ async function sendHttpRequestToGateway(runConfig, gatewayUrl, actorRequest, opt
     if (reqBody.byteLength !== 0) {
       bodyToSend = reqBody;
       guardHeaders.delete("transfer-encoding");
-      guardHeaders.set("content-length", String(bodyToSend.byteLength));
+      guardHeaders.delete("content-length");
     }
   }
   const guardRequest = new Request(gatewayUrl, {
@@ -1116,8 +1154,8 @@ function buildGuardHeaders(runConfig, actorRequest, options) {
     headers.set(HEADER_RIVET_TARGET, "actor");
     headers.set(HEADER_RIVET_ACTOR, options.directActorId);
   }
-  if (shouldBypassConnectable(options)) {
-    headers.set(HEADER_RIVET_BYPASS_CONNECTABLE, "1");
+  if (shouldSkipReadyWait(options)) {
+    headers.set(HEADER_RIVET_SKIP_READY_WAIT, "1");
   }
   return headers;
 }
@@ -1229,8 +1267,8 @@ var ClientConfigSchemaBase = z3.object({
   encoding: EncodingSchema.default("bare"),
   headers: z3.record(z3.string(), z3.string()).optional().default(() => ({})),
   gateway: z3.object({
-    bypassConnectable: z3.boolean().optional().default(false)
-  }).optional().default(() => ({ bypassConnectable: false })),
+    skipReadyWait: z3.boolean().optional().default(false)
+  }).optional().default(() => ({ skipReadyWait: false })),
   // See RunConfig.getUpgradeWebSocket
   //
   // This is required in the client config in order to support
@@ -1534,8 +1572,8 @@ function buildActorQueryGatewayUrl(endpoint, namespace, query, token, path = "",
   if (token !== void 0) {
     params.append("rvt-token", token);
   }
-  if (shouldBypassConnectable(options)) {
-    params.append("rvt-bypass_connectable", "true");
+  if (shouldSkipReadyWait(options)) {
+    params.append("rvt-skip-ready-wait", "true");
   }
   const queryString = params.toString();
   let separator;
@@ -1603,16 +1641,19 @@ async function openWebSocketToGateway(runConfig, gatewayUrl, encoding, params, o
   }
   return bufferedWs;
 }
-function buildWebSocketProtocols(_runConfig, encoding, params, ackHookToken, target, options = {}) {
+function buildWebSocketProtocols(runConfig, encoding, params, ackHookToken, target, options = {}) {
   const protocols = [];
   protocols.push(WS_PROTOCOL_STANDARD);
   protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
   if (target) {
     protocols.push(`${WS_PROTOCOL_TARGET}${target.target}`);
     protocols.push(`${WS_PROTOCOL_ACTOR}${target.actorId}`);
+    if (runConfig.token) {
+      protocols.push(`${WS_PROTOCOL_TOKEN}${runConfig.token}`);
+    }
   }
-  if (shouldBypassConnectable(options)) {
-    protocols.push(WS_PROTOCOL_BYPASS_CONNECTABLE);
+  if (shouldSkipReadyWait(options)) {
+    protocols.push(WS_PROTOCOL_SKIP_READY_WAIT);
   }
   if (params) {
     protocols.push(
@@ -2568,129 +2609,561 @@ function write3(bc, x) {
 function read4(bc) {
   return bare3.readBool(bc) ? bare3.readU64(bc) : null;
 }
-function write4(bc, x) {
-  bare3.writeBool(bc, x != null);
+function write4(bc, x) {
+  bare3.writeBool(bc, x != null);
+  if (x != null) {
+    bare3.writeU64(bc, x);
+  }
+}
+function readHttpQueueSendRequest(bc) {
+  return {
+    body: readCbor3(bc),
+    name: read2(bc),
+    wait: read3(bc),
+    timeout: read4(bc)
+  };
+}
+function writeHttpQueueSendRequest(bc, x) {
+  writeCbor3(bc, x.body);
+  write2(bc, x.name);
+  write3(bc, x.wait);
+  write4(bc, x.timeout);
+}
+function encodeHttpQueueSendRequest(x, config) {
+  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpQueueSendRequest(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendRequest(bytes) {
+  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
+  const result = readHttpQueueSendRequest(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpQueueSendResponse(bc) {
+  return {
+    status: bare3.readString(bc),
+    response: read03(bc)
+  };
+}
+function writeHttpQueueSendResponse(bc, x) {
+  bare3.writeString(bc, x.status);
+  write03(bc, x.response);
+}
+function encodeHttpQueueSendResponse(x, config) {
+  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpQueueSendResponse(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendResponse(bytes) {
+  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
+  const result = readHttpQueueSendResponse(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResponseError3(bc) {
+  return {
+    group: bare3.readString(bc),
+    code: bare3.readString(bc),
+    message: bare3.readString(bc),
+    metadata: read03(bc)
+  };
+}
+function writeHttpResponseError3(bc, x) {
+  bare3.writeString(bc, x.group);
+  bare3.writeString(bc, x.code);
+  bare3.writeString(bc, x.message);
+  write03(bc, x.metadata);
+}
+function encodeHttpResponseError3(x, config) {
+  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpResponseError3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResponseError3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
+  const result = readHttpResponseError3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResolveResponse3(bc) {
+  return {
+    actorId: bare3.readString(bc)
+  };
+}
+function writeHttpResolveResponse3(bc, x) {
+  bare3.writeString(bc, x.actorId);
+}
+function encodeHttpResolveResponse3(x, config) {
+  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpResolveResponse3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResolveResponse3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
+  const result = readHttpResolveResponse3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/common/bare/generated/client-protocol/v4.ts
+import * as bare4 from "@rivetkit/bare-ts";
+var DEFAULT_CONFIG4 = /* @__PURE__ */ bare4.Config({});
+function readCbor4(bc) {
+  return bare4.readData(bc);
+}
+function writeCbor4(bc, x) {
+  bare4.writeData(bc, x);
+}
+function read04(bc) {
+  return bare4.readBool(bc) ? bare4.readString(bc) : null;
+}
+function write04(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeString(bc, x);
+  }
+}
+function readActorSpecifier(bc) {
+  return {
+    actorId: bare4.readString(bc),
+    generation: bare4.readUint(bc),
+    key: read04(bc)
+  };
+}
+function writeActorSpecifier(bc, x) {
+  bare4.writeString(bc, x.actorId);
+  bare4.writeUint(bc, x.generation);
+  write04(bc, x.key);
+}
+function readInit4(bc) {
+  return {
+    actorId: bare4.readString(bc),
+    connectionId: bare4.readString(bc)
+  };
+}
+function writeInit4(bc, x) {
+  bare4.writeString(bc, x.actorId);
+  bare4.writeString(bc, x.connectionId);
+}
+function read14(bc) {
+  return bare4.readBool(bc) ? readCbor4(bc) : null;
+}
+function write14(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    writeCbor4(bc, x);
+  }
+}
+function read22(bc) {
+  return bare4.readBool(bc) ? bare4.readUint(bc) : null;
+}
+function write22(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeUint(bc, x);
+  }
+}
+function read32(bc) {
+  return bare4.readBool(bc) ? readActorSpecifier(bc) : null;
+}
+function write32(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    writeActorSpecifier(bc, x);
+  }
+}
+function readError4(bc) {
+  return {
+    group: bare4.readString(bc),
+    code: bare4.readString(bc),
+    message: bare4.readString(bc),
+    metadata: read14(bc),
+    actionId: read22(bc),
+    actor: read32(bc)
+  };
+}
+function writeError4(bc, x) {
+  bare4.writeString(bc, x.group);
+  bare4.writeString(bc, x.code);
+  bare4.writeString(bc, x.message);
+  write14(bc, x.metadata);
+  write22(bc, x.actionId);
+  write32(bc, x.actor);
+}
+function readActionResponse4(bc) {
+  return {
+    id: bare4.readUint(bc),
+    output: readCbor4(bc)
+  };
+}
+function writeActionResponse4(bc, x) {
+  bare4.writeUint(bc, x.id);
+  writeCbor4(bc, x.output);
+}
+function readEvent4(bc) {
+  return {
+    name: bare4.readString(bc),
+    args: readCbor4(bc)
+  };
+}
+function writeEvent4(bc, x) {
+  bare4.writeString(bc, x.name);
+  writeCbor4(bc, x.args);
+}
+function readToClientBody4(bc) {
+  const offset = bc.offset;
+  const tag = bare4.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "Init", val: readInit4(bc) };
+    case 1:
+      return { tag: "Error", val: readError4(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse4(bc) };
+    case 3:
+      return { tag: "Event", val: readEvent4(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare4.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody4(bc, x) {
+  switch (x.tag) {
+    case "Init": {
+      bare4.writeU8(bc, 0);
+      writeInit4(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare4.writeU8(bc, 1);
+      writeError4(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare4.writeU8(bc, 2);
+      writeActionResponse4(bc, x.val);
+      break;
+    }
+    case "Event": {
+      bare4.writeU8(bc, 3);
+      writeEvent4(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient4(bc) {
+  return {
+    body: readToClientBody4(bc)
+  };
+}
+function writeToClient4(bc, x) {
+  writeToClientBody4(bc, x.body);
+}
+function encodeToClient4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToClient4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readToClient4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActionRequest4(bc) {
+  return {
+    id: bare4.readUint(bc),
+    name: bare4.readString(bc),
+    args: readCbor4(bc)
+  };
+}
+function writeActionRequest4(bc, x) {
+  bare4.writeUint(bc, x.id);
+  bare4.writeString(bc, x.name);
+  writeCbor4(bc, x.args);
+}
+function readSubscriptionRequest4(bc) {
+  return {
+    eventName: bare4.readString(bc),
+    subscribe: bare4.readBool(bc)
+  };
+}
+function writeSubscriptionRequest4(bc, x) {
+  bare4.writeString(bc, x.eventName);
+  bare4.writeBool(bc, x.subscribe);
+}
+function readToServerBody4(bc) {
+  const offset = bc.offset;
+  const tag = bare4.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActionRequest", val: readActionRequest4(bc) };
+    case 1:
+      return { tag: "SubscriptionRequest", val: readSubscriptionRequest4(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare4.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody4(bc, x) {
+  switch (x.tag) {
+    case "ActionRequest": {
+      bare4.writeU8(bc, 0);
+      writeActionRequest4(bc, x.val);
+      break;
+    }
+    case "SubscriptionRequest": {
+      bare4.writeU8(bc, 1);
+      writeSubscriptionRequest4(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer4(bc) {
+  return {
+    body: readToServerBody4(bc)
+  };
+}
+function writeToServer4(bc, x) {
+  writeToServerBody4(bc, x.body);
+}
+function encodeToServer4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServer4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readToServer4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionRequest4(bc) {
+  return {
+    args: readCbor4(bc)
+  };
+}
+function writeHttpActionRequest4(bc, x) {
+  writeCbor4(bc, x.args);
+}
+function encodeHttpActionRequest4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpActionRequest4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionRequest4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpActionRequest4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionResponse4(bc) {
+  return {
+    output: readCbor4(bc)
+  };
+}
+function writeHttpActionResponse4(bc, x) {
+  writeCbor4(bc, x.output);
+}
+function encodeHttpActionResponse4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpActionResponse4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionResponse4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpActionResponse4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read42(bc) {
+  return bare4.readBool(bc) ? bare4.readBool(bc) : null;
+}
+function write42(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeBool(bc, x);
+  }
+}
+function read5(bc) {
+  return bare4.readBool(bc) ? bare4.readU64(bc) : null;
+}
+function write5(bc, x) {
+  bare4.writeBool(bc, x != null);
   if (x != null) {
-    bare3.writeU64(bc, x);
+    bare4.writeU64(bc, x);
   }
 }
-function readHttpQueueSendRequest(bc) {
+function readHttpQueueSendRequest2(bc) {
   return {
-    body: readCbor3(bc),
-    name: read2(bc),
-    wait: read3(bc),
-    timeout: read4(bc)
+    body: readCbor4(bc),
+    name: read04(bc),
+    wait: read42(bc),
+    timeout: read5(bc)
   };
 }
-function writeHttpQueueSendRequest(bc, x) {
-  writeCbor3(bc, x.body);
-  write2(bc, x.name);
-  write3(bc, x.wait);
-  write4(bc, x.timeout);
+function writeHttpQueueSendRequest2(bc, x) {
+  writeCbor4(bc, x.body);
+  write04(bc, x.name);
+  write42(bc, x.wait);
+  write5(bc, x.timeout);
 }
-function encodeHttpQueueSendRequest(x, config) {
-  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
-  const bc = new bare3.ByteCursor(
+function encodeHttpQueueSendRequest2(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeHttpQueueSendRequest(bc, x);
+  writeHttpQueueSendRequest2(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeHttpQueueSendRequest(bytes) {
-  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
-  const result = readHttpQueueSendRequest(bc);
+function decodeHttpQueueSendRequest2(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpQueueSendRequest2(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
+    throw new bare4.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
-function readHttpQueueSendResponse(bc) {
+function readHttpQueueSendResponse2(bc) {
   return {
-    status: bare3.readString(bc),
-    response: read03(bc)
+    status: bare4.readString(bc),
+    response: read14(bc)
   };
 }
-function writeHttpQueueSendResponse(bc, x) {
-  bare3.writeString(bc, x.status);
-  write03(bc, x.response);
+function writeHttpQueueSendResponse2(bc, x) {
+  bare4.writeString(bc, x.status);
+  write14(bc, x.response);
 }
-function encodeHttpQueueSendResponse(x, config) {
-  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
-  const bc = new bare3.ByteCursor(
+function encodeHttpQueueSendResponse2(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeHttpQueueSendResponse(bc, x);
+  writeHttpQueueSendResponse2(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeHttpQueueSendResponse(bytes) {
-  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
-  const result = readHttpQueueSendResponse(bc);
+function decodeHttpQueueSendResponse2(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpQueueSendResponse2(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
+    throw new bare4.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
-function readHttpResponseError3(bc) {
+function readHttpResponseError4(bc) {
   return {
-    group: bare3.readString(bc),
-    code: bare3.readString(bc),
-    message: bare3.readString(bc),
-    metadata: read03(bc)
+    group: bare4.readString(bc),
+    code: bare4.readString(bc),
+    message: bare4.readString(bc),
+    metadata: read14(bc),
+    actor: read32(bc)
   };
 }
-function writeHttpResponseError3(bc, x) {
-  bare3.writeString(bc, x.group);
-  bare3.writeString(bc, x.code);
-  bare3.writeString(bc, x.message);
-  write03(bc, x.metadata);
+function writeHttpResponseError4(bc, x) {
+  bare4.writeString(bc, x.group);
+  bare4.writeString(bc, x.code);
+  bare4.writeString(bc, x.message);
+  write14(bc, x.metadata);
+  write32(bc, x.actor);
 }
-function encodeHttpResponseError3(x, config) {
-  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
-  const bc = new bare3.ByteCursor(
+function encodeHttpResponseError4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeHttpResponseError3(bc, x);
+  writeHttpResponseError4(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeHttpResponseError3(bytes) {
-  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
-  const result = readHttpResponseError3(bc);
+function decodeHttpResponseError4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpResponseError4(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
+    throw new bare4.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
-function readHttpResolveResponse3(bc) {
+function readHttpResolveResponse4(bc) {
   return {
-    actorId: bare3.readString(bc)
+    actorId: bare4.readString(bc)
   };
 }
-function writeHttpResolveResponse3(bc, x) {
-  bare3.writeString(bc, x.actorId);
+function writeHttpResolveResponse4(bc, x) {
+  bare4.writeString(bc, x.actorId);
 }
-function encodeHttpResolveResponse3(x, config) {
-  const fullConfig = config != null ? bare3.Config(config) : DEFAULT_CONFIG3;
-  const bc = new bare3.ByteCursor(
+function encodeHttpResolveResponse4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeHttpResolveResponse3(bc, x);
+  writeHttpResolveResponse4(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeHttpResolveResponse3(bytes) {
-  const bc = new bare3.ByteCursor(bytes, DEFAULT_CONFIG3);
-  const result = readHttpResolveResponse3(bc);
+function decodeHttpResolveResponse4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpResolveResponse4(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
+    throw new bare4.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
 
 // src/common/client-protocol-versioned.ts
-var CURRENT_VERSION = 3;
+var CURRENT_VERSION = 4;
 var v1ToV2 = (v1Data) => {
   if (v1Data.body.tag === "Init") {
     const { actorId, connectionId } = v1Data.body.val;
@@ -2726,6 +3199,32 @@ var v2ToV1 = (v2Data) => {
 var v2ToV3 = (v2Data) => {
   return v2Data;
 };
+var v3ToV4 = (v3Data) => {
+  if (v3Data.body.tag === "Error") {
+    return {
+      body: {
+        tag: "Error",
+        val: {
+          ...v3Data.body.val,
+          actor: null
+        }
+      }
+    };
+  }
+  return v3Data;
+};
+var v4ToV3 = (v4Data) => {
+  if (v4Data.body.tag === "Error") {
+    const { actor: _, ...val } = v4Data.body.val;
+    return {
+      body: {
+        tag: "Error",
+        val
+      }
+    };
+  }
+  return v4Data;
+};
 var v3ToV2 = (v3Data) => {
   return v3Data;
 };
@@ -2735,12 +3234,26 @@ var v1ToServerV2 = (v1Data) => {
 var v2ToServerV3 = (v2Data) => {
   return v2Data;
 };
+var v3ToServerV4 = (v3Data) => {
+  return v3Data;
+};
+var v4ToServerV3 = (v4Data) => {
+  return v4Data;
+};
 var v3ToServerV2 = (v3Data) => {
   return v3Data;
 };
 var v2ToServerV1 = (v2Data) => {
   return v2Data;
 };
+var v3HttpResponseErrorToV4 = (v3Data) => ({
+  ...v3Data,
+  actor: null
+});
+var v4HttpResponseErrorToV3 = (v4Data) => {
+  const { actor: _, ...rest } = v4Data;
+  return rest;
+};
 var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
     switch (version) {
@@ -2750,6 +3263,8 @@ var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
         return decodeToServer2(bytes);
       case 3:
         return decodeToServer3(bytes);
+      case 4:
+        return decodeToServer4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2762,12 +3277,14 @@ var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
         return encodeToServer2(data);
       case 3:
         return encodeToServer3(data);
+      case 4:
+        return encodeToServer4(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
-  serializeConverters: () => [v3ToServerV2, v2ToServerV1]
+  deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+  serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1]
 });
 var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -2778,6 +3295,8 @@ var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
         return decodeToClient2(bytes);
       case 3:
         return decodeToClient3(bytes);
+      case 4:
+        return decodeToClient4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2790,12 +3309,14 @@ var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
         return encodeToClient2(data);
       case 3:
         return encodeToClient3(data);
+      case 4:
+        return encodeToClient4(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToV2, v2ToV3],
-  serializeConverters: () => [v3ToV2, v2ToV1]
+  deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+  serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1]
 });
 var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -2806,6 +3327,8 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionRequest2(bytes);
       case 3:
         return decodeHttpActionRequest3(bytes);
+      case 4:
+        return decodeHttpActionRequest4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2824,6 +3347,10 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionRequest3(
           data
         );
+      case 4:
+        return encodeHttpActionRequest4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2840,6 +3367,8 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionResponse2(bytes);
       case 3:
         return decodeHttpActionResponse3(bytes);
+      case 4:
+        return decodeHttpActionResponse4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2858,6 +3387,10 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionResponse3(
           data
         );
+      case 4:
+        return encodeHttpActionResponse4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2870,6 +3403,8 @@ var HTTP_QUEUE_SEND_REQUEST_VERSIONED = createVersionedDataHandler({
     switch (version) {
       case 3:
         return decodeHttpQueueSendRequest(bytes);
+      case 4:
+        return decodeHttpQueueSendRequest2(bytes);
       default:
         throw new Error(
           `HttpQueueSendRequest only exists in version 3+, got version ${version}`
@@ -2882,6 +3417,10 @@ var HTTP_QUEUE_SEND_REQUEST_VERSIONED = createVersionedDataHandler({
         return encodeHttpQueueSendRequest(
           data
         );
+      case 4:
+        return encodeHttpQueueSendRequest2(
+          data
+        );
       default:
         throw new Error(
           `HttpQueueSendRequest only exists in version 3+, got version ${version}`
@@ -2896,6 +3435,8 @@ var HTTP_QUEUE_SEND_RESPONSE_VERSIONED = createVersionedDataHandler({
     switch (version) {
       case 3:
         return decodeHttpQueueSendResponse(bytes);
+      case 4:
+        return decodeHttpQueueSendResponse2(bytes);
       default:
         throw new Error(
           `HttpQueueSendResponse only exists in version 3+, got version ${version}`
@@ -2908,6 +3449,10 @@ var HTTP_QUEUE_SEND_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpQueueSendResponse(
           data
         );
+      case 4:
+        return encodeHttpQueueSendResponse2(
+          data
+        );
       default:
         throw new Error(
           `HttpQueueSendResponse only exists in version 3+, got version ${version}`
@@ -2926,6 +3471,8 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return decodeHttpResponseError2(bytes);
       case 3:
         return decodeHttpResponseError3(bytes);
+      case 4:
+        return decodeHttpResponseError4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2944,12 +3491,24 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return encodeHttpResponseError3(
           data
         );
+      case 4:
+        return encodeHttpResponseError4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [],
-  serializeConverters: () => []
+  deserializeConverters: () => [
+    (data) => data,
+    (data) => data,
+    v3HttpResponseErrorToV4
+  ],
+  serializeConverters: () => [
+    v4HttpResponseErrorToV3,
+    (data) => data,
+    (data) => data
+  ]
 });
 var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -2960,6 +3519,8 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpResolveResponse2(bytes);
       case 3:
         return decodeHttpResolveResponse3(bytes);
+      case 4:
+        return decodeHttpResolveResponse4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2978,6 +3539,10 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpResolveResponse3(
           data
         );
+      case 4:
+        return encodeHttpResolveResponse4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -2990,6 +3555,11 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
 import { z as z4 } from "zod/v4";
 var UintSchema = z4.bigint();
 var OptionalUintSchema = UintSchema.nullable();
+var ActorSpecifierSchema = z4.object({
+  actorId: z4.string(),
+  generation: z4.union([z4.number(), z4.bigint()]),
+  key: z4.string().optional()
+});
 var InitSchema = z4.object({
   actorId: z4.string(),
   connectionId: z4.string()
@@ -2999,7 +3569,8 @@ var ErrorSchema = z4.object({
   code: z4.string(),
   message: z4.string(),
   metadata: z4.unknown().optional(),
-  actionId: OptionalUintSchema
+  actionId: OptionalUintSchema,
+  actor: ActorSpecifierSchema.optional()
 });
 var ActionResponseSchema = z4.object({
   id: UintSchema,
@@ -3057,7 +3628,8 @@ var HttpResponseErrorSchema = z4.object({
   group: z4.string(),
   code: z4.string(),
   message: z4.string(),
-  metadata: z4.unknown().optional()
+  metadata: z4.unknown().optional(),
+  actor: ActorSpecifierSchema.optional()
 });
 var HttpResolveRequestSchema = z4.null();
 var HttpResolveResponseSchema = z4.object({
@@ -3187,21 +3759,45 @@ async function sendHttpRequest(opts) {
         new Uint8Array(bufferResponse),
         HTTP_RESPONSE_ERROR_VERSIONED,
         HttpResponseErrorSchema,
-        // JSON: metadata is already unknown
-        (json) => json,
+        // JSON/CBOR: normalize actor generation to the public number shape.
+        (json) => ({
+          ...json,
+          actor: json.actor ? {
+            ...json.actor,
+            generation: Number(json.actor.generation)
+          } : void 0
+        }),
         // BARE: decode ArrayBuffer metadata to unknown
-        (bare4) => ({
-          group: bare4.group,
-          code: bare4.code,
-          message: bare4.message,
-          metadata: bare4.metadata ? decodeCborCompat(new Uint8Array(bare4.metadata)) : void 0
+        (bare5) => ({
+          group: bare5.group,
+          code: bare5.code,
+          message: bare5.message,
+          metadata: bare5.metadata ? decodeCborCompat(new Uint8Array(bare5.metadata)) : void 0,
+          actor: bare5.actor ? {
+            actorId: bare5.actor.actorId,
+            generation: Number(bare5.actor.generation),
+            key: bare5.actor.key ?? void 0
+          } : void 0
         })
       );
+      logger2().warn({
+        msg: "http error response",
+        group: responseData.group,
+        code: responseData.code,
+        message: responseData.message,
+        metadata: responseData.metadata,
+        actorId: responseData.actor?.actorId,
+        generation: responseData.actor?.generation,
+        actorKey: responseData.actor?.key
+      });
       throw new RivetError(
         responseData.group,
         responseData.code,
         responseData.message,
-        responseData.metadata
+        {
+          metadata: responseData.metadata,
+          actor: responseData.actor
+        }
       );
     } catch (error) {
       if (error instanceof RivetError) {
@@ -3381,11 +3977,11 @@ async function lookupMetadataCached(config) {
 }
 
 // src/engine-client/ws-proxy.ts
-async function createWebSocketProxy(c, targetUrl, protocols) {
+async function createWebSocketProxy(_c, targetUrl, protocols) {
   const WebSocket2 = await importWebSocket();
   const state = {};
   return {
-    onOpen: async (event, clientWs) => {
+    onOpen: async (_event, clientWs) => {
       logger3().debug({ msg: "client websocket connected", targetUrl });
       if (clientWs.readyState !== 1) {
         logger3().warn({
@@ -3423,23 +4019,25 @@ async function createWebSocketProxy(c, targetUrl, protocols) {
           reject(error);
         });
       });
-      state.targetWs.addEventListener("message", (event2) => {
-        if (typeof event2.data === "string" || event2.data instanceof ArrayBuffer) {
-          clientWs.send(event2.data);
-        } else if (event2.data instanceof Blob) {
-          event2.data.arrayBuffer().then((buffer) => {
+      state.connectPromise.catch(() => {
+      });
+      state.targetWs.addEventListener("message", (event) => {
+        if (typeof event.data === "string" || event.data instanceof ArrayBuffer) {
+          clientWs.send(event.data);
+        } else if (event.data instanceof Blob) {
+          event.data.arrayBuffer().then((buffer) => {
             clientWs.send(buffer);
           });
         }
       });
-      state.targetWs.addEventListener("close", (event2) => {
+      state.targetWs.addEventListener("close", (event) => {
         logger3().debug({
           msg: "target websocket closed",
           targetUrl,
-          code: event2.code,
-          reason: event2.reason
+          code: event.code,
+          reason: event.reason
         });
-        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
+        closeWebSocketIfOpen(clientWs, event.code, event.reason);
       });
       state.targetWs.addEventListener("error", (error) => {
         logger3().error({
@@ -3482,7 +4080,7 @@ async function createWebSocketProxy(c, targetUrl, protocols) {
         );
       }
     },
-    onClose: (event, clientWs) => {
+    onClose: (event, _clientWs) => {
       logger3().debug({
         msg: "client websocket closed",
         targetUrl,
@@ -3499,7 +4097,7 @@ async function createWebSocketProxy(c, targetUrl, protocols) {
         }
       }
     },
-    onError: (event, clientWs) => {
+    onError: (event, _clientWs) => {
       logger3().error({ msg: "client websocket error", targetUrl, event });
       if (state.targetWs) {
         if (state.targetWs.readyState === WebSocket2.OPEN) {
@@ -3615,7 +4213,9 @@ var RemoteEngineControlClient = class {
       name,
       key: serializeActorKey(key),
       runner_name_selector: this.#config.poolName,
-      input: actorInput ? uint8ArrayToBase64(encodeCborCompat(actorInput)) : void 0,
+      input: actorInput ? uint8ArrayToBase64(
+        encodeCborCompat(actorInput)
+      ) : void 0,
       crash_policy: crashPolicy ?? "sleep"
     });
     logger3().info({
@@ -3674,7 +4274,7 @@ var RemoteEngineControlClient = class {
     );
     const httpOptions = {
       ...options,
-      directActorId: shouldBypassConnectable(options) ? directActorIdFromTarget(target) : void 0
+      directActorId: shouldSkipReadyWait(options) ? directActorIdFromTarget(target) : void 0
     };
     return sendHttpRequestToGateway(
       this.#config,
@@ -3697,7 +4297,7 @@ var RemoteEngineControlClient = class {
       params,
       {
         ...options,
-        directActorId: shouldBypassConnectable(options) ? directActorIdFromTarget(target) : void 0
+        directActorId: shouldSkipReadyWait(options) ? directActorIdFromTarget(target) : void 0
       }
     );
   }
@@ -3769,7 +4369,7 @@ var RemoteEngineControlClient = class {
   }
   #buildGatewayUrlForTarget(target, path, options = {}) {
     const endpoint = getEndpoint(this.#config);
-    if (shouldBypassConnectable(options) && directActorIdFromTarget(target) && canUseDirectBypassPath(path)) {
+    if (shouldSkipReadyWait(options) && directActorIdFromTarget(target) && canUseDirectSkipReadyWaitPath(path)) {
       return combineUrlPath(endpoint, path);
     }
     if ("directId" in target) {
@@ -3809,8 +4409,11 @@ var RemoteEngineControlClient = class {
     throw new Error("unreachable: unknown gateway target type");
   }
 };
-function canUseDirectBypassPath(path) {
-  return isActorHttpRequestPath(path) || path === PATH_CONNECT || path === PATH_WEBSOCKET_BASE || path.startsWith(PATH_WEBSOCKET_PREFIX);
+function canUseDirectSkipReadyWaitPath(path) {
+  return isActorHttpRequestPath(path) || isPathOrQuery(path, PATH_CONNECT) || isPathOrQuery(path, PATH_WEBSOCKET_BASE) || path.startsWith(PATH_WEBSOCKET_PREFIX);
+}
+function isPathOrQuery(path, basePath) {
+  return path === basePath || path.startsWith(`${basePath}?`);
 }
 function isActorHttpRequestPath(path) {
   const stripped = path.slice("/request".length);
@@ -3849,10 +4452,9 @@ import pRetry2, { AbortError } from "p-retry";
 
 // src/client/actor-common.ts
 function resolveActorGatewayOptions(defaults = {}, overrides) {
-  const bypassConnectable = overrides?.bypassConnectable ?? overrides?.skipReadyWait ?? defaults.bypassConnectable ?? defaults.skipReadyWait ?? false;
+  const skipReadyWait = overrides?.skipReadyWait ?? defaults.skipReadyWait ?? false;
   return {
-    bypassConnectable,
-    skipReadyWait: bypassConnectable
+    skipReadyWait
   };
 }
 
@@ -4004,7 +4606,7 @@ function classifyActorError(error) {
   return void 0;
 }
 function isRetryableGuardGatewayHttpError(code) {
-  return code === "service_unavailable" || code === "actor_stopped_while_waiting" || code === "tunnel_request_aborted" || code === "tunnel_message_timeout" || code === "tunnel_response_closed" || code === "gateway_response_start_timeout";
+  return code === "service_unavailable" || code === "actor_wake_retries_exceeded" || code === "actor_stopped_while_waiting" || code === "tunnel_request_aborted" || code === "tunnel_message_timeout" || code === "tunnel_response_closed" || code === "gateway_response_start_timeout";
 }
 function classifyTransportError(error) {
   if (error.message.includes("database accessed after actor stopped")) {
@@ -4093,10 +4695,7 @@ async function retryOnLifecycleBoundary(run, opts) {
       if (attempt === maxAttempts - 1) {
         break;
       }
-      const delayMs = Math.min(
-        initialDelayMs * 2 ** attempt,
-        maxDelayMs
-      );
+      const delayMs = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
       await waitWithSignal(delayMs, opts?.signal);
     }
   }
@@ -4135,7 +4734,9 @@ function createQueueSender(senderOptions) {
       }),
       requestToBare: (value) => ({
         name: value.name ?? name,
-        body: bufferToArrayBuffer(encodeCborCompat(value.body)),
+        body: bufferToArrayBuffer(
+          encodeCborCompat(value.body)
+        ),
         wait: value.wait ?? false,
         timeout: value.timeout !== void 0 ? BigInt(value.timeout) : null
       }),
@@ -4148,13 +4749,13 @@ function createQueueSender(senderOptions) {
           response: json.response
         };
       },
-      responseFromBare: (bare4) => {
-        if (bare4.response === null || bare4.response === void 0) {
-          return { status: bare4.status };
+      responseFromBare: (bare5) => {
+        if (bare5.response === null || bare5.response === void 0) {
+          return { status: bare5.status };
         }
         return {
-          status: bare4.status,
-          response: decodeCborCompat(new Uint8Array(bare4.response))
+          status: bare5.status,
+          response: decodeCborCompat(new Uint8Array(bare5.response))
         };
       }
     });
@@ -4168,49 +4769,7 @@ function createQueueSender(senderOptions) {
   };
 }
 
-// src/client/resolve-gateway-target.ts
-async function resolveGatewayTarget(driver, target) {
-  if ("directId" in target) {
-    return target.directId;
-  }
-  if ("getForId" in target) {
-    return target.getForId.actorId;
-  }
-  if ("getForKey" in target) {
-    const output = await driver.getWithKey({
-      name: target.getForKey.name,
-      key: target.getForKey.key
-    });
-    if (!output) {
-      throw actorNotFound(
-        `${target.getForKey.name}:${JSON.stringify(target.getForKey.key)}`
-      );
-    }
-    return output.actorId;
-  }
-  if ("getOrCreateForKey" in target) {
-    const output = await driver.getOrCreateWithKey({
-      name: target.getOrCreateForKey.name,
-      key: target.getOrCreateForKey.key,
-      input: target.getOrCreateForKey.input,
-      region: target.getOrCreateForKey.region
-    });
-    return output.actorId;
-  }
-  if ("create" in target) {
-    const output = await driver.createActor({
-      name: target.create.name,
-      key: target.create.key,
-      input: target.create.input,
-      region: target.create.region
-    });
-    return output.actorId;
-  }
-  throw invalidRequest("Invalid query format");
-}
-
 // src/client/actor-conn.ts
-var DEFAULT_MAX_INCOMING_MESSAGE_SIZE = 65536;
 var CONNECT_SYMBOL = /* @__PURE__ */ Symbol("connect");
 var ActorConnRaw = class {
   #disposed = false;
@@ -4262,6 +4821,9 @@ var ActorConnRaw = class {
     this.#encoding = encoding;
     this.#actorResolutionState = actorResolutionState;
     this.#gatewayOptions = resolveActorGatewayOptions(gatewayOptions);
+    if ("getForId" in actorResolutionState) {
+      this.#actorId = actorResolutionState.getForId.actorId;
+    }
     this.#readyPromise = promiseWithResolvers(
       (reason) => logger2().warn({
         msg: "unhandled ready promise rejection",
@@ -4512,7 +5074,7 @@ var ActorConnRaw = class {
   }
   async #connectWebSocket() {
     const params = await this.#resolveConnectionParams();
-    const target = this.#gatewayOptions.bypassConnectable ? await this.#resolveGatewayTargetForBypass() : getGatewayTarget(this.#actorResolutionState);
+    const target = getGatewayTarget(this.#actorResolutionState);
     const ws = await this.#driver.openWebSocket(
       PATH_CONNECT,
       target,
@@ -4565,22 +5127,6 @@ var ActorConnRaw = class {
       }
     });
   }
-  async #resolveGatewayTargetForBypass() {
-    if ("getForId" in this.#actorResolutionState) {
-      return {
-        directId: this.#actorResolutionState.getForId.actorId
-      };
-    }
-    if (this.#actorId) {
-      return { directId: this.#actorId };
-    }
-    return {
-      directId: await resolveGatewayTarget(
-        this.#driver,
-        this.#actorResolutionState
-      )
-    };
-  }
   /** Called by the onopen event from drivers. */
   #handleOnOpen() {
     if (this.#disposed) {
@@ -4659,7 +5205,7 @@ var ActorConnRaw = class {
       });
       this.#handleOnOpen();
     } else if (response.body.tag === "Error") {
-      const { group, code, message, metadata, actionId } = response.body.val;
+      const { group, code, message, metadata, actionId, actor } = response.body.val;
       if (actionId !== null) {
         const inFlight = this.#takeActionInFlight(Number(actionId));
         this.#invalidateActorIfStale(group, code);
@@ -4670,10 +5216,16 @@ var ActorConnRaw = class {
           group,
           code,
           message,
-          metadata
+          metadata,
+          actorId: actor?.actorId,
+          generation: actor?.generation,
+          actorKey: actor?.key
         });
         inFlight.reject(
-          new RivetError(group, code, message, metadata)
+          new RivetError(group, code, message, {
+            metadata,
+            actor
+          })
         );
       } else {
         logger2().warn({
@@ -4681,21 +5233,25 @@ var ActorConnRaw = class {
           group,
           code,
           message,
-          metadata
+          metadata,
+          actorId: actor?.actorId,
+          generation: actor?.generation,
+          actorKey: actor?.key
         });
         if (this.#shouldReconnectForStaleActor(group, code)) {
           this.#clearResolvedActorIdentity();
           this.#onOpenPromise?.reject(
-            new RivetError(group, code, message, metadata)
+            new RivetError(group, code, message, {
+              metadata,
+              actor
+            })
           );
           return;
         }
-        let errorToThrow = new RivetError(
-          group,
-          code,
-          message,
-          metadata
-        );
+        let errorToThrow = new RivetError(group, code, message, {
+          metadata,
+          actor
+        });
         if (isSchedulingError(group, code) && this.#actorId) {
           const schedulingError = await checkForSchedulingError(
             group,
@@ -5091,31 +5647,8 @@ var ActorConnRaw = class {
               }
             }
           );
-          const serializedLength = messageLength(messageSerialized);
-          if (serializedLength > DEFAULT_MAX_INCOMING_MESSAGE_SIZE && message.body.tag === "ActionRequest") {
-            const actionId = Number(message.body.val.id);
-            const inFlight = this.#takeActionInFlight(actionId);
-            const error = new RivetError(
-              "message",
-              "incoming_too_long",
-              "Incoming message too long",
-              {
-                maxSize: DEFAULT_MAX_INCOMING_MESSAGE_SIZE,
-                actualSize: serializedLength
-              }
-            );
-            logger2().warn({
-              msg: "rejecting oversized connection action request",
-              actionId,
-              actionName: inFlight.name,
-              actualSize: serializedLength,
-              maxSize: DEFAULT_MAX_INCOMING_MESSAGE_SIZE
-            });
-            inFlight.reject(error);
-            this.#dispatchActorError(error);
-            return;
-          }
           this.#websocket.send(messageSerialized);
+          const serializedLength = messageLength(messageSerialized);
           logger2().trace({
             msg: "sent websocket message",
             len: serializedLength
@@ -5158,8 +5691,26 @@ var ActorConnRaw = class {
       buffer,
       CLIENT_PROTOCOL_TO_CLIENT,
       ToClientSchema,
-      // JSON: values are already the correct type
-      (msg) => msg,
+      // JSON/CBOR: normalize actor generation to the public number shape.
+      (msg) => {
+        if (msg.body.tag !== "Error" || !msg.body.val.actor) {
+          return msg;
+        }
+        return {
+          body: {
+            tag: "Error",
+            val: {
+              ...msg.body.val,
+              actor: {
+                ...msg.body.val.actor,
+                generation: Number(
+                  msg.body.val.actor.generation
+                )
+              }
+            }
+          }
+        };
+      },
       // BARE: need to decode ArrayBuffer fields back to unknown
       (msg) => {
         if (msg.body.tag === "Error") {
@@ -5175,7 +5726,14 @@ var ActorConnRaw = class {
                     msg.body.val.metadata
                   )
                 ) : null,
-                actionId: msg.body.val.actionId
+                actionId: msg.body.val.actionId,
+                actor: msg.body.val.actor ? {
+                  actorId: msg.body.val.actor.actorId,
+                  generation: Number(
+                    msg.body.val.actor.generation
+                  ),
+                  key: msg.body.val.actor.key ?? void 0
+                } : void 0
               }
             }
           };
@@ -5369,13 +5927,11 @@ async function rawHttpFetch(driver, target, params, input, init, options = {}) {
     });
     return driver.sendRequest(target, proxyRequest, options);
   } catch (err) {
-    const { group, code, message, metadata } = deconstructError(
+    const { group, code, message, metadata, actor } = deconstructError(
       err,
-      logger2(),
-      {},
       true
     );
-    throw new RivetError(group, code, message, metadata);
+    throw new RivetError(group, code, message, { metadata, actor });
   }
 }
 async function rawWebSocket(driver, target, params, path, _protocols, options = {}) {
@@ -5411,6 +5967,47 @@ async function rawWebSocket(driver, target, params, path, _protocols, options =
   return ws;
 }
 
+// src/client/resolve-gateway-target.ts
+async function resolveGatewayTarget(driver, target) {
+  if ("directId" in target) {
+    return target.directId;
+  }
+  if ("getForId" in target) {
+    return target.getForId.actorId;
+  }
+  if ("getForKey" in target) {
+    const output = await driver.getWithKey({
+      name: target.getForKey.name,
+      key: target.getForKey.key
+    });
+    if (!output) {
+      throw actorNotFound(
+        `${target.getForKey.name}:${JSON.stringify(target.getForKey.key)}`
+      );
+    }
+    return output.actorId;
+  }
+  if ("getOrCreateForKey" in target) {
+    const output = await driver.getOrCreateWithKey({
+      name: target.getOrCreateForKey.name,
+      key: target.getOrCreateForKey.key,
+      input: target.getOrCreateForKey.input,
+      region: target.getOrCreateForKey.region
+    });
+    return output.actorId;
+  }
+  if ("create" in target) {
+    const output = await driver.createActor({
+      name: target.create.name,
+      key: target.create.key,
+      input: target.create.input,
+      region: target.create.region
+    });
+    return output.actorId;
+  }
+  throw invalidRequest("Invalid query format");
+}
+
 // src/client/actor-handle.ts
 var ActorHandleRaw = class {
   #client;
@@ -5455,7 +6052,13 @@ var ActorHandleRaw = class {
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         let actorId;
         try {
-          const target = await this.#resolveActionTarget(useQueryTarget);
+          const gatewayOptions = resolveActorGatewayOptions(
+            this.#gatewayOptions
+          );
+          const target = await this.#resolveGatewayRequestTarget(
+            useQueryTarget,
+            gatewayOptions
+          );
           actorId = "directId" in target ? target.directId : void 0;
           return await createQueueSender({
             encoding: this.#encoding,
@@ -5464,19 +6067,12 @@ var ActorHandleRaw = class {
               return await this.#driver.sendRequest(
                 target,
                 request,
-                resolveActorGatewayOptions(
-                  this.#gatewayOptions
-                )
+                gatewayOptions
               );
             }
           }).send(name, body, options);
         } catch (err) {
-          const { group, code, message, metadata } = deconstructError(
-            err,
-            logger2(),
-            {},
-            true
-          );
+          const { group, code, message, metadata, actor } = deconstructError(err, true);
           if (this.#shouldRetryQueueDispatchOverload(
             group,
             code,
@@ -5509,7 +6105,10 @@ var ActorHandleRaw = class {
             await this.#waitForRetryWindow();
             continue;
           }
-          const invalidated = this.#invalidateResolvedActorId(group, code);
+          const invalidated = this.#invalidateResolvedActorId(
+            group,
+            code
+          );
           if (invalidated && attempt < maxAttempts - 1) {
             useQueryTarget = code === "starting" || code === "stopping" || code.startsWith("destroyed_");
             if (useQueryTarget) {
@@ -5517,7 +6116,10 @@ var ActorHandleRaw = class {
             }
             continue;
           }
-          throw new RivetError(group, code, message, metadata);
+          throw new RivetError(group, code, message, {
+            metadata,
+            actor
+          });
         }
       }
       throw new Error("unreachable queue retry state");
@@ -5552,7 +6154,10 @@ var ActorHandleRaw = class {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       let actorId;
       try {
-        const target = await this.#resolveActionTarget(useQueryTarget);
+        const target = await this.#resolveGatewayRequestTarget(
+          useQueryTarget,
+          gatewayOptions
+        );
         actorId = "directId" in target ? target.directId : void 0;
         logger2().debug(
           actorId ? { msg: "using direct actor gateway target", actorId } : {
@@ -5594,22 +6199,19 @@ var ActorHandleRaw = class {
             args
           }),
           requestToBare: (args) => ({
-            args: bufferToArrayBuffer(encodeCborCompat(args))
+            args: bufferToArrayBuffer(
+              encodeCborCompat(args)
+            )
           }),
           responseFromJson: (json) => json.output,
-          responseFromBare: (bare4) => decodeCborCompat(new Uint8Array(bare4.output))
+          responseFromBare: (bare5) => decodeCborCompat(new Uint8Array(bare5.output))
         });
         if (opts.name === "destroy" && actorId) {
           await this.#waitForDestroyActionToSettle(actorId);
         }
         return output;
       } catch (err) {
-        const { group, code, message, metadata } = deconstructError(
-          err,
-          logger2(),
-          {},
-          true
-        );
+        const { group, code, message, metadata, actor } = deconstructError(err, true);
         if (await this.#shouldRetrySchedulingError(
           group,
           code,
@@ -5637,18 +6239,23 @@ var ActorHandleRaw = class {
             "actor",
             "not_found",
             "The actor does not exist or was destroyed.",
-            metadata
+            { metadata, actor }
           );
         }
-        const invalidated = this.#invalidateResolvedActorId(group, code);
+        const invalidated = this.#invalidateResolvedActorId(
+          group,
+          code
+        );
         if (invalidated && attempt < maxAttempts - 1) {
           if (group === "actor" && (code === "starting" || code === "stopping")) {
             useQueryTarget = true;
-            await new Promise((resolve) => setTimeout(resolve, 100));
+            await new Promise(
+              (resolve) => setTimeout(resolve, 100)
+            );
           }
           continue;
         }
-        throw new RivetError(group, code, message, metadata);
+        throw new RivetError(group, code, message, { metadata, actor });
       }
     }
     throw new Error("unreachable action retry state");
@@ -5741,6 +6348,12 @@ var ActorHandleRaw = class {
       this.#resolvingActorId = void 0;
     }
   }
+  async #resolveGatewayRequestTarget(useQueryTarget, gatewayOptions) {
+    if (gatewayOptions.skipReadyWait) {
+      return getGatewayTarget(this.#actorResolutionState);
+    }
+    return await this.#resolveActionTarget(useQueryTarget);
+  }
   /**
    * Establishes a persistent connection to the actor.
    *
@@ -5777,15 +6390,20 @@ var ActorHandleRaw = class {
   async #fetchWithResolvedActor(input, init) {
     const maxAttempts = this.#getDynamicQueryMaxAttempts();
     let useQueryTarget = false;
-    const { bypassConnectable, skipReadyWait, ...requestInit } = init ?? {};
+    const { skipReadyWait, ...requestInit } = init ?? {};
     const gatewayOptions = resolveActorGatewayOptions(
       this.#gatewayOptions,
-      { bypassConnectable, skipReadyWait }
+      {
+        skipReadyWait
+      }
     );
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       let actorId;
       try {
-        const target = await this.#resolveActionTarget(useQueryTarget);
+        const target = await this.#resolveGatewayRequestTarget(
+          useQueryTarget,
+          gatewayOptions
+        );
         actorId = "directId" in target ? target.directId : void 0;
         const response = await rawHttpFetch(
           this.#driver,
@@ -5810,12 +6428,7 @@ var ActorHandleRaw = class {
         }
         return response;
       } catch (err) {
-        const { group, code, message, metadata } = deconstructError(
-          err,
-          logger2(),
-          {},
-          true
-        );
+        const { group, code, message, metadata, actor } = deconstructError(err, true);
         if (await this.#shouldRetrySchedulingError(
           group,
           code,
@@ -5838,7 +6451,10 @@ var ActorHandleRaw = class {
           await this.#waitForRetryWindow();
           continue;
         }
-        const invalidated = this.#invalidateResolvedActorId(group, code);
+        const invalidated = this.#invalidateResolvedActorId(
+          group,
+          code
+        );
         if (invalidated && attempt < maxAttempts - 1) {
           useQueryTarget = code === "starting" || code === "stopping" || code.startsWith("destroyed_");
           if (useQueryTarget) {
@@ -5846,7 +6462,7 @@ var ActorHandleRaw = class {
           }
           continue;
         }
-        throw new RivetError(group, code, message, metadata);
+        throw new RivetError(group, code, message, { metadata, actor });
       }
     }
     throw new Error("unreachable fetch retry state");
@@ -5906,12 +6522,23 @@ var ActorHandleRaw = class {
         new Uint8Array(await response.clone().arrayBuffer()),
         HTTP_RESPONSE_ERROR_VERSIONED,
         HttpResponseErrorSchema,
-        (json) => json,
-        (bare4) => ({
-          group: bare4.group,
-          code: bare4.code,
-          message: bare4.message,
-          metadata: bare4.metadata ? decodeCborCompat(new Uint8Array(bare4.metadata)) : void 0
+        (json) => ({
+          ...json,
+          actor: json.actor ? {
+            ...json.actor,
+            generation: Number(json.actor.generation)
+          } : void 0
+        }),
+        (bare5) => ({
+          group: bare5.group,
+          code: bare5.code,
+          message: bare5.message,
+          metadata: bare5.metadata ? decodeCborCompat(new Uint8Array(bare5.metadata)) : void 0,
+          actor: bare5.actor ? {
+            actorId: bare5.actor.actorId,
+            generation: Number(bare5.actor.generation),
+            key: bare5.actor.key ?? void 0
+          } : void 0
         })
       );
     } catch {
@@ -5927,7 +6554,11 @@ var ActorHandleRaw = class {
       this.#gatewayOptions,
       options
     );
-    const target = gatewayOptions.bypassConnectable ? await this.#resolveActionTarget(false) : getGatewayTarget(this.#actorResolutionState);
+    const useQueryTarget = isDynamicActorQuery(this.#actorResolutionState);
+    const target = await this.#resolveGatewayRequestTarget(
+      useQueryTarget,
+      gatewayOptions
+    );
     return await rawWebSocket(
       this.#driver,
       target,
@@ -5948,7 +6579,9 @@ var ActorHandleRaw = class {
     if ("directId" in target) {
       return target.directId;
     }
-    throw new Error("dynamic actor resolution did not produce a direct actor id");
+    throw new Error(
+      "dynamic actor resolution did not produce a direct actor id"
+    );
   }
   /**
    * Returns the raw URL for routing traffic to the actor.