@rivetkit/supabase 2.3.4 → 2.3.5-rc.1

package/dist/mod.js

@@ -508,7 +508,7 @@ function unsupportedFeature(feature) {
   );
 }
 
-// ../rivetkit/dist/tsup/chunk-M7DCRMOZ.js
+// ../rivetkit/dist/tsup/chunk-B4IZU537.js
 var import_pino = require("pino");
 
 // ../../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/classic/external.js
@@ -13181,7 +13181,9 @@ var classic_default = external_exports;
 // ../../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/index.js
 var v4_default = classic_default;
 
-// ../rivetkit/dist/tsup/chunk-M7DCRMOZ.js
+// ../rivetkit/dist/tsup/chunk-B4IZU537.js
+var cbor = __toESM(require("cbor-x"), 1);
+var import_invariant = __toESM(require_invariant(), 1);
 var getRivetEngine = () => getEnvUniversal("RIVET_ENGINE");
 var getRivetEndpoint = () => getEnvUniversal("RIVET_ENDPOINT");
 var getRivetToken = () => getEnvUniversal("RIVET_TOKEN");
@@ -13344,7 +13346,7 @@ function noopNext() {
 }
 var package_default = {
   name: "rivetkit",
-  version: "2.3.4",
+  version: "2.3.5-rc.1",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -13741,834 +13743,1194 @@ function quoteLogfmtString(value) {
   }
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
 }
-var VERSION = package_default.version;
-var _userAgent;
-function httpUserAgent() {
-  if (_userAgent !== void 0) {
-    return _userAgent;
+function uint8ArrayToBase642(uint8Array) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(uint8Array).toString("base64");
   }
-  let userAgent = `RivetKit/${VERSION}`;
-  const navigatorObj = typeof navigator !== "undefined" ? navigator : void 0;
-  if (navigatorObj == null ? void 0 : 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];
+  let binary = "";
+  const len = uint8Array.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(uint8Array[i]);
   }
+  return btoa(binary);
 }
-function toUint8Array(data) {
-  if (data instanceof Uint8Array) {
-    return data;
-  } else if (data instanceof ArrayBuffer) {
-    return new Uint8Array(data);
-  } else if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(
-      data.buffer.slice(
-        data.byteOffset,
-        data.byteOffset + data.byteLength
-      )
-    );
+function contentTypeForEncoding(encoding) {
+  if (encoding === "json") {
+    return "application/json";
+  } else if (encoding === "cbor" || encoding === "bare") {
+    return "application/octet-stream";
   } else {
-    throw new TypeError("Input must be ArrayBuffer or ArrayBufferView");
+    assertUnreachable(encoding);
   }
 }
-function promiseWithResolvers(onReject) {
-  let resolve;
-  let reject;
-  const promise2 = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  promise2.catch(onReject);
-  return { promise: promise2, resolve, reject };
+function encodeCborCompat(value) {
+  return cbor.encode(encodeJsonCompatValue(value));
 }
-function bufferToArrayBuffer(buf) {
-  return buf.buffer.slice(
-    buf.byteOffset,
-    buf.byteOffset + buf.byteLength
-  );
+function decodeCborCompat(buffer) {
+  return reviveJsonCompatValue(cbor.decode(buffer));
 }
-function combineUrlPath(endpoint, path2, queryParams) {
-  const baseUrl = new URL(endpoint);
-  const pathParts = path2.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)}`
-        );
-      }
+function serializeWithEncoding(encoding, value, versionedDataHandler, version2, zodSchema, toJson, toBare) {
+  if (encoding === "json") {
+    const jsonValue = toJson(value);
+    const validated = zodSchema.parse(jsonValue);
+    return jsonStringifyCompat(validated);
+  } else if (encoding === "cbor") {
+    const jsonValue = toJson(value);
+    const validated = zodSchema.parse(jsonValue);
+    return cbor.encode(validated);
+  } else if (encoding === "bare") {
+    if (!versionedDataHandler) {
+      throw new Error(
+        "VersionedDataHandler is required for 'bare' encoding"
+      );
     }
-  }
-  const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
-  return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
-}
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/imports/dev.node.js
-var DEV = process.env.NODE_ENV === "development";
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/assert.js
-var V8Error = Error;
-function assert2(test, message = "") {
-  if (!test) {
-    const e = new AssertionError(message);
-    V8Error.captureStackTrace?.(e, assert2);
-    throw e;
+    if (version2 === void 0) {
+      throw new Error("version is required for 'bare' encoding");
+    }
+    const bareValue = toBare(value);
+    return versionedDataHandler.serializeWithEmbeddedVersion(
+      bareValue,
+      version2
+    );
+  } else {
+    assertUnreachable(encoding);
   }
 }
-var AssertionError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AssertionError";
+function deserializeWithEncoding(encoding, buffer, versionedDataHandler, zodSchema, fromJson, fromBare) {
+  if (encoding === "json") {
+    let parsed;
+    if (typeof buffer === "string") {
+      parsed = jsonParseCompat(buffer);
+    } else {
+      const decoder = new TextDecoder("utf-8");
+      const jsonString = decoder.decode(buffer);
+      parsed = jsonParseCompat(jsonString);
+    }
+    const validated = zodSchema.parse(parsed);
+    return fromJson(validated);
+  } else if (encoding === "cbor") {
+    (0, import_invariant.default)(
+      typeof buffer !== "string",
+      "buffer cannot be string for cbor encoding"
+    );
+    const decoded = decodeCborCompat(buffer);
+    const validated = zodSchema.parse(decoded);
+    return fromJson(validated);
+  } else if (encoding === "bare") {
+    (0, import_invariant.default)(
+      typeof buffer !== "string",
+      "buffer cannot be string for bare encoding"
+    );
+    if (!versionedDataHandler) {
+      throw new Error(
+        "VersionedDataHandler is required for 'bare' encoding"
+      );
+    }
+    const bareValue = versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
+    return fromBare(bareValue);
+  } else {
+    assertUnreachable(encoding);
   }
-};
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/validator.js
-function isU8(val) {
-  return val === (val & 255);
 }
-function isU32(val) {
-  return val === val >>> 0;
-}
-function isU64(val) {
-  return val === BigInt.asUintN(64, val);
+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;
 }
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/constants.js
-var TEXT_DECODER_THRESHOLD = 256;
-var TEXT_ENCODER_THRESHOLD = 256;
-var INT_SAFE_MAX_BYTE_COUNT = 8;
-var UINT_MAX_BYTE_COUNT = 10;
-var UINT_SAFE32_MAX_BYTE_COUNT = 5;
-var INVALID_UTF8_STRING = "invalid UTF-8 string";
-var NON_CANONICAL_REPRESENTATION = "must be canonical";
-var TOO_LARGE_BUFFER = "too large buffer";
-var TOO_LARGE_NUMBER = "too large number";
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/bare-error.js
-var BareError = class extends Error {
-  constructor(offset, issue2, opts) {
-    super(`(byte:${offset}) ${issue2}`);
-    this.name = "BareError";
-    this.issue = issue2;
-    this.offset = offset;
-    this.cause = opts?.cause;
+function assertJsonCompatValue(value, path2 = "") {
+  var _a2;
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return;
   }
-};
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/byte-cursor.js
-var ByteCursor = class {
-  /**
-   * @throws {BareError} Buffer exceeds `config.maxBufferLength`
-   */
-  constructor(bytes, config3) {
-    this.offset = 0;
-    if (bytes.length > config3.maxBufferLength) {
-      throw new BareError(0, TOO_LARGE_BUFFER);
-    }
-    this.bytes = bytes;
-    this.config = config3;
-    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  if (typeof value === "function") {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a function and is not CBOR serializable`
+    );
   }
-};
-function check2(bc, min) {
-  if (DEV) {
-    assert2(isU32(min));
+  if (typeof value === "symbol") {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a symbol and is not CBOR serializable`
+    );
   }
-  if (bc.offset + min > bc.bytes.length) {
-    throw new BareError(bc.offset, "missing bytes");
+  if (value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof ArrayBuffer || value instanceof Uint8Array || isTypedArray(value)) {
+    return;
   }
-}
-function reserve(bc, min) {
-  if (DEV) {
-    assert2(isU32(min));
+  if (value instanceof WeakMap) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakMap and is not CBOR serializable`
+    );
   }
-  const minLen = bc.offset + min | 0;
-  if (minLen > bc.bytes.length) {
-    grow(bc, minLen);
+  if (value instanceof WeakSet) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakSet and is not CBOR serializable`
+    );
   }
-}
-function grow(bc, minLen) {
-  if (minLen > bc.config.maxBufferLength) {
-    throw new BareError(0, TOO_LARGE_BUFFER);
+  if (value instanceof WeakRef) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakRef and is not CBOR serializable`
+    );
   }
-  const buffer = bc.bytes.buffer;
-  let newBytes;
-  if (isEs2024ArrayBufferLike(buffer) && // Make sure that the view covers the end of the buffer.
-  // If it is not the case, this indicates that the user don't want
-  // to override the trailing bytes.
-  bc.bytes.byteOffset + bc.bytes.byteLength === buffer.byteLength && bc.bytes.byteLength + minLen <= buffer.maxByteLength) {
-    const newLen = Math.min(minLen << 1, bc.config.maxBufferLength, buffer.maxByteLength);
-    if (buffer instanceof ArrayBuffer) {
-      buffer.resize(newLen);
-    } else {
-      buffer.grow(newLen);
+  if (value instanceof Promise) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a Promise and is not CBOR serializable`
+    );
+  }
+  if (value instanceof Map) {
+    for (const [k, v] of value.entries()) {
+      assertJsonCompatValue(k, `${path2 || "root"}.key(${String(k)})`);
+      assertJsonCompatValue(v, `${path2 || "root"}.value(${String(k)})`);
     }
-    newBytes = new Uint8Array(buffer, bc.bytes.byteOffset, newLen);
-  } else {
-    const newLen = Math.min(minLen << 1, bc.config.maxBufferLength);
-    newBytes = new Uint8Array(newLen);
-    newBytes.set(bc.bytes);
+    return;
   }
-  bc.bytes = newBytes;
-  bc.view = new DataView(newBytes.buffer);
-}
-function isEs2024ArrayBufferLike(buffer) {
-  return "maxByteLength" in buffer;
-}
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/fixed-primitive.js
-function readBool(bc) {
-  const val = readU8(bc);
-  if (val > 1) {
-    bc.offset--;
-    throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
+  if (value instanceof Set) {
+    let index = 0;
+    for (const item of value.values()) {
+      assertJsonCompatValue(item, `${path2 || "root"}.set[${index}]`);
+      index++;
+    }
+    return;
   }
-  return val > 0;
-}
-function writeBool(bc, x) {
-  writeU8(bc, x ? 1 : 0);
-}
-function readU8(bc) {
-  check2(bc, 1);
-  return bc.bytes[bc.offset++];
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      assertJsonCompatValue(value[i], `${path2 || "root"}[${i}]`);
+    }
+    return;
+  }
+  if (isPlainObject2(value)) {
+    for (const key in value) {
+      assertJsonCompatValue(
+        value[key],
+        path2 ? `${path2}.${key}` : key
+      );
+    }
+    return;
+  }
+  const typeName = typeof value === "object" && value !== null ? ((_a2 = value.constructor) == null ? void 0 : _a2.name) ?? typeof value : typeof value;
+  throw new TypeError(
+    `Value at ${path2 || "root"} of type "${typeName}" is not CBOR serializable`
+  );
 }
-function writeU8(bc, x) {
-  if (DEV) {
-    assert2(isU8(x), TOO_LARGE_NUMBER);
+var EncodingSchema = external_exports.enum(["json", "cbor", "bare"]);
+async function inputDataToBuffer(data) {
+  if (typeof data === "string") {
+    return data;
   }
-  reserve(bc, 1);
-  bc.bytes[bc.offset++] = x;
+  if (data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  throw new Error("Malformed message");
 }
-function readU32(bc) {
-  check2(bc, 4);
-  const result = bc.view.getUint32(bc.offset, true);
-  bc.offset += 4;
-  return result;
+function base64EncodeUint8Array(uint8Array) {
+  let binary = "";
+  for (const value of uint8Array) {
+    binary += String.fromCharCode(value);
+  }
+  return btoa(binary);
 }
-function readU64(bc) {
-  check2(bc, 8);
-  const result = bc.view.getBigUint64(bc.offset, true);
-  bc.offset += 8;
-  return result;
+function base64EncodeArrayBuffer(arrayBuffer) {
+  return base64EncodeUint8Array(new Uint8Array(arrayBuffer));
 }
-function writeU64(bc, x) {
-  if (DEV) {
-    assert2(isU64(x), TOO_LARGE_NUMBER);
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
   }
-  reserve(bc, 8);
-  bc.view.setBigUint64(bc.offset, x, true);
-  bc.offset += 8;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/uint.js
-function readUint(bc) {
-  let low = readU8(bc);
-  if (low >= 128) {
-    low &= 127;
-    let shiftMul = 128;
-    let byteCount = 1;
-    let byte;
-    do {
-      byte = readU8(bc);
-      low += (byte & 127) * shiftMul;
-      shiftMul *= /* 2**7 */
-      128;
-      byteCount++;
-    } while (byte >= 128 && byteCount < 7);
-    let height = 0;
-    shiftMul = 1;
-    while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
-      byte = readU8(bc);
-      height += (byte & 127) * shiftMul;
-      shiftMul *= /* 2**7 */
-      128;
-      byteCount++;
-    }
-    if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
-      bc.offset -= byteCount;
-      throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
-    }
-    return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
+function encodeJsonCompatValue(input) {
+  var _a2;
+  if (input === null) {
+    return input;
   }
-  return BigInt(low);
-}
-function writeUint(bc, x) {
-  const truncated = BigInt.asUintN(64, x);
-  if (DEV) {
-    assert2(truncated === x, TOO_LARGE_NUMBER);
+  if (input === void 0) {
+    return [JSON_COMPAT_UNDEFINED, 0];
   }
-  writeUintTruncated(bc, truncated);
-}
-function writeUintTruncated(bc, x) {
-  let tmp = Number(BigInt.asUintN(7 * 7, x));
-  let rest = Number(x >> BigInt(7 * 7));
-  let byteCount = 0;
-  while (tmp >= 128 || rest > 0) {
-    writeU8(bc, 128 | tmp & 127);
-    tmp = Math.floor(tmp / /* 2**7 */
-    128);
-    byteCount++;
-    if (byteCount === 7) {
-      tmp = rest;
-      rest = 0;
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return input;
+  }
+  if (typeof input === "bigint") {
+    return [JSON_COMPAT_BIGINT, input.toString()];
+  }
+  if (input instanceof ArrayBuffer) {
+    return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(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;
   }
-  writeU8(bc, tmp);
-}
-function readUintSafe32(bc) {
-  let result = readU8(bc);
-  if (result >= 128) {
-    result &= 127;
-    let shift = 7;
-    let byteCount = 1;
-    let byte;
-    do {
-      byte = readU8(bc);
-      result += (byte & 127) << shift >>> 0;
-      shift += 7;
-      byteCount++;
-    } while (byte >= 128 && byteCount < UINT_SAFE32_MAX_BYTE_COUNT);
-    if (byte === 0) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+  if (Array.isArray(input)) {
+    const encoded = input.map(
+      (value) => encodeJsonCompatValue(value)
+    );
+    if (encoded.length === 2 && typeof encoded[0] === "string" && encoded[0].startsWith("$")) {
+      return [`$${encoded[0]}`, encoded[1]];
     }
-    if (byteCount === UINT_SAFE32_MAX_BYTE_COUNT && byte > 15) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    return encoded;
+  }
+  if (isPlainObject2(input)) {
+    const encoded = {};
+    for (const [key, value] of Object.entries(input)) {
+      encoded[key] = encodeJsonCompatValue(value);
     }
+    return encoded;
   }
-  return result;
+  const typeName = typeof input === "object" && input !== null ? ((_a2 = input.constructor) == null ? void 0 : _a2.name) ?? typeof input : typeof input;
+  throw new TypeError(`Value of type "${typeName}" is not CBOR serializable`);
 }
-function writeUintSafe32(bc, x) {
-  if (DEV) {
-    assert2(isU32(x), TOO_LARGE_NUMBER);
+function reviveJsonCompatValue(input, options = {}) {
+  if (typeof input === "bigint") {
+    if (options.coerceSafeIntegerBigInts && input >= BigInt(Number.MIN_SAFE_INTEGER) && input <= BigInt(Number.MAX_SAFE_INTEGER)) {
+      return Number(input);
+    }
+    return input;
   }
-  let zigZag = x >>> 0;
-  while (zigZag >= 128) {
-    writeU8(bc, 128 | zigZag & 127);
-    zigZag >>>= 7;
+  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;
   }
-  writeU8(bc, zigZag);
-}
-function readUintSafe(bc) {
-  let result = readU8(bc);
-  if (result >= 128) {
-    result &= 127;
-    let shiftMul = (
-      /* 2**7 */
-      128
-    );
-    let byteCount = 1;
-    let byte;
-    do {
-      byte = readU8(bc);
-      result += (byte & 127) * shiftMul;
-      shiftMul *= /* 2**7 */
-      128;
-      byteCount++;
-    } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
-    if (byte === 0) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+  if (Array.isArray(input)) {
+    if (input.length === 2 && typeof input[0] === "string" && input[0].startsWith("$")) {
+      if (input[0] === JSON_COMPAT_BIGINT) {
+        return BigInt(input[1]);
+      }
+      if (input[0] === JSON_COMPAT_ARRAY_BUFFER) {
+        return base64DecodeToArrayBuffer(input[1]);
+      }
+      if (input[0] === JSON_COMPAT_UINT8_ARRAY) {
+        return base64DecodeToUint8Array(input[1]);
+      }
+      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),
+          reviveJsonCompatValue(input[1], options)
+        ];
+      }
+      throw new Error(
+        `Unknown JSON encoding type: ${input[0]}. This may indicate corrupted data or a version mismatch.`
+      );
     }
-    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && byte > 15) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    return input.map((value) => reviveJsonCompatValue(value, options));
+  }
+  if (isPlainObject2(input)) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(input)) {
+      decoded[key] = reviveJsonCompatValue(value, options);
     }
+    return decoded;
   }
-  return result;
+  return input;
 }
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/u8-array.js
-function readU8Array(bc) {
-  return readU8FixedArray(bc, readUintSafe32(bc));
+function base64DecodeToUint8Array(base643) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base643, "base64"));
+  }
+  const binary = atob(base643);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
 }
-function writeU8Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  writeU8FixedArray(bc, x);
+function base64DecodeToArrayBuffer(base643) {
+  return base64DecodeToUint8Array(base643).buffer;
 }
-function readU8FixedArray(bc, len) {
-  return readUnsafeU8FixedArray(bc, len).slice();
+function jsonStringifyCompat(input, space) {
+  return JSON.stringify(
+    input,
+    (_key, value) => {
+      if (typeof value === "bigint") {
+        return [JSON_COMPAT_BIGINT, value.toString()];
+      }
+      if (value instanceof ArrayBuffer) {
+        return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(value)];
+      }
+      if (value instanceof Uint8Array) {
+        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;
+    },
+    space
+  );
 }
-function writeU8FixedArray(bc, x) {
-  const len = x.length;
-  if (len > 0) {
-    reserve(bc, len);
-    bc.bytes.set(x, bc.offset);
-    bc.offset += len;
+function jsonParseCompat(input) {
+  return reviveJsonCompatValue(JSON.parse(input));
+}
+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 == null ? void 0 : navigatorObj.userAgent) userAgent += ` ${navigatorObj.userAgent}`;
+  _userAgent = userAgent;
+  return userAgent;
 }
-function readUnsafeU8FixedArray(bc, len) {
-  if (DEV) {
-    assert2(isU32(len));
+function getEnvUniversal(key) {
+  if (typeof Deno !== "undefined") {
+    return Deno.env.get(key);
+  } else if (typeof process !== "undefined") {
+    return process.env[key];
   }
-  check2(bc, len);
-  const offset = bc.offset;
-  bc.offset += len;
-  return bc.bytes.subarray(offset, offset + len);
 }
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/data.js
-function readData(bc) {
-  return readU8Array(bc).buffer;
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  } else if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  } else if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(
+      data.buffer.slice(
+        data.byteOffset,
+        data.byteOffset + data.byteLength
+      )
+    );
+  } else {
+    throw new TypeError("Input must be ArrayBuffer or ArrayBufferView");
+  }
 }
-function writeData(bc, x) {
-  writeU8Array(bc, new Uint8Array(x));
+function promiseWithResolvers(onReject) {
+  let resolve;
+  let reject;
+  const promise2 = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  promise2.catch(onReject);
+  return { promise: promise2, resolve, reject };
 }
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/string.js
-function readString(bc) {
-  return readFixedString(bc, readUintSafe32(bc));
+function bufferToArrayBuffer(buf) {
+  return buf.buffer.slice(
+    buf.byteOffset,
+    buf.byteOffset + buf.byteLength
+  );
 }
-function writeString(bc, x) {
-  if (x.length < TEXT_ENCODER_THRESHOLD) {
-    const byteLen = utf8ByteLength(x);
-    writeUintSafe32(bc, byteLen);
-    reserve(bc, byteLen);
-    writeUtf8Js(bc, x);
-  } else {
-    const strBytes = UTF8_ENCODER.encode(x);
-    writeUintSafe32(bc, strBytes.length);
-    writeU8FixedArray(bc, strBytes);
+function combineUrlPath(endpoint, path2, queryParams) {
+  const baseUrl = new URL(endpoint);
+  const pathParts = path2.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);
   }
-}
-function readFixedString(bc, byteLen) {
-  if (DEV) {
-    assert2(isU32(byteLen));
+  if (queryParams) {
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (value !== void 0) {
+        queryParts.push(
+          `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+        );
+      }
+    }
   }
-  if (byteLen < TEXT_DECODER_THRESHOLD) {
-    return readUtf8Js(bc, byteLen);
+  const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+  return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
+}
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/imports/dev.node.js
+var DEV = process.env.NODE_ENV === "development";
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/assert.js
+var V8Error = Error;
+function assert2(test, message = "") {
+  if (!test) {
+    const e = new AssertionError(message);
+    V8Error.captureStackTrace?.(e, assert2);
+    throw e;
   }
-  try {
-    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
-  } catch (_cause) {
-    throw new BareError(bc.offset, INVALID_UTF8_STRING);
+}
+var AssertionError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "AssertionError";
   }
+};
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/validator.js
+function isU8(val) {
+  return val === (val & 255);
 }
-function readUtf8Js(bc, byteLen) {
-  check2(bc, byteLen);
-  let result = "";
-  const bytes = bc.bytes;
-  let offset = bc.offset;
-  const upperOffset = offset + byteLen;
-  while (offset < upperOffset) {
-    let codePoint = bytes[offset++];
-    if (codePoint > 127) {
-      let malformed = true;
-      const byte1 = codePoint;
-      if (offset < upperOffset && codePoint < 224) {
-        const byte2 = bytes[offset++];
-        codePoint = (byte1 & 31) << 6 | byte2 & 63;
-        malformed = codePoint >> 7 === 0 || // non-canonical char
-        byte1 >> 5 !== 6 || // invalid tag
-        byte2 >> 6 !== 2;
-      } else if (offset + 1 < upperOffset && codePoint < 240) {
-        const byte2 = bytes[offset++];
-        const byte3 = bytes[offset++];
-        codePoint = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
-        malformed = codePoint >> 11 === 0 || // non-canonical char or missing data
-        codePoint >> 11 === 27 || // surrogate char (0xD800 <= codePoint <= 0xDFFF)
-        byte1 >> 4 !== 14 || // invalid tag
-        byte2 >> 6 !== 2 || // invalid tag
-        byte3 >> 6 !== 2;
-      } else if (offset + 2 < upperOffset) {
-        const byte2 = bytes[offset++];
-        const byte3 = bytes[offset++];
-        const byte4 = bytes[offset++];
-        codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
-        malformed = codePoint >> 16 === 0 || // non-canonical char or missing data
-        codePoint > 1114111 || // too large code point
-        byte1 >> 3 !== 30 || // invalid tag
-        byte2 >> 6 !== 2 || // invalid tag
-        byte3 >> 6 !== 2 || // invalid tag
-        byte4 >> 6 !== 2;
-      }
-      if (malformed) {
-        throw new BareError(bc.offset, INVALID_UTF8_STRING);
-      }
+function isU32(val) {
+  return val === val >>> 0;
+}
+function isU64(val) {
+  return val === BigInt.asUintN(64, val);
+}
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/util/constants.js
+var TEXT_DECODER_THRESHOLD = 256;
+var TEXT_ENCODER_THRESHOLD = 256;
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+var UINT_MAX_BYTE_COUNT = 10;
+var UINT_SAFE32_MAX_BYTE_COUNT = 5;
+var INVALID_UTF8_STRING = "invalid UTF-8 string";
+var NON_CANONICAL_REPRESENTATION = "must be canonical";
+var TOO_LARGE_BUFFER = "too large buffer";
+var TOO_LARGE_NUMBER = "too large number";
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/bare-error.js
+var BareError = class extends Error {
+  constructor(offset, issue2, opts) {
+    super(`(byte:${offset}) ${issue2}`);
+    this.name = "BareError";
+    this.issue = issue2;
+    this.offset = offset;
+    this.cause = opts?.cause;
+  }
+};
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/byte-cursor.js
+var ByteCursor = class {
+  /**
+   * @throws {BareError} Buffer exceeds `config.maxBufferLength`
+   */
+  constructor(bytes, config3) {
+    this.offset = 0;
+    if (bytes.length > config3.maxBufferLength) {
+      throw new BareError(0, TOO_LARGE_BUFFER);
     }
-    result += String.fromCodePoint(codePoint);
+    this.bytes = bytes;
+    this.config = config3;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  }
+};
+function check2(bc, min) {
+  if (DEV) {
+    assert2(isU32(min));
+  }
+  if (bc.offset + min > bc.bytes.length) {
+    throw new BareError(bc.offset, "missing bytes");
   }
-  bc.offset = offset;
-  return result;
 }
-function writeUtf8Js(bc, s) {
-  const bytes = bc.bytes;
-  let offset = bc.offset;
-  let i = 0;
-  while (i < s.length) {
-    const codePoint = s.codePointAt(i++);
-    if (codePoint < 128) {
-      bytes[offset++] = codePoint;
-    } else {
-      if (codePoint < 2048) {
-        bytes[offset++] = 192 | codePoint >> 6;
-      } else {
-        if (codePoint < 65536) {
-          bytes[offset++] = 224 | codePoint >> 12;
-        } else {
-          bytes[offset++] = 240 | codePoint >> 18;
-          bytes[offset++] = 128 | codePoint >> 12 & 63;
-          i++;
-        }
-        bytes[offset++] = 128 | codePoint >> 6 & 63;
-      }
-      bytes[offset++] = 128 | codePoint & 63;
-    }
+function reserve(bc, min) {
+  if (DEV) {
+    assert2(isU32(min));
+  }
+  const minLen = bc.offset + min | 0;
+  if (minLen > bc.bytes.length) {
+    grow(bc, minLen);
   }
-  bc.offset = offset;
 }
-function utf8ByteLength(s) {
-  let result = s.length;
-  for (let i = 0; i < s.length; i++) {
-    const codePoint = s.codePointAt(i);
-    if (codePoint > 127) {
-      result++;
-      if (codePoint > 2047) {
-        result++;
-        if (codePoint > 65535) {
-          i++;
-        }
-      }
+function grow(bc, minLen) {
+  if (minLen > bc.config.maxBufferLength) {
+    throw new BareError(0, TOO_LARGE_BUFFER);
+  }
+  const buffer = bc.bytes.buffer;
+  let newBytes;
+  if (isEs2024ArrayBufferLike(buffer) && // Make sure that the view covers the end of the buffer.
+  // If it is not the case, this indicates that the user don't want
+  // to override the trailing bytes.
+  bc.bytes.byteOffset + bc.bytes.byteLength === buffer.byteLength && bc.bytes.byteLength + minLen <= buffer.maxByteLength) {
+    const newLen = Math.min(minLen << 1, bc.config.maxBufferLength, buffer.maxByteLength);
+    if (buffer instanceof ArrayBuffer) {
+      buffer.resize(newLen);
+    } else {
+      buffer.grow(newLen);
     }
+    newBytes = new Uint8Array(buffer, bc.bytes.byteOffset, newLen);
+  } else {
+    const newLen = Math.min(minLen << 1, bc.config.maxBufferLength);
+    newBytes = new Uint8Array(newLen);
+    newBytes.set(bc.bytes);
   }
-  return result;
+  bc.bytes = newBytes;
+  bc.view = new DataView(newBytes.buffer);
 }
-var UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
-var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
-
-// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/config.js
-function Config({ initialBufferLength = 1024, maxBufferLength = 1024 * 1024 * 32 }) {
-  if (DEV) {
-    assert2(isU32(initialBufferLength), TOO_LARGE_NUMBER);
-    assert2(isU32(maxBufferLength), TOO_LARGE_NUMBER);
-    assert2(initialBufferLength <= maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
-  }
-  return {
-    initialBufferLength,
-    maxBufferLength
-  };
+function isEs2024ArrayBufferLike(buffer) {
+  return "maxByteLength" in buffer;
 }
 
-// ../rivetkit/dist/tsup/chunk-GXW3VFJQ.js
-var config2 = /* @__PURE__ */ Config({});
-function readWorkflowCbor(bc) {
-  return readData(bc);
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/fixed-primitive.js
+function readBool(bc) {
+  const val = readU8(bc);
+  if (val > 1) {
+    bc.offset--;
+    throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
+  }
+  return val > 0;
 }
-function readWorkflowNameIndex(bc) {
-  return readU32(bc);
+function writeBool(bc, x) {
+  writeU8(bc, x ? 1 : 0);
 }
-function readWorkflowLoopIterationMarker(bc) {
-  return {
-    loop: readWorkflowNameIndex(bc),
-    iteration: readU32(bc)
-  };
+function readU8(bc) {
+  check2(bc, 1);
+  return bc.bytes[bc.offset++];
 }
-function readWorkflowPathSegment(bc) {
-  const offset = bc.offset;
-  const tag = readU8(bc);
-  switch (tag) {
-    case 0:
-      return { tag: "WorkflowNameIndex", val: readWorkflowNameIndex(bc) };
-    case 1:
-      return {
-        tag: "WorkflowLoopIterationMarker",
-        val: readWorkflowLoopIterationMarker(bc)
-      };
-    default: {
-      bc.offset = offset;
-      throw new BareError(offset, "invalid tag");
-    }
+function writeU8(bc, x) {
+  if (DEV) {
+    assert2(isU8(x), TOO_LARGE_NUMBER);
   }
+  reserve(bc, 1);
+  bc.bytes[bc.offset++] = x;
 }
-function readWorkflowLocation(bc) {
-  const len = readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readWorkflowPathSegment(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readWorkflowPathSegment(bc);
-  }
+function readU32(bc) {
+  check2(bc, 4);
+  const result = bc.view.getUint32(bc.offset, true);
+  bc.offset += 4;
   return result;
 }
-function readWorkflowEntryStatus(bc) {
-  const offset = bc.offset;
-  const tag = readU8(bc);
-  switch (tag) {
-    case 0:
-      return "PENDING";
-    case 1:
-      return "RUNNING";
-    case 2:
-      return "COMPLETED";
-    case 3:
-      return "FAILED";
-    case 4:
-      return "EXHAUSTED";
-    default: {
-      bc.offset = offset;
-      throw new BareError(offset, "invalid tag");
-    }
-  }
+function readU64(bc) {
+  check2(bc, 8);
+  const result = bc.view.getBigUint64(bc.offset, true);
+  bc.offset += 8;
+  return result;
 }
-function readWorkflowSleepState(bc) {
-  const offset = bc.offset;
-  const tag = readU8(bc);
-  switch (tag) {
-    case 0:
-      return "PENDING";
-    case 1:
-      return "COMPLETED";
-    case 2:
-      return "INTERRUPTED";
-    default: {
-      bc.offset = offset;
-      throw new BareError(offset, "invalid tag");
-    }
+function writeU64(bc, x) {
+  if (DEV) {
+    assert2(isU64(x), TOO_LARGE_NUMBER);
   }
+  reserve(bc, 8);
+  bc.view.setBigUint64(bc.offset, x, true);
+  bc.offset += 8;
 }
-function readWorkflowBranchStatusType(bc) {
-  const offset = bc.offset;
-  const tag = readU8(bc);
-  switch (tag) {
-    case 0:
-      return "PENDING";
-    case 1:
-      return "RUNNING";
-    case 2:
-      return "COMPLETED";
-    case 3:
-      return "FAILED";
-    case 4:
-      return "CANCELLED";
-    default: {
-      bc.offset = offset;
-      throw new BareError(offset, "invalid tag");
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/uint.js
+function readUint(bc) {
+  let low = readU8(bc);
+  if (low >= 128) {
+    low &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      low += (byte & 127) * shiftMul;
+      shiftMul *= /* 2**7 */
+      128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < 7);
+    let height = 0;
+    shiftMul = 1;
+    while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
+      byte = readU8(bc);
+      height += (byte & 127) * shiftMul;
+      shiftMul *= /* 2**7 */
+      128;
+      byteCount++;
+    }
+    if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
+      bc.offset -= byteCount;
+      throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
     }
+    return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
   }
+  return BigInt(low);
 }
-function read0(bc) {
-  return readBool(bc) ? readWorkflowCbor(bc) : null;
-}
-function read1(bc) {
-  return readBool(bc) ? readString(bc) : null;
-}
-function readWorkflowStepEntry(bc) {
-  return {
-    output: read0(bc),
-    error: read1(bc)
-  };
-}
-function readWorkflowLoopEntry(bc) {
-  return {
-    state: readWorkflowCbor(bc),
-    iteration: readU32(bc),
-    output: read0(bc)
-  };
-}
-function readWorkflowSleepEntry(bc) {
-  return {
-    deadline: readU64(bc),
-    state: readWorkflowSleepState(bc)
-  };
+function writeUint(bc, x) {
+  const truncated = BigInt.asUintN(64, x);
+  if (DEV) {
+    assert2(truncated === x, TOO_LARGE_NUMBER);
+  }
+  writeUintTruncated(bc, truncated);
 }
-function readWorkflowMessageEntry(bc) {
-  return {
-    name: readString(bc),
-    messageData: readWorkflowCbor(bc)
-  };
+function writeUintTruncated(bc, x) {
+  let tmp = Number(BigInt.asUintN(7 * 7, x));
+  let rest = Number(x >> BigInt(7 * 7));
+  let byteCount = 0;
+  while (tmp >= 128 || rest > 0) {
+    writeU8(bc, 128 | tmp & 127);
+    tmp = Math.floor(tmp / /* 2**7 */
+    128);
+    byteCount++;
+    if (byteCount === 7) {
+      tmp = rest;
+      rest = 0;
+    }
+  }
+  writeU8(bc, tmp);
 }
-function readWorkflowRollbackCheckpointEntry(bc) {
-  return {
-    name: readString(bc)
-  };
+function readUintSafe32(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shift = 7;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) << shift >>> 0;
+      shift += 7;
+      byteCount++;
+    } while (byte >= 128 && byteCount < UINT_SAFE32_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+    }
+    if (byteCount === UINT_SAFE32_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  return result;
 }
-function readWorkflowBranchStatus(bc) {
-  return {
-    status: readWorkflowBranchStatusType(bc),
-    output: read0(bc),
-    error: read1(bc)
-  };
+function writeUintSafe32(bc, x) {
+  if (DEV) {
+    assert2(isU32(x), TOO_LARGE_NUMBER);
+  }
+  let zigZag = x >>> 0;
+  while (zigZag >= 128) {
+    writeU8(bc, 128 | zigZag & 127);
+    zigZag >>>= 7;
+  }
+  writeU8(bc, zigZag);
 }
-function read2(bc) {
-  const len = readUintSafe(bc);
-  const result = /* @__PURE__ */ new Map();
-  for (let i = 0; i < len; i++) {
-    const offset = bc.offset;
-    const key = readString(bc);
-    if (result.has(key)) {
-      bc.offset = offset;
-      throw new BareError(offset, "duplicated key");
+function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = (
+      /* 2**7 */
+      128
+    );
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= /* 2**7 */
+      128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+    }
+    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
     }
-    result.set(key, readWorkflowBranchStatus(bc));
   }
   return result;
 }
-function readWorkflowJoinEntry(bc) {
-  return {
-    branches: read2(bc)
-  };
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/u8-array.js
+function readU8Array(bc) {
+  return readU8FixedArray(bc, readUintSafe32(bc));
 }
-function readWorkflowRaceEntry(bc) {
-  return {
-    winner: read1(bc),
-    branches: read2(bc)
-  };
+function writeU8Array(bc, x) {
+  writeUintSafe32(bc, x.length);
+  writeU8FixedArray(bc, x);
 }
-function readWorkflowRemovedEntry(bc) {
-  return {
-    originalType: readString(bc),
-    originalName: read1(bc)
-  };
+function readU8FixedArray(bc, len) {
+  return readUnsafeU8FixedArray(bc, len).slice();
 }
-function readWorkflowVersionCheckEntry(bc) {
-  return {
-    resolved: readU32(bc),
-    latest: readU32(bc)
-  };
+function writeU8FixedArray(bc, x) {
+  const len = x.length;
+  if (len > 0) {
+    reserve(bc, len);
+    bc.bytes.set(x, bc.offset);
+    bc.offset += len;
+  }
 }
-function readWorkflowEntryKind(bc) {
-  const offset = bc.offset;
-  const tag = readU8(bc);
-  switch (tag) {
-    case 0:
-      return { tag: "WorkflowStepEntry", val: readWorkflowStepEntry(bc) };
-    case 1:
-      return { tag: "WorkflowLoopEntry", val: readWorkflowLoopEntry(bc) };
-    case 2:
-      return {
-        tag: "WorkflowSleepEntry",
-        val: readWorkflowSleepEntry(bc)
-      };
-    case 3:
-      return {
-        tag: "WorkflowMessageEntry",
-        val: readWorkflowMessageEntry(bc)
-      };
-    case 4:
-      return {
-        tag: "WorkflowRollbackCheckpointEntry",
-        val: readWorkflowRollbackCheckpointEntry(bc)
-      };
-    case 5:
-      return { tag: "WorkflowJoinEntry", val: readWorkflowJoinEntry(bc) };
-    case 6:
-      return { tag: "WorkflowRaceEntry", val: readWorkflowRaceEntry(bc) };
-    case 7:
-      return {
-        tag: "WorkflowRemovedEntry",
-        val: readWorkflowRemovedEntry(bc)
-      };
-    case 8:
-      return {
-        tag: "WorkflowVersionCheckEntry",
-        val: readWorkflowVersionCheckEntry(bc)
-      };
-    default: {
-      bc.offset = offset;
-      throw new BareError(offset, "invalid tag");
-    }
+function readUnsafeU8FixedArray(bc, len) {
+  if (DEV) {
+    assert2(isU32(len));
   }
+  check2(bc, len);
+  const offset = bc.offset;
+  bc.offset += len;
+  return bc.bytes.subarray(offset, offset + len);
 }
-function readWorkflowEntry(bc) {
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/data.js
+function readData(bc) {
+  return readU8Array(bc).buffer;
+}
+function writeData(bc, x) {
+  writeU8Array(bc, new Uint8Array(x));
+}
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/codec/string.js
+function readString(bc) {
+  return readFixedString(bc, readUintSafe32(bc));
+}
+function writeString(bc, x) {
+  if (x.length < TEXT_ENCODER_THRESHOLD) {
+    const byteLen = utf8ByteLength(x);
+    writeUintSafe32(bc, byteLen);
+    reserve(bc, byteLen);
+    writeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    writeUintSafe32(bc, strBytes.length);
+    writeU8FixedArray(bc, strBytes);
+  }
+}
+function readFixedString(bc, byteLen) {
+  if (DEV) {
+    assert2(isU32(byteLen));
+  }
+  if (byteLen < TEXT_DECODER_THRESHOLD) {
+    return readUtf8Js(bc, byteLen);
+  }
+  try {
+    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
+  } catch (_cause) {
+    throw new BareError(bc.offset, INVALID_UTF8_STRING);
+  }
+}
+function readUtf8Js(bc, byteLen) {
+  check2(bc, byteLen);
+  let result = "";
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  const upperOffset = offset + byteLen;
+  while (offset < upperOffset) {
+    let codePoint = bytes[offset++];
+    if (codePoint > 127) {
+      let malformed = true;
+      const byte1 = codePoint;
+      if (offset < upperOffset && codePoint < 224) {
+        const byte2 = bytes[offset++];
+        codePoint = (byte1 & 31) << 6 | byte2 & 63;
+        malformed = codePoint >> 7 === 0 || // non-canonical char
+        byte1 >> 5 !== 6 || // invalid tag
+        byte2 >> 6 !== 2;
+      } else if (offset + 1 < upperOffset && codePoint < 240) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        codePoint = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
+        malformed = codePoint >> 11 === 0 || // non-canonical char or missing data
+        codePoint >> 11 === 27 || // surrogate char (0xD800 <= codePoint <= 0xDFFF)
+        byte1 >> 4 !== 14 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        byte3 >> 6 !== 2;
+      } else if (offset + 2 < upperOffset) {
+        const byte2 = bytes[offset++];
+        const byte3 = bytes[offset++];
+        const byte4 = bytes[offset++];
+        codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+        malformed = codePoint >> 16 === 0 || // non-canonical char or missing data
+        codePoint > 1114111 || // too large code point
+        byte1 >> 3 !== 30 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        byte3 >> 6 !== 2 || // invalid tag
+        byte4 >> 6 !== 2;
+      }
+      if (malformed) {
+        throw new BareError(bc.offset, INVALID_UTF8_STRING);
+      }
+    }
+    result += String.fromCodePoint(codePoint);
+  }
+  bc.offset = offset;
+  return result;
+}
+function writeUtf8Js(bc, s) {
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  let i = 0;
+  while (i < s.length) {
+    const codePoint = s.codePointAt(i++);
+    if (codePoint < 128) {
+      bytes[offset++] = codePoint;
+    } else {
+      if (codePoint < 2048) {
+        bytes[offset++] = 192 | codePoint >> 6;
+      } else {
+        if (codePoint < 65536) {
+          bytes[offset++] = 224 | codePoint >> 12;
+        } else {
+          bytes[offset++] = 240 | codePoint >> 18;
+          bytes[offset++] = 128 | codePoint >> 12 & 63;
+          i++;
+        }
+        bytes[offset++] = 128 | codePoint >> 6 & 63;
+      }
+      bytes[offset++] = 128 | codePoint & 63;
+    }
+  }
+  bc.offset = offset;
+}
+function utf8ByteLength(s) {
+  let result = s.length;
+  for (let i = 0; i < s.length; i++) {
+    const codePoint = s.codePointAt(i);
+    if (codePoint > 127) {
+      result++;
+      if (codePoint > 2047) {
+        result++;
+        if (codePoint > 65535) {
+          i++;
+        }
+      }
+    }
+  }
+  return result;
+}
+var UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
+
+// ../../../node_modules/.pnpm/@rivetkit+bare-ts@0.6.2/node_modules/@rivetkit/bare-ts/dist/core/config.js
+function Config({ initialBufferLength = 1024, maxBufferLength = 1024 * 1024 * 32 }) {
+  if (DEV) {
+    assert2(isU32(initialBufferLength), TOO_LARGE_NUMBER);
+    assert2(isU32(maxBufferLength), TOO_LARGE_NUMBER);
+    assert2(initialBufferLength <= maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
+  }
   return {
-    id: readString(bc),
-    location: readWorkflowLocation(bc),
-    kind: readWorkflowEntryKind(bc)
+    initialBufferLength,
+    maxBufferLength
   };
 }
-function read3(bc) {
-  return readBool(bc) ? readU64(bc) : null;
+
+// ../rivetkit/dist/tsup/chunk-MGTSVSUC.js
+var config2 = /* @__PURE__ */ Config({});
+function readWorkflowCbor(bc) {
+  return readData(bc);
 }
-function readWorkflowEntryMetadata(bc) {
+function readWorkflowNameIndex(bc) {
+  return readU32(bc);
+}
+function readWorkflowLoopIterationMarker(bc) {
   return {
-    status: readWorkflowEntryStatus(bc),
-    error: read1(bc),
-    attempts: readU32(bc),
-    lastAttemptAt: readU64(bc),
-    createdAt: readU64(bc),
-    completedAt: read3(bc),
-    rollbackCompletedAt: read3(bc),
-    rollbackError: read1(bc)
+    loop: readWorkflowNameIndex(bc),
+    iteration: readU32(bc)
   };
 }
-function read4(bc) {
-  const len = readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readString(bc);
+function readWorkflowPathSegment(bc) {
+  const offset = bc.offset;
+  const tag = readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "WorkflowNameIndex", val: readWorkflowNameIndex(bc) };
+    case 1:
+      return {
+        tag: "WorkflowLoopIterationMarker",
+        val: readWorkflowLoopIterationMarker(bc)
+      };
+    default: {
+      bc.offset = offset;
+      throw new BareError(offset, "invalid tag");
+    }
   }
-  return result;
 }
-function read5(bc) {
+function readWorkflowLocation(bc) {
   const len = readUintSafe(bc);
   if (len === 0) {
     return [];
   }
-  const result = [readWorkflowEntry(bc)];
+  const result = [readWorkflowPathSegment(bc)];
   for (let i = 1; i < len; i++) {
-    result[i] = readWorkflowEntry(bc);
+    result[i] = readWorkflowPathSegment(bc);
   }
   return result;
 }
-function read6(bc) {
-  const len = readUintSafe(bc);
-  const result = /* @__PURE__ */ new Map();
-  for (let i = 0; i < len; i++) {
-    const offset = bc.offset;
-    const key = readString(bc);
-    if (result.has(key)) {
+function readWorkflowEntryStatus(bc) {
+  const offset = bc.offset;
+  const tag = readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING";
+    case 1:
+      return "RUNNING";
+    case 2:
+      return "COMPLETED";
+    case 3:
+      return "FAILED";
+    case 4:
+      return "EXHAUSTED";
+    default: {
       bc.offset = offset;
-      throw new BareError(offset, "duplicated key");
+      throw new BareError(offset, "invalid tag");
     }
-    result.set(key, readWorkflowEntryMetadata(bc));
   }
-  return result;
-}
-function readWorkflowHistory(bc) {
-  return {
-    nameRegistry: read4(bc),
-    entries: read5(bc),
-    entryMetadata: read6(bc)
-  };
 }
-function decodeWorkflowHistory(bytes) {
-  const bc = new ByteCursor(bytes, config2);
-  const result = readWorkflowHistory(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new BareError(bc.offset, "remaining bytes");
+function readWorkflowSleepState(bc) {
+  const offset = bc.offset;
+  const tag = readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING";
+    case 1:
+      return "COMPLETED";
+    case 2:
+      return "INTERRUPTED";
+    default: {
+      bc.offset = offset;
+      throw new BareError(offset, "invalid tag");
+    }
   }
-  return result;
-}
-function decodeWorkflowHistoryTransport(data) {
-  return decodeWorkflowHistory(toUint8Array(data));
 }
-
-// ../rivetkit/dist/tsup/chunk-XIX5DOZN.js
-var DEFAULT_SLEEP_GRACE_PERIOD = 15e3;
-var ACTOR_CONTEXT_INTERNAL_SYMBOL = /* @__PURE__ */ Symbol(
-  "rivetkit.actor_context_internal"
-);
-var RAW_STATE_SYMBOL = /* @__PURE__ */ Symbol("rivetkit.raw_state");
-var CONN_STATE_MANAGER_SYMBOL = /* @__PURE__ */ Symbol("rivetkit.conn_state_manager");
+function readWorkflowBranchStatusType(bc) {
+  const offset = bc.offset;
+  const tag = readU8(bc);
+  switch (tag) {
+    case 0:
+      return "PENDING";
+    case 1:
+      return "RUNNING";
+    case 2:
+      return "COMPLETED";
+    case 3:
+      return "FAILED";
+    case 4:
+      return "CANCELLED";
+    default: {
+      bc.offset = offset;
+      throw new BareError(offset, "invalid tag");
+    }
+  }
+}
+function read0(bc) {
+  return readBool(bc) ? readWorkflowCbor(bc) : null;
+}
+function read1(bc) {
+  return readBool(bc) ? readString(bc) : null;
+}
+function readWorkflowStepEntry(bc) {
+  return {
+    output: read0(bc),
+    error: read1(bc)
+  };
+}
+function readWorkflowLoopEntry(bc) {
+  return {
+    state: readWorkflowCbor(bc),
+    iteration: readU32(bc),
+    output: read0(bc)
+  };
+}
+function readWorkflowSleepEntry(bc) {
+  return {
+    deadline: readU64(bc),
+    state: readWorkflowSleepState(bc)
+  };
+}
+function readWorkflowMessageEntry(bc) {
+  return {
+    name: readString(bc),
+    messageData: readWorkflowCbor(bc)
+  };
+}
+function readWorkflowRollbackCheckpointEntry(bc) {
+  return {
+    name: readString(bc)
+  };
+}
+function readWorkflowBranchStatus(bc) {
+  return {
+    status: readWorkflowBranchStatusType(bc),
+    output: read0(bc),
+    error: read1(bc)
+  };
+}
+function read2(bc) {
+  const len = readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new BareError(offset, "duplicated key");
+    }
+    result.set(key, readWorkflowBranchStatus(bc));
+  }
+  return result;
+}
+function readWorkflowJoinEntry(bc) {
+  return {
+    branches: read2(bc)
+  };
+}
+function readWorkflowRaceEntry(bc) {
+  return {
+    winner: read1(bc),
+    branches: read2(bc)
+  };
+}
+function readWorkflowRemovedEntry(bc) {
+  return {
+    originalType: readString(bc),
+    originalName: read1(bc)
+  };
+}
+function readWorkflowVersionCheckEntry(bc) {
+  return {
+    resolved: readU32(bc),
+    latest: readU32(bc)
+  };
+}
+function readWorkflowEntryKind(bc) {
+  const offset = bc.offset;
+  const tag = readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "WorkflowStepEntry", val: readWorkflowStepEntry(bc) };
+    case 1:
+      return { tag: "WorkflowLoopEntry", val: readWorkflowLoopEntry(bc) };
+    case 2:
+      return {
+        tag: "WorkflowSleepEntry",
+        val: readWorkflowSleepEntry(bc)
+      };
+    case 3:
+      return {
+        tag: "WorkflowMessageEntry",
+        val: readWorkflowMessageEntry(bc)
+      };
+    case 4:
+      return {
+        tag: "WorkflowRollbackCheckpointEntry",
+        val: readWorkflowRollbackCheckpointEntry(bc)
+      };
+    case 5:
+      return { tag: "WorkflowJoinEntry", val: readWorkflowJoinEntry(bc) };
+    case 6:
+      return { tag: "WorkflowRaceEntry", val: readWorkflowRaceEntry(bc) };
+    case 7:
+      return {
+        tag: "WorkflowRemovedEntry",
+        val: readWorkflowRemovedEntry(bc)
+      };
+    case 8:
+      return {
+        tag: "WorkflowVersionCheckEntry",
+        val: readWorkflowVersionCheckEntry(bc)
+      };
+    default: {
+      bc.offset = offset;
+      throw new BareError(offset, "invalid tag");
+    }
+  }
+}
+function readWorkflowEntry(bc) {
+  return {
+    id: readString(bc),
+    location: readWorkflowLocation(bc),
+    kind: readWorkflowEntryKind(bc)
+  };
+}
+function read3(bc) {
+  return readBool(bc) ? readU64(bc) : null;
+}
+function readWorkflowEntryMetadata(bc) {
+  return {
+    status: readWorkflowEntryStatus(bc),
+    error: read1(bc),
+    attempts: readU32(bc),
+    lastAttemptAt: readU64(bc),
+    createdAt: readU64(bc),
+    completedAt: read3(bc),
+    rollbackCompletedAt: read3(bc),
+    rollbackError: read1(bc)
+  };
+}
+function read4(bc) {
+  const len = readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readString(bc);
+  }
+  return result;
+}
+function read5(bc) {
+  const len = readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readWorkflowEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readWorkflowEntry(bc);
+  }
+  return result;
+}
+function read6(bc) {
+  const len = readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new BareError(offset, "duplicated key");
+    }
+    result.set(key, readWorkflowEntryMetadata(bc));
+  }
+  return result;
+}
+function readWorkflowHistory(bc) {
+  return {
+    nameRegistry: read4(bc),
+    entries: read5(bc),
+    entryMetadata: read6(bc)
+  };
+}
+function decodeWorkflowHistory(bytes) {
+  const bc = new ByteCursor(bytes, config2);
+  const result = readWorkflowHistory(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function decodeWorkflowHistoryTransport(data) {
+  return decodeWorkflowHistory(toUint8Array(data));
+}
+
+// ../rivetkit/dist/tsup/chunk-SHBE77IT.js
+var DEFAULT_SLEEP_GRACE_PERIOD = 15e3;
+var ACTOR_CONTEXT_INTERNAL_SYMBOL = /* @__PURE__ */ Symbol(
+  "rivetkit.actor_context_internal"
+);
+var RAW_STATE_SYMBOL = /* @__PURE__ */ Symbol("rivetkit.raw_state");
+var CONN_STATE_MANAGER_SYMBOL = /* @__PURE__ */ Symbol("rivetkit.conn_state_manager");
 var zFunction = () => external_exports.custom((val) => typeof val === "function");
 var WorkflowInspectorConfigSchema = external_exports.object({
   getHistory: zFunction(),
@@ -14583,6 +14945,7 @@ var BUILTIN_INSPECTOR_TAB_IDS = [
   "database",
   "state",
   "queue",
+  "schedules",
   "connections",
   "console"
 ];
@@ -14679,6 +15042,8 @@ var GlobalActorOptionsBaseSchema = external_exports.object({
   name: external_exports.string().optional(),
   /** Icon for the actor in the Inspector UI. Can be an emoji or FontAwesome icon name. */
   icon: external_exports.string().optional(),
+  /** Enables the experimental Actor Runtime Socket for this actor. */
+  enableActorRuntimeSocket: external_exports.boolean().default(false),
   /**
    * Can hibernate WebSockets for onWebSocket.
    *
@@ -14710,10 +15075,12 @@ var InstanceActorOptionsBaseSchema = external_exports.object({
   noSleep: external_exports.boolean().default(false),
   sleepTimeout: external_exports.number().positive().default(3e4),
   maxQueueSize: external_exports.number().positive().default(1e3),
+  /** Maximum pending one-shot and recurring schedules. */
+  maxSchedules: external_exports.number().int().nonnegative().default(1e3),
   maxQueueMessageSize: external_exports.number().positive().default(64 * 1024),
-  /** Override RivetKit's workflow preload budget for this actor. Set to 0 to disable workflow preloading. */
+  /** @deprecated Internal storage moved to SQLite and no longer uses KV preloading, so this option is ignored. Will be removed in 2.2.0. */
   preloadMaxWorkflowBytes: external_exports.number().nonnegative().optional(),
-  /** Override RivetKit's connections preload budget for this actor. Set to 0 to disable connections preloading. */
+  /** @deprecated Internal storage moved to SQLite and no longer uses KV preloading, so this option is ignored. Will be removed in 2.2.0. */
   preloadMaxConnectionsBytes: external_exports.number().nonnegative().optional()
 }).strict();
 var InstanceActorOptionsSchema = InstanceActorOptionsBaseSchema.prefault(() => ({}));
@@ -14772,6 +15139,9 @@ var DocActorOptionsSchema = external_exports.object({
   icon: external_exports.string().optional().describe(
     "Icon for the actor in the Inspector UI. Can be an emoji (e.g., '\u{1F680}') or FontAwesome icon name (e.g., 'rocket')."
   ),
+  enableActorRuntimeSocket: external_exports.boolean().optional().describe(
+    "Enables the experimental Actor Runtime Socket for this actor. Default: false"
+  ),
   createVarsTimeout: external_exports.number().optional().describe("Timeout in ms for createVars handler. Default: 5000"),
   createConnStateTimeout: external_exports.number().optional().describe(
     "Timeout in ms for createConnState handler. Default: 5000"
@@ -14809,17 +15179,14 @@ var DocActorOptionsSchema = external_exports.object({
   maxQueueSize: external_exports.number().optional().describe(
     "Maximum number of queue messages before rejecting new messages. Default: 1000"
   ),
+  maxSchedules: external_exports.number().int().nonnegative().optional().describe(
+    "Maximum pending one-shot and recurring schedules before rejecting new schedules. Default: 1000"
+  ),
   maxQueueMessageSize: external_exports.number().optional().describe(
     "Maximum size of each queue message in bytes. Default: 65536"
   ),
   canHibernateWebSocket: external_exports.boolean().optional().describe(
     "Whether WebSockets using onWebSocket can be hibernated. WebSockets using actions/events are hibernatable by default. Default: false"
-  ),
-  preloadMaxWorkflowBytes: external_exports.number().optional().describe(
-    "Override RivetKit's workflow preload budget for this actor. Set to 0 to disable workflow preloading."
-  ),
-  preloadMaxConnectionsBytes: external_exports.number().optional().describe(
-    "Override RivetKit's connections preload budget for this actor. Set to 0 to disable connections preloading."
   )
 }).describe("Actor options for timeouts and behavior configuration.");
 var DocActorConfigSchema = external_exports.object({
@@ -14891,7 +15258,7 @@ var DocActorConfigSchema = external_exports.object({
   options: DocActorOptionsSchema.optional()
 }).describe("Actor configuration passed to the actor() function.");
 
-// ../rivetkit/dist/tsup/chunk-HXUEHHJF.js
+// ../rivetkit/dist/tsup/chunk-JI6GZ2C2.js
 var EMPTY_KEY = "/";
 var KEY_SEPARATOR = "/";
 var KEYS = {
@@ -14934,450 +15301,109 @@ var QUEUE_METADATA_KEY = concatPrefix(
 );
 var QUEUE_MESSAGES_PREFIX = concatPrefix(
   QUEUE_STORAGE_PREFIX,
-  QUEUE_NAMESPACE.MESSAGES
-);
-var WORKFLOW_STORAGE_PREFIX = concatPrefix(
-  KEYS.WORKFLOW_PREFIX,
-  STORAGE_VERSION_BYTES.WORKFLOW
-);
-var TRACES_STORAGE_PREFIX = concatPrefix(
-  KEYS.TRACES_PREFIX,
-  STORAGE_VERSION_BYTES.TRACES
-);
-function serializeActorKey(key) {
-  if (key.length === 0) {
-    return EMPTY_KEY;
-  }
-  const escapedParts = key.map((part) => {
-    if (part === "") {
-      return "\\0";
-    }
-    let escaped = part.replace(/\\/g, "\\\\");
-    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
-    return escaped;
-  });
-  return escapedParts.join(KEY_SEPARATOR);
-}
-function deserializeActorKey(keyString) {
-  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
-    return [];
-  }
-  const parts = [];
-  let currentPart = "";
-  let escaping = false;
-  let isEmptyStringMarker = false;
-  for (let i = 0; i < keyString.length; i++) {
-    const char = keyString[i];
-    if (escaping) {
-      if (char === "0") {
-        isEmptyStringMarker = true;
-      } else {
-        currentPart += char;
-      }
-      escaping = false;
-    } else if (char === "\\") {
-      escaping = true;
-    } else if (char === KEY_SEPARATOR) {
-      if (isEmptyStringMarker) {
-        parts.push("");
-        isEmptyStringMarker = false;
-      } else {
-        parts.push(currentPart);
-      }
-      currentPart = "";
-    } else {
-      currentPart += char;
-    }
-  }
-  if (escaping) {
-    parts.push(`${currentPart}\\`);
-  } else if (isEmptyStringMarker) {
-    parts.push("");
-  } else if (currentPart !== "" || parts.length > 0) {
-    parts.push(currentPart);
-  }
-  return parts;
-}
-function makePrefixedKey(key) {
-  const prefixed = new Uint8Array(KEYS.KV.length + key.length);
-  prefixed.set(KEYS.KV, 0);
-  prefixed.set(key, KEYS.KV.length);
-  return prefixed;
-}
-function removePrefixFromKey(prefixedKey) {
-  return prefixedKey.slice(KEYS.KV.length);
-}
-function workflowStoragePrefix() {
-  return Uint8Array.from(WORKFLOW_STORAGE_PREFIX);
-}
-function queueMetadataKey() {
-  return Uint8Array.from(QUEUE_METADATA_KEY);
-}
-function queueMessagesPrefix() {
-  return Uint8Array.from(QUEUE_MESSAGES_PREFIX);
-}
-
-// ../rivetkit/dist/tsup/chunk-W6WPKZ6I.js
-var cbor = __toESM(require("cbor-x"), 1);
-var import_invariant = __toESM(require_invariant(), 1);
-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;
-}
-function assertJsonCompatValue(value, path2 = "") {
-  var _a2;
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return;
-  }
-  if (typeof value === "function") {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a function and is not CBOR serializable`
-    );
-  }
-  if (typeof value === "symbol") {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a symbol and is not CBOR serializable`
-    );
-  }
-  if (value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof ArrayBuffer || value instanceof Uint8Array || isTypedArray(value)) {
-    return;
-  }
-  if (value instanceof WeakMap) {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a WeakMap and is not CBOR serializable`
-    );
-  }
-  if (value instanceof WeakSet) {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a WeakSet and is not CBOR serializable`
-    );
-  }
-  if (value instanceof WeakRef) {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a WeakRef and is not CBOR serializable`
-    );
-  }
-  if (value instanceof Promise) {
-    throw new TypeError(
-      `Value at ${path2 || "root"} is a Promise and is not CBOR serializable`
-    );
-  }
-  if (value instanceof Map) {
-    for (const [k, v] of value.entries()) {
-      assertJsonCompatValue(k, `${path2 || "root"}.key(${String(k)})`);
-      assertJsonCompatValue(v, `${path2 || "root"}.value(${String(k)})`);
-    }
-    return;
-  }
-  if (value instanceof Set) {
-    let index = 0;
-    for (const item of value.values()) {
-      assertJsonCompatValue(item, `${path2 || "root"}.set[${index}]`);
-      index++;
-    }
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      assertJsonCompatValue(value[i], `${path2 || "root"}[${i}]`);
-    }
-    return;
-  }
-  if (isPlainObject2(value)) {
-    for (const key in value) {
-      assertJsonCompatValue(
-        value[key],
-        path2 ? `${path2}.${key}` : key
-      );
-    }
-    return;
-  }
-  const typeName = typeof value === "object" && value !== null ? ((_a2 = value.constructor) == null ? void 0 : _a2.name) ?? typeof value : typeof value;
-  throw new TypeError(
-    `Value at ${path2 || "root"} of type "${typeName}" is not CBOR serializable`
-  );
-}
-var EncodingSchema = external_exports.enum(["json", "cbor", "bare"]);
-async function inputDataToBuffer(data) {
-  if (typeof data === "string") {
-    return data;
-  }
-  if (data instanceof Blob) {
-    return new Uint8Array(await data.arrayBuffer());
-  }
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
-    return new Uint8Array(data);
-  }
-  throw new Error("Malformed message");
-}
-function base64EncodeUint8Array(uint8Array) {
-  let binary = "";
-  for (const value of uint8Array) {
-    binary += String.fromCharCode(value);
-  }
-  return btoa(binary);
-}
-function base64EncodeArrayBuffer(arrayBuffer) {
-  return base64EncodeUint8Array(new Uint8Array(arrayBuffer));
-}
-function isPlainObject2(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function encodeJsonCompatValue(input) {
-  var _a2;
-  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()];
-  }
-  if (input instanceof ArrayBuffer) {
-    return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(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)
-    );
-    if (encoded.length === 2 && typeof encoded[0] === "string" && encoded[0].startsWith("$")) {
-      return [`$${encoded[0]}`, encoded[1]];
-    }
-    return encoded;
-  }
-  if (isPlainObject2(input)) {
-    const encoded = {};
-    for (const [key, value] of Object.entries(input)) {
-      encoded[key] = encodeJsonCompatValue(value);
-    }
-    return encoded;
-  }
-  const typeName = typeof input === "object" && input !== null ? ((_a2 = input.constructor) == null ? void 0 : _a2.name) ?? typeof input : typeof input;
-  throw new TypeError(`Value of type "${typeName}" is not CBOR serializable`);
-}
-function reviveJsonCompatValue(input, options = {}) {
-  if (typeof input === "bigint") {
-    if (options.coerceSafeIntegerBigInts && input >= BigInt(Number.MIN_SAFE_INTEGER) && input <= BigInt(Number.MAX_SAFE_INTEGER)) {
-      return Number(input);
-    }
-    return input;
+  QUEUE_NAMESPACE.MESSAGES
+);
+var WORKFLOW_STORAGE_PREFIX = concatPrefix(
+  KEYS.WORKFLOW_PREFIX,
+  STORAGE_VERSION_BYTES.WORKFLOW
+);
+var TRACES_STORAGE_PREFIX = concatPrefix(
+  KEYS.TRACES_PREFIX,
+  STORAGE_VERSION_BYTES.TRACES
+);
+function serializeActorKey(key) {
+  if (key.length === 0) {
+    return EMPTY_KEY;
   }
-  if (input instanceof Map) {
-    const revived = /* @__PURE__ */ new Map();
-    for (const [k, v] of input.entries()) {
-      revived.set(
-        reviveJsonCompatValue(k, options),
-        reviveJsonCompatValue(v, options)
-      );
+  const escapedParts = key.map((part) => {
+    if (part === "") {
+      return "\\0";
     }
-    return revived;
+    let escaped = part.replace(/\\/g, "\\\\");
+    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
+    return escaped;
+  });
+  return escapedParts.join(KEY_SEPARATOR);
+}
+function deserializeActorKey(keyString) {
+  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
+    return [];
   }
-  if (Array.isArray(input)) {
-    if (input.length === 2 && typeof input[0] === "string" && input[0].startsWith("$")) {
-      if (input[0] === JSON_COMPAT_BIGINT) {
-        return BigInt(input[1]);
-      }
-      if (input[0] === JSON_COMPAT_ARRAY_BUFFER) {
-        return base64DecodeToArrayBuffer(input[1]);
-      }
-      if (input[0] === JSON_COMPAT_UINT8_ARRAY) {
-        return base64DecodeToUint8Array(input[1]);
-      }
-      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);
+  const parts = [];
+  let currentPart = "";
+  let escaping = false;
+  let isEmptyStringMarker = false;
+  for (let i = 0; i < keyString.length; i++) {
+    const char = keyString[i];
+    if (escaping) {
+      if (char === "0") {
+        isEmptyStringMarker = true;
+      } else {
+        currentPart += char;
       }
-      if (input[0].startsWith("$$")) {
-        return [
-          input[0].substring(1),
-          reviveJsonCompatValue(input[1], options)
-        ];
+      escaping = false;
+    } else if (char === "\\") {
+      escaping = true;
+    } else if (char === KEY_SEPARATOR) {
+      if (isEmptyStringMarker) {
+        parts.push("");
+        isEmptyStringMarker = false;
+      } else {
+        parts.push(currentPart);
       }
-      throw new Error(
-        `Unknown JSON encoding type: ${input[0]}. This may indicate corrupted data or a version mismatch.`
-      );
+      currentPart = "";
+    } else {
+      currentPart += char;
     }
-    return input.map((value) => reviveJsonCompatValue(value, options));
   }
-  if (isPlainObject2(input)) {
-    const decoded = {};
-    for (const [key, value] of Object.entries(input)) {
-      decoded[key] = reviveJsonCompatValue(value, options);
-    }
-    return decoded;
+  if (escaping) {
+    parts.push(`${currentPart}\\`);
+  } else if (isEmptyStringMarker) {
+    parts.push("");
+  } else if (currentPart !== "" || parts.length > 0) {
+    parts.push(currentPart);
   }
-  return input;
+  return parts;
 }
-function base64DecodeToUint8Array(base643) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(base643, "base64"));
-  }
-  const binary = atob(base643);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
+function makePrefixedKey(key) {
+  const prefixed = new Uint8Array(KEYS.KV.length + key.length);
+  prefixed.set(KEYS.KV, 0);
+  prefixed.set(key, KEYS.KV.length);
+  return prefixed;
 }
-function base64DecodeToArrayBuffer(base643) {
-  return base64DecodeToUint8Array(base643).buffer;
+function removePrefixFromKey(prefixedKey) {
+  return prefixedKey.slice(KEYS.KV.length);
 }
-function jsonStringifyCompat(input) {
-  return JSON.stringify(input, (_key, value) => {
-    if (typeof value === "bigint") {
-      return [JSON_COMPAT_BIGINT, value.toString()];
-    }
-    if (value instanceof ArrayBuffer) {
-      return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(value)];
-    }
-    if (value instanceof Uint8Array) {
-      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]];
+
+// ../rivetkit/dist/tsup/chunk-7AFZMFPQ.js
+var MIGRATION_TRANSACTION_TIMEOUT_MS = 5 * 6e4;
+var AsyncMutex = class {
+  #locked = false;
+  #waiting = [];
+  async acquire() {
+    while (this.#locked) {
+      await new Promise((resolve) => this.#waiting.push(resolve));
     }
-    return value;
-  });
-}
-function jsonParseCompat(input) {
-  return reviveJsonCompatValue(JSON.parse(input));
-}
-function uint8ArrayToBase642(uint8Array) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(uint8Array).toString("base64");
-  }
-  let binary = "";
-  const len = uint8Array.byteLength;
-  for (let i = 0; i < len; i++) {
-    binary += String.fromCharCode(uint8Array[i]);
-  }
-  return btoa(binary);
-}
-function contentTypeForEncoding(encoding) {
-  if (encoding === "json") {
-    return "application/json";
-  } else if (encoding === "cbor" || encoding === "bare") {
-    return "application/octet-stream";
-  } else {
-    assertUnreachable(encoding);
+    this.#locked = true;
   }
-}
-function encodeCborCompat(value) {
-  return cbor.encode(encodeJsonCompatValue(value));
-}
-function decodeCborCompat(buffer) {
-  return reviveJsonCompatValue(cbor.decode(buffer));
-}
-function serializeWithEncoding(encoding, value, versionedDataHandler, version2, zodSchema, toJson, toBare) {
-  if (encoding === "json") {
-    const jsonValue = toJson(value);
-    const validated = zodSchema.parse(jsonValue);
-    return jsonStringifyCompat(validated);
-  } else if (encoding === "cbor") {
-    const jsonValue = toJson(value);
-    const validated = zodSchema.parse(jsonValue);
-    return cbor.encode(validated);
-  } else if (encoding === "bare") {
-    if (!versionedDataHandler) {
-      throw new Error(
-        "VersionedDataHandler is required for 'bare' encoding"
-      );
-    }
-    if (version2 === void 0) {
-      throw new Error("version is required for 'bare' encoding");
+  release() {
+    this.#locked = false;
+    const next = this.#waiting.shift();
+    if (next) {
+      next();
     }
-    const bareValue = toBare(value);
-    return versionedDataHandler.serializeWithEmbeddedVersion(
-      bareValue,
-      version2
-    );
-  } else {
-    assertUnreachable(encoding);
   }
-}
-function deserializeWithEncoding(encoding, buffer, versionedDataHandler, zodSchema, fromJson, fromBare) {
-  if (encoding === "json") {
-    let parsed;
-    if (typeof buffer === "string") {
-      parsed = jsonParseCompat(buffer);
-    } else {
-      const decoder = new TextDecoder("utf-8");
-      const jsonString = decoder.decode(buffer);
-      parsed = jsonParseCompat(jsonString);
-    }
-    const validated = zodSchema.parse(parsed);
-    return fromJson(validated);
-  } else if (encoding === "cbor") {
-    (0, import_invariant.default)(
-      typeof buffer !== "string",
-      "buffer cannot be string for cbor encoding"
-    );
-    const decoded = decodeCborCompat(buffer);
-    const validated = zodSchema.parse(decoded);
-    return fromJson(validated);
-  } else if (encoding === "bare") {
-    (0, import_invariant.default)(
-      typeof buffer !== "string",
-      "buffer cannot be string for bare encoding"
-    );
-    if (!versionedDataHandler) {
-      throw new Error(
-        "VersionedDataHandler is required for 'bare' encoding"
-      );
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
     }
-    const bareValue = versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
-    return fromBare(bareValue);
-  } else {
-    assertUnreachable(encoding);
   }
-}
+};
 
-// ../rivetkit/dist/tsup/chunk-EOSGY3DC.js
+// ../rivetkit/dist/tsup/chunk-PAG6G46L.js
 function logger() {
   return getLogger("actor-client");
 }
@@ -15415,34 +15441,7 @@ async function importWebSocket() {
   return webSocketPromise;
 }
 
-// ../rivetkit/dist/tsup/chunk-JZ7TWV65.js
-var AsyncMutex = class {
-  #locked = false;
-  #waiting = [];
-  async acquire() {
-    while (this.#locked) {
-      await new Promise((resolve) => this.#waiting.push(resolve));
-    }
-    this.#locked = true;
-  }
-  release() {
-    this.#locked = false;
-    const next = this.#waiting.shift();
-    if (next) {
-      next();
-    }
-  }
-  async run(fn) {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-};
-
-// ../rivetkit/dist/tsup/chunk-CMPFZ724.js
+// ../rivetkit/dist/tsup/chunk-GAV4PKFT.js
 var import_invariant2 = __toESM(require_invariant(), 1);
 
 // ../../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
@@ -15620,7 +15619,7 @@ function createVersionedDataHandler(config3) {
   return new VersionedDataHandler(config3);
 }
 
-// ../rivetkit/dist/tsup/chunk-CMPFZ724.js
+// ../rivetkit/dist/tsup/chunk-GAV4PKFT.js
 var import_invariant3 = __toESM(require_invariant(), 1);
 var import_invariant4 = __toESM(require_invariant(), 1);
 var PATH_CONNECT = "/connect";
@@ -20449,13 +20448,6 @@ async function updateRunnerConfig(config3, runnerName, request) {
     request
   );
 }
-async function kvGet(config3, actorId, key) {
-  return apiCall(
-    config3,
-    "GET",
-    `/actors/${encodeURIComponent(actorId)}/kv/keys/${encodeURIComponent(key)}`
-  );
-}
 function shouldSkipReadyWait(options = {}) {
   return options.skipReadyWait === true;
 }
@@ -21221,28 +21213,6 @@ var RemoteEngineControlClient = class {
     const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
     return await upgradeWebSocket(() => args)(c, noopNext());
   }
-  async kvGet(actorId, key) {
-    await this.#metadataPromise;
-    logger2().debug({ msg: "getting kv value via engine api", key });
-    const response = await kvGet(
-      this.#config,
-      actorId,
-      new TextDecoder("utf8").decode(key)
-    );
-    return response.value;
-  }
-  async kvBatchGet(_actorId, _keys) {
-    throw new Error("kvBatchGet not supported on remote engine client");
-  }
-  async kvBatchPut(_actorId, _entries) {
-    throw new Error("kvBatchPut not supported on remote engine client");
-  }
-  async kvBatchDelete(_actorId, _keys) {
-    throw new Error("kvBatchDelete not supported on remote engine client");
-  }
-  async kvDeleteRange(_actorId, _start, _end) {
-    throw new Error("kvDeleteRange not supported on remote engine client");
-  }
   displayInformation() {
     return { properties: {} };
   }
@@ -22565,15 +22535,21 @@ var import_meta = {};
 function loggerWithoutContext() {
   return getLogger("actor-runtime");
 }
-var warnedDeprecatedTimeoutKeys = /* @__PURE__ */ new Set();
-function warnDeprecatedShutdownTimeoutKeys(options) {
+var warnedDeprecatedOptionKeys = /* @__PURE__ */ new Set();
+var DEPRECATED_OPTION_MESSAGES = {
+  onDestroyTimeout: "Configure `sleepGracePeriod` instead, which bounds the entire graceful shutdown window for both sleep and destroy.",
+  waitUntilTimeout: "Configure `sleepGracePeriod` instead, which bounds the entire graceful shutdown window for both sleep and destroy.",
+  preloadMaxWorkflowBytes: "Internal storage moved to SQLite and no longer uses KV preloading.",
+  preloadMaxConnectionsBytes: "Internal storage moved to SQLite and no longer uses KV preloading."
+};
+function warnDeprecatedOptionKeys(options) {
   if (!options || typeof options !== "object") return;
   const opts = options;
-  for (const key of ["onDestroyTimeout", "waitUntilTimeout"]) {
-    if (opts[key] !== void 0 && !warnedDeprecatedTimeoutKeys.has(key)) {
-      warnedDeprecatedTimeoutKeys.add(key);
+  for (const [key, detail] of Object.entries(DEPRECATED_OPTION_MESSAGES)) {
+    if (opts[key] !== void 0 && !warnedDeprecatedOptionKeys.has(key)) {
+      warnedDeprecatedOptionKeys.add(key);
       loggerWithoutContext().warn({
-        msg: `actor option \`${key}\` is deprecated and is now ignored. Configure \`sleepGracePeriod\` instead, which bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0.`
+        msg: `actor option \`${key}\` is deprecated and is now ignored. ${detail} Will be removed in 2.2.0.`
       });
     }
   }
@@ -22591,7 +22567,7 @@ function isStaticActorInstance(_actor) {
   return true;
 }
 function actor(input) {
-  warnDeprecatedShutdownTimeoutKeys(
+  warnDeprecatedOptionKeys(
     input == null ? void 0 : input.options
   );
   const config3 = ActorConfigSchema.parse(input);
@@ -23296,31 +23272,6 @@ function buildActorNames(config3) {
       const metadata = {};
       metadata.icon = options.icon ?? runMeta.icon;
       metadata.name = options.name ?? runMeta.name;
-      metadata.preload = {
-        keys: [
-          Array.from(KEYS.PERSIST_DATA),
-          Array.from(KEYS.INSPECTOR_TOKEN),
-          Array.from(queueMetadataKey()),
-          Array.from(KEYS.LAST_PUSHED_ALARM)
-        ],
-        prefixes: [
-          {
-            prefix: Array.from(workflowStoragePrefix()),
-            maxBytes: options.preloadMaxWorkflowBytes ?? 131072,
-            partial: false
-          },
-          {
-            prefix: Array.from(KEYS.CONN_PREFIX),
-            maxBytes: options.preloadMaxConnectionsBytes ?? 65536,
-            partial: false
-          },
-          {
-            prefix: Array.from(queueMessagesPrefix()),
-            maxBytes: 65536,
-            partial: false
-          }
-        ]
-      };
       if (!metadata.icon) delete metadata.icon;
       if (!metadata.name) delete metadata.name;
       return [actorName, { metadata }];
@@ -23508,6 +23459,12 @@ function toNativeBindings(sql, params) {
     return toNativeBinding(value);
   });
 }
+function toNativeBatchStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: toNativeBindings(statement.sql, statement.params)
+  };
+}
 function normalizeNativeMetrics(metrics) {
   if (!metrics) return null;
   const raw = metrics;
@@ -23621,6 +23578,60 @@ function wrapJsNativeDatabase(database) {
     async execute(sql, params) {
       return await executeNative(sql, params);
     },
+    async executeBatch(statements) {
+      const nativeStatements = statements.map(toNativeBatchStatement);
+      const release = gate.enter();
+      let transaction;
+      try {
+        const results = database.executeBatch ? await database.executeBatch(nativeStatements) : await (async () => {
+          transaction = await database.beginTransaction();
+          const transactionResults = [];
+          for (const statement of nativeStatements) {
+            transactionResults.push(
+              await transaction.execute(
+                statement.sql,
+                statement.params
+              )
+            );
+          }
+          await transaction.commit();
+          transaction = void 0;
+          return transactionResults;
+        })();
+        for (const result of results) {
+          if (result.lastInsertRowId !== void 0) {
+            lastInsertRowId = result.lastInsertRowId;
+          }
+        }
+        return results;
+      } catch (error46) {
+        if (transaction) {
+          try {
+            await transaction.rollback();
+          } catch {
+          }
+        }
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+    },
+    async beginTransaction(timeoutMs) {
+      const release = gate.enter();
+      let transaction;
+      try {
+        transaction = await database.beginTransaction(timeoutMs);
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+      return wrapTransaction(database, transaction, gate, (result) => {
+        if (result.lastInsertRowId !== void 0) {
+          lastInsertRowId = result.lastInsertRowId;
+        }
+      });
+    },
     async run(sql, params) {
       await executeNative(sql, params);
     },
@@ -23638,6 +23649,59 @@ function wrapJsNativeDatabase(database) {
     }
   };
 }
+function wrapTransaction(database, transaction, gate, onExecute) {
+  return {
+    async exec(sql, callback) {
+      const release = gate.enter();
+      let result;
+      try {
+        result = await transaction.exec(sql);
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+      if (callback) {
+        for (const row of result.rows) callback(row, result.columns);
+      }
+    },
+    async execute(sql, params) {
+      const release = gate.enter();
+      try {
+        const result = await transaction.execute(
+          sql,
+          toNativeBindings(sql, params)
+        );
+        onExecute(result);
+        return result;
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+    },
+    async commit() {
+      const release = gate.enter();
+      try {
+        await transaction.commit();
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+    },
+    async rollback() {
+      const release = gate.enter();
+      try {
+        await transaction.rollback();
+      } catch (error46) {
+        enrichNativeDatabaseError(database, error46);
+      } finally {
+        release();
+      }
+    }
+  };
+}
 function lastInsertRowIdColumnName(sql) {
   const match = sql.match(
     /^\s*SELECT\s+last_insert_rowid\s*\(\s*\)\s*(?:AS\s+("[^"]+"|`[^`]+`|\[[^\]]+\]|\w+))?\s*;?\s*$/i
@@ -23745,6 +23809,9 @@ function asNativeConn(handle) {
 function asNativeWebSocket(handle) {
   return handle;
 }
+function asNativeSqlTransaction(handle) {
+  return handle;
+}
 function asNativeCancellationToken(handle) {
   return handle;
 }
@@ -23774,6 +23841,12 @@ function toNapiSqlBindParams(params) {
   }
   return params.map((param) => toNapiSqlBindParam(param));
 }
+function toNapiSqlBatchStatement(statement) {
+  return {
+    sql: statement.sql,
+    params: toNapiSqlBindParams(statement.params) ?? void 0
+  };
+}
 function toNapiBuffer(value) {
   return Buffer.from(value);
 }
@@ -23897,11 +23970,16 @@ var NapiCoreRuntime = class {
   createCancellationToken() {
     return new this.#bindings.CancellationToken();
   }
-  createTestActorContext(actorId, name, region) {
-    return new this.#bindings.ActorContext(
-      actorId,
-      name,
-      region
+  decodeInspectorRequest(bytes, advertisedVersion) {
+    return this.#bindings.decodeInspectorRequest(
+      toNapiBuffer(bytes),
+      advertisedVersion
+    );
+  }
+  encodeInspectorResponse(bytes, targetVersion) {
+    return this.#bindings.encodeInspectorResponse(
+      toNapiBuffer(bytes),
+      targetVersion
     );
   }
   cancellationTokenAborted(token) {
@@ -23965,6 +24043,14 @@ var NapiCoreRuntime = class {
       toNapiStateDeltaPayload(payload)
     );
   }
+  async actorSaveStateAndWorkflowBatch(ctx, writes) {
+    await asNativeActorContext(ctx).saveStateAndWorkflowBatch(
+      writes.map((write) => ({
+        key: toNapiBuffer(write.key),
+        value: toNapiBuffer(write.value)
+      }))
+    );
+  }
   actorId(ctx) {
     return asNativeActorContext(ctx).actorId();
   }
@@ -24071,6 +24157,33 @@ var NapiCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  async actorSqlExecuteBatch(ctx, statements) {
+    const results = await this.#actorSql(ctx).executeBatch(
+      statements.map(toNapiSqlBatchStatement)
+    );
+    return results.map(normalizeRuntimeSqlExecuteResult);
+  }
+  async actorSqlBeginTransaction(ctx, timeoutMs) {
+    return await this.#actorSql(ctx).beginTransaction(
+      timeoutMs
+    );
+  }
+  async actorSqlTransactionExec(transaction, sql) {
+    return await asNativeSqlTransaction(transaction).exec(sql);
+  }
+  async actorSqlTransactionExecute(transaction, sql, params) {
+    const result = await asNativeSqlTransaction(transaction).execute(
+      sql,
+      toNapiSqlBindParams(params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
+  async actorSqlTransactionCommit(transaction) {
+    await asNativeSqlTransaction(transaction).commit();
+  }
+  async actorSqlTransactionRollback(transaction) {
+    await asNativeSqlTransaction(transaction).rollback();
+  }
   async actorSqlQuery(ctx, sql, params) {
     return await this.#actorSql(ctx).query(
       sql,
@@ -24097,6 +24210,9 @@ var NapiCoreRuntime = class {
     this.#sql.delete(nativeCtx);
     await database.close();
   }
+  async actorRuntimeSocketProvision(ctx) {
+    return await asNativeActorContext(ctx).provisionActorRuntimeSocket();
+  }
   async actorQueueSend(ctx, name, body) {
     return toNapiQueueMessage(
       await asNativeActorContext(ctx).queue().send(name, toNapiBuffer(body))
@@ -24145,11 +24261,51 @@ var NapiCoreRuntime = class {
   async actorQueueReset(ctx) {
     await asNativeActorContext(ctx).queue().reset();
   }
-  actorScheduleAfter(ctx, durationMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().after(durationMs, actionName, toNapiBuffer(args));
+  async actorScheduleAfter(ctx, durationMs, actionName, args) {
+    return await asNativeActorContext(ctx).schedule().after(durationMs, actionName, toNapiBuffer(args));
+  }
+  async actorScheduleAt(ctx, timestampMs, actionName, args) {
+    return await asNativeActorContext(ctx).schedule().at(timestampMs, actionName, toNapiBuffer(args));
+  }
+  async actorScheduleCancel(ctx, id) {
+    return await asNativeActorContext(ctx).schedule().cancel(id);
+  }
+  async actorScheduleGet(ctx, id) {
+    return await asNativeActorContext(ctx).schedule().get(id) ?? void 0;
+  }
+  async actorScheduleList(ctx) {
+    return await asNativeActorContext(ctx).schedule().list();
+  }
+  async actorCronSet(ctx, name, expression, timezone, actionName, args, maxHistory) {
+    await asNativeActorContext(ctx).schedule().cronSet(
+      name,
+      expression,
+      timezone,
+      actionName,
+      toNapiBuffer(args),
+      maxHistory
+    );
+  }
+  async actorCronEvery(ctx, name, intervalMs, actionName, args, maxHistory) {
+    await asNativeActorContext(ctx).schedule().cronEvery(
+      name,
+      intervalMs,
+      actionName,
+      toNapiBuffer(args),
+      maxHistory
+    );
+  }
+  async actorCronGet(ctx, name) {
+    return await asNativeActorContext(ctx).schedule().cronGet(name) ?? void 0;
   }
-  actorScheduleAt(ctx, timestampMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().at(timestampMs, actionName, toNapiBuffer(args));
+  async actorCronList(ctx) {
+    return await asNativeActorContext(ctx).schedule().cronList();
+  }
+  async actorCronDelete(ctx, name) {
+    return await asNativeActorContext(ctx).schedule().cronDelete(name);
+  }
+  async actorCronHistory(ctx, name, limit) {
+    return await asNativeActorContext(ctx).schedule().cronHistory(name, limit);
   }
   connId(conn) {
     return asNativeConn(conn).id();
@@ -24552,6 +24708,13 @@ var WasmCoreRuntime = class {
   async actorSaveState(ctx, payload) {
     await callHandleAsync(asWasmActorContext(ctx), "saveState", payload);
   }
+  async actorSaveStateAndWorkflowBatch(ctx, writes) {
+    await callHandleAsync(
+      asWasmActorContext(ctx),
+      "saveStateAndWorkflowBatch",
+      writes
+    );
+  }
   actorId(ctx) {
     return callHandle(asWasmActorContext(ctx), "actorId");
   }
@@ -24698,6 +24861,38 @@ var WasmCoreRuntime = class {
     );
     return normalizeRuntimeSqlExecuteResult(result);
   }
+  async actorSqlExecuteBatch(ctx, statements) {
+    const results = await callWasm(
+      () => this.#actorSql(ctx).executeBatch(statements)
+    );
+    return results.map(normalizeRuntimeSqlExecuteResult);
+  }
+  async actorSqlBeginTransaction(ctx, timeoutMs) {
+    return await callWasm(
+      () => this.#actorSql(ctx).beginTransaction(timeoutMs)
+    );
+  }
+  async actorSqlTransactionExec(transaction, sql) {
+    return await callWasm(
+      () => transaction.exec(sql)
+    );
+  }
+  async actorSqlTransactionExecute(transaction, sql, params) {
+    const result = await callWasm(
+      () => transaction.execute(sql, params)
+    );
+    return normalizeRuntimeSqlExecuteResult(result);
+  }
+  async actorSqlTransactionCommit(transaction) {
+    await callWasm(
+      () => transaction.commit()
+    );
+  }
+  async actorSqlTransactionRollback(transaction) {
+    await callWasm(
+      () => transaction.rollback()
+    );
+  }
   async actorSqlQuery(ctx, sql, params) {
     return await callWasm(() => this.#actorSql(ctx).query(sql, params));
   }
@@ -24721,6 +24916,17 @@ var WasmCoreRuntime = class {
     this.#sql.delete(wasmCtx);
     await callWasm(() => database.close());
   }
+  async actorRuntimeSocketProvision(_ctx) {
+    throw new RivetError(
+      "actor_runtime_socket",
+      "unsupported",
+      "Actor Runtime Socket is only available on Unix native runtimes.",
+      {
+        public: true,
+        metadata: { runtime: "wasm" }
+      }
+    );
+  }
   async actorQueueSend(ctx, name, body) {
     const queue2 = childHandle(asWasmActorContext(ctx), "queue");
     return normalizeQueueMessage(
@@ -24792,13 +24998,97 @@ var WasmCoreRuntime = class {
     const queue2 = childHandle(asWasmActorContext(ctx), "queue");
     await callHandleAsync(queue2, "reset");
   }
-  actorScheduleAfter(ctx, durationMs, actionName, args) {
+  async actorScheduleAfter(ctx, durationMs, actionName, args) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "after",
+      wasmNumber(durationMs),
+      actionName,
+      args
+    );
+  }
+  async actorScheduleAt(ctx, timestampMs, actionName, args) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "at",
+      wasmNumber(timestampMs),
+      actionName,
+      args
+    );
+  }
+  async actorScheduleCancel(ctx, id) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(schedule, "cancel", id);
+  }
+  async actorScheduleGet(ctx, id) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "get",
+      id
+    );
+  }
+  async actorScheduleList(ctx) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "list"
+    );
+  }
+  async actorCronSet(ctx, name, expression, timezone, actionName, args, maxHistory) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    await callHandleAsync(
+      schedule,
+      "cronSet",
+      name,
+      expression,
+      timezone,
+      actionName,
+      args,
+      maxHistory
+    );
+  }
+  async actorCronEvery(ctx, name, intervalMs, actionName, args, maxHistory) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    await callHandleAsync(
+      schedule,
+      "cronEvery",
+      name,
+      intervalMs,
+      actionName,
+      args,
+      maxHistory
+    );
+  }
+  async actorCronGet(ctx, name) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(
+      schedule,
+      "cronGet",
+      name
+    );
+  }
+  async actorCronList(ctx) {
     const schedule = childHandle(asWasmActorContext(ctx), "schedule");
-    callHandle(schedule, "after", wasmNumber(durationMs), actionName, args);
+    return await callHandleAsync(
+      schedule,
+      "cronList"
+    );
+  }
+  async actorCronDelete(ctx, name) {
+    const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+    return await callHandleAsync(schedule, "cronDelete", name);
   }
-  actorScheduleAt(ctx, timestampMs, actionName, args) {
+  async actorCronHistory(ctx, name, limit) {
     const schedule = childHandle(asWasmActorContext(ctx), "schedule");
-    callHandle(schedule, "at", wasmNumber(timestampMs), actionName, args);
+    return await callHandleAsync(
+      schedule,
+      "cronHistory",
+      name,
+      limit
+    );
   }
   connId(conn) {
     return callHandle(asWasmConn(conn), "id");
@@ -25133,6 +25423,23 @@ function getOrCreateNativeSqlDatabase(runtime, ctx) {
   const database = wrapJsNativeDatabase({
     exec: (sql) => runtime.actorSqlExec(ctx, sql),
     execute: (sql, params) => runtime.actorSqlExecute(ctx, sql, params),
+    executeBatch: (statements) => runtime.actorSqlExecuteBatch(ctx, statements),
+    beginTransaction: async (timeoutMs) => {
+      const transaction = await runtime.actorSqlBeginTransaction(
+        ctx,
+        timeoutMs
+      );
+      return {
+        exec: (sql) => runtime.actorSqlTransactionExec(transaction, sql),
+        execute: (sql, params) => runtime.actorSqlTransactionExecute(
+          transaction,
+          sql,
+          params
+        ),
+        commit: () => runtime.actorSqlTransactionCommit(transaction),
+        rollback: () => runtime.actorSqlTransactionRollback(transaction)
+      };
+    },
     query: (sql, params) => runtime.actorSqlQuery(ctx, sql, params),
     run: (sql, params) => runtime.actorSqlRun(ctx, sql, params),
     metrics: () => runtime.actorSqlMetrics(ctx),
@@ -25626,26 +25933,116 @@ var NativeScheduleAdapter = class {
     this.#ctx = ctx;
   }
   async after(duration3, action, ...args) {
-    callNativeSync(
-      () => this.#runtime.actorScheduleAfter(
-        this.#ctx,
-        duration3,
-        action,
-        encodeValue(args)
-      )
+    return await this.#runtime.actorScheduleAfter(
+      this.#ctx,
+      duration3,
+      action,
+      encodeValue(args)
     );
   }
   async at(timestamp, action, ...args) {
-    callNativeSync(
-      () => this.#runtime.actorScheduleAt(
-        this.#ctx,
-        timestamp,
-        action,
-        encodeValue(args)
-      )
+    return await this.#runtime.actorScheduleAt(
+      this.#ctx,
+      timestamp,
+      action,
+      encodeValue(args)
+    );
+  }
+  async cancel(id) {
+    return await this.#runtime.actorScheduleCancel(this.#ctx, id);
+  }
+  async get(id) {
+    const event2 = await this.#runtime.actorScheduleGet(this.#ctx, id);
+    return event2 ? decodeScheduledEventInfo(event2) : void 0;
+  }
+  async list() {
+    return (await this.#runtime.actorScheduleList(this.#ctx)).map(
+      decodeScheduledEventInfo
+    );
+  }
+};
+var NativeCronAdapter = class {
+  #runtime;
+  #ctx;
+  constructor(runtime, ctx) {
+    this.#runtime = runtime;
+    this.#ctx = ctx;
+  }
+  async set(options) {
+    await this.#runtime.actorCronSet(
+      this.#ctx,
+      options.name,
+      options.expression,
+      options.timezone,
+      options.action,
+      encodeValue(options.args ?? []),
+      options.maxHistory
+    );
+  }
+  async every(options) {
+    await this.#runtime.actorCronEvery(
+      this.#ctx,
+      options.name,
+      options.interval,
+      options.action,
+      encodeValue(options.args ?? []),
+      options.maxHistory
+    );
+  }
+  async get(name) {
+    const job = await this.#runtime.actorCronGet(this.#ctx, name);
+    return job ? decodeCronJobInfo(job) : void 0;
+  }
+  async list() {
+    return (await this.#runtime.actorCronList(this.#ctx)).map(
+      decodeCronJobInfo
     );
   }
+  async delete(name) {
+    return await this.#runtime.actorCronDelete(this.#ctx, name);
+  }
+  async history(name, options) {
+    return (await this.#runtime.actorCronHistory(
+      this.#ctx,
+      name,
+      options == null ? void 0 : options.limit
+    )).map(decodeCronFire);
+  }
 };
+function decodeScheduledEventInfo(event2) {
+  return {
+    id: event2.id,
+    action: event2.action,
+    args: decodeArgs(event2.args),
+    runAt: event2.runAt
+  };
+}
+function decodeCronJobInfo(job) {
+  const base = {
+    name: job.name,
+    action: job.action,
+    args: decodeArgs(job.args),
+    nextRunAt: job.nextRunAt,
+    lastRunAt: job.lastRunAt,
+    maxHistory: job.maxHistory
+  };
+  if (job.kind === "cron") {
+    return {
+      ...base,
+      kind: "cron",
+      expression: job.expression,
+      timezone: job.timezone
+    };
+  }
+  return {
+    ...base,
+    kind: "every",
+    interval: job.intervalMs
+  };
+}
+function decodeCronFire(fire) {
+  return { ...fire };
+}
 var NativeKvAdapter = class {
   #runtime;
   #ctx;
@@ -26426,6 +26823,7 @@ var ActorContextHandleAdapter = class {
   #client;
   #clientFactory;
   #connMap;
+  #cron;
   #databaseProvider;
   #db;
   #dispatchCancelToken;
@@ -26466,6 +26864,11 @@ var ActorContextHandleAdapter = class {
     }
     return this.#sql;
   }
+  async actorRuntimeSocket() {
+    return await callNative(
+      () => this.#runtime.actorRuntimeSocketProvision(this.#ctx)
+    );
+  }
   get db() {
     if (!this.#databaseProvider) {
       throw databaseNotConfiguredError();
@@ -26555,6 +26958,12 @@ var ActorContextHandleAdapter = class {
     }
     return this.#schedule;
   }
+  get cron() {
+    if (!this.#cron) {
+      this.#cron = new NativeCronAdapter(this.#runtime, this.#ctx);
+    }
+    return this.#cron;
+  }
   get actorId() {
     return callNativeSync(() => this.#runtime.actorId(this.#ctx));
   }
@@ -26739,6 +27148,11 @@ var ActorContextHandleAdapter = class {
       () => this.#runtime.actorRequestSave(this.#ctx, { immediate: false })
     );
   }
+  async saveStateAndWorkflowBatch(writes) {
+    await callNative(
+      () => this.#runtime.actorSaveStateAndWorkflowBatch(this.#ctx, writes)
+    );
+  }
   serializeForTick(reason) {
     void reason;
     const actorState = getNativePersistState(this.#runtime, this.#ctx);
@@ -27053,6 +27467,9 @@ var NativeWorkflowRuntimeAdapter = class {
     this.stateManager = {
       saveState: async (opts) => {
         await this.#ctx.saveState(opts);
+      },
+      saveStateAndWorkflowBatch: async (writes) => {
+        await this.#ctx.saveStateAndWorkflowBatch(writes);
       }
     };
   }
@@ -27122,11 +27539,13 @@ function buildActorConfig(definition, registryConfig, runtimeKind) {
   const config3 = definition.config;
   const options = config3.options ?? {};
   const canHibernate = options.canHibernateWebSocket;
+  const usesRemoteSqlite = sqliteBackendForConfig(registryConfig) === "remote";
   return {
     name: options.name,
     icon: options.icon,
-    hasDatabase: config3.db !== void 0,
-    remoteSqlite: config3.db !== void 0 && sqliteBackendForConfig(registryConfig) === "remote",
+    hasDatabase: config3.db !== void 0 || usesRemoteSqlite,
+    remoteSqlite: usesRemoteSqlite,
+    enableActorRuntimeSocket: options.enableActorRuntimeSocket === true,
     hasState: config3.state !== void 0 || typeof config3.createState === "function",
     canHibernateWebsocket: typeof canHibernate === "boolean" ? canHibernate : void 0,
     stateSaveIntervalMs: options.stateSaveInterval,
@@ -27142,6 +27561,7 @@ function buildActorConfig(definition, registryConfig, runtimeKind) {
     connectionLivenessTimeoutMs: options.connectionLivenessTimeout,
     connectionLivenessIntervalMs: options.connectionLivenessInterval,
     maxQueueSize: options.maxQueueSize,
+    maxSchedules: options.maxSchedules,
     maxQueueMessageSize: options.maxQueueMessageSize,
     maxIncomingMessageSize: registryConfig.maxIncomingMessageSize,
     maxOutgoingMessageSize: registryConfig.maxOutgoingMessageSize,
@@ -27418,7 +27838,9 @@ function buildNativeFactory(runtime, registryConfig, definition) {
             400
           );
         }
-        const cbor2 = encodeCborCompat(body.body ?? null);
+        const cbor2 = encodeCborCompat(
+          body.body ?? null
+        );
         const message = await runtime.actorQueueSend(ctx, name, cbor2);
         return jsonResponse({
           id: message.id().toString(),
@@ -28111,7 +28533,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
         name,
         wrapNativeCallback(
           async (error46, payload) => {
-            const { ctx, conn, args, cancelToken } = unwrapTsfnPayload(error46, payload);
+            const { ctx, conn, args, scheduledFire, cancelToken } = unwrapTsfnPayload(error46, payload);
             const actorCtx = conn != null ? makeConnCtx(ctx, conn, void 0, cancelToken) : makeActorCtx(ctx, void 0, cancelToken);
             try {
               return encodeValue(
@@ -28121,7 +28543,8 @@ function buildNativeFactory(runtime, registryConfig, definition) {
                     schemaConfig.actionInputSchemas,
                     name,
                     decodeArgs(args)
-                  )
+                  ),
+                  ...scheduledFire ? [scheduledFire] : []
                 )
               );
             } finally {