@rivetkit/supabase 0.0.0-main.3118df2 → 0.0.0-main.79e97f1

package/dist/mod.js

@@ -508,7 +508,7 @@ function unsupportedFeature(feature) {
   );
 }
 
-// ../rivetkit/dist/tsup/chunk-6HYOPKO3.js
+// ../rivetkit/dist/tsup/chunk-Y5BCFECV.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-6HYOPKO3.js
+// ../rivetkit/dist/tsup/chunk-Y5BCFECV.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: "0.0.0-main.3118df2",
+  version: "0.0.0-main.79e97f1",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -13416,6 +13418,16 @@ var package_default = {
         default: "./dist/tsup/db/drizzle.cjs"
       }
     },
+    "./unstable/migrations": {
+      import: {
+        types: "./dist/tsup/unstable/migrations.d.ts",
+        default: "./dist/tsup/unstable/migrations.js"
+      },
+      require: {
+        types: "./dist/tsup/unstable/migrations.d.cts",
+        default: "./dist/tsup/unstable/migrations.cjs"
+      }
+    },
     "./dynamic": {
       import: {
         types: "./dist/tsup/dynamic/mod.d.ts",
@@ -13515,7 +13527,7 @@ var package_default = {
     "./dist/tsup/chunk-*.cjs"
   ],
   scripts: {
-    build: "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/inspector-tab/mod.ts src/db/mod.ts src/db/drizzle.ts src/dynamic/mod.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
+    build: "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/inspector-tab/mod.ts src/db/mod.ts src/db/drizzle.ts src/dynamic/mod.ts src/unstable/migrations.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
     "build:browser": "tsup --config tsup.browser.config.ts",
     "check-types": "tsc --noEmit",
     lint: "biome check . && pnpm run check:test-skips && pnpm run check:wait-for-comments",
@@ -13741,1633 +13753,1766 @@ 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;
-  }
-};
-
-// ../../../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);
+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;
   }
-};
-function check2(bc, min) {
-  if (DEV) {
-    assert2(isU32(min));
+  if (typeof value === "function") {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a function and is not CBOR serializable`
+    );
   }
-  if (bc.offset + min > bc.bytes.length) {
-    throw new BareError(bc.offset, "missing bytes");
+  if (typeof value === "symbol") {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a symbol and is not CBOR serializable`
+    );
   }
-}
-function reserve(bc, min) {
-  if (DEV) {
-    assert2(isU32(min));
+  if (value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof ArrayBuffer || value instanceof Uint8Array || isTypedArray(value)) {
+    return;
   }
-  const minLen = bc.offset + min | 0;
-  if (minLen > bc.bytes.length) {
-    grow(bc, minLen);
+  if (value instanceof WeakMap) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakMap and is not CBOR serializable`
+    );
   }
-}
-function grow(bc, minLen) {
-  if (minLen > bc.config.maxBufferLength) {
-    throw new BareError(0, TOO_LARGE_BUFFER);
+  if (value instanceof WeakSet) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakSet 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);
-    }
-    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);
-  }
-  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");
-  }
-  return val > 0;
-}
-function writeBool(bc, x) {
-  writeU8(bc, x ? 1 : 0);
-}
-function readU8(bc) {
-  check2(bc, 1);
-  return bc.bytes[bc.offset++];
-}
-function writeU8(bc, x) {
-  if (DEV) {
-    assert2(isU8(x), TOO_LARGE_NUMBER);
+  if (value instanceof WeakRef) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a WeakRef and is not CBOR serializable`
+    );
   }
-  reserve(bc, 1);
-  bc.bytes[bc.offset++] = x;
-}
-function readU32(bc) {
-  check2(bc, 4);
-  const result = bc.view.getUint32(bc.offset, true);
-  bc.offset += 4;
-  return result;
-}
-function readU64(bc) {
-  check2(bc, 8);
-  const result = bc.view.getBigUint64(bc.offset, true);
-  bc.offset += 8;
-  return result;
-}
-function writeU64(bc, x) {
-  if (DEV) {
-    assert2(isU64(x), TOO_LARGE_NUMBER);
+  if (value instanceof Promise) {
+    throw new TypeError(
+      `Value at ${path2 || "root"} is a Promise and is not CBOR serializable`
+    );
   }
-  reserve(bc, 8);
-  bc.view.setBigUint64(bc.offset, x, true);
-  bc.offset += 8;
-}
-
-// ../../../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);
+  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 BigInt(low) + (BigInt(height) << BigInt(7 * 7));
-  }
-  return BigInt(low);
-}
-function writeUint(bc, x) {
-  const truncated = BigInt.asUintN(64, x);
-  if (DEV) {
-    assert2(truncated === x, TOO_LARGE_NUMBER);
+    return;
   }
-  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 (value instanceof Set) {
+    let index = 0;
+    for (const item of value.values()) {
+      assertJsonCompatValue(item, `${path2 || "root"}.set[${index}]`);
+      index++;
     }
+    return;
   }
-  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(value)) {
+    for (let i = 0; i < value.length; i++) {
+      assertJsonCompatValue(value[i], `${path2 || "root"}[${i}]`);
     }
-    if (byteCount === UINT_SAFE32_MAX_BYTE_COUNT && byte > 15) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    return;
+  }
+  if (isPlainObject2(value)) {
+    for (const key in value) {
+      assertJsonCompatValue(
+        value[key],
+        path2 ? `${path2}.${key}` : key
+      );
     }
+    return;
   }
-  return result;
+  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 writeUintSafe32(bc, x) {
-  if (DEV) {
-    assert2(isU32(x), TOO_LARGE_NUMBER);
+var EncodingSchema = external_exports.enum(["json", "cbor", "bare"]);
+async function inputDataToBuffer(data) {
+  if (typeof data === "string") {
+    return data;
   }
-  let zigZag = x >>> 0;
-  while (zigZag >= 128) {
-    writeU8(bc, 128 | zigZag & 127);
-    zigZag >>>= 7;
+  if (data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
   }
-  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 (byteCount === INT_SAFE_MAX_BYTE_COUNT && byte > 15) {
-      bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
-    }
+  if (data instanceof Uint8Array) {
+    return data;
   }
-  return result;
-}
-
-// ../../../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));
+  if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  throw new Error("Malformed message");
 }
-function writeU8Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  writeU8FixedArray(bc, x);
+function base64EncodeUint8Array(uint8Array) {
+  let binary = "";
+  for (const value of uint8Array) {
+    binary += String.fromCharCode(value);
+  }
+  return btoa(binary);
 }
-function readU8FixedArray(bc, len) {
-  return readUnsafeU8FixedArray(bc, len).slice();
+function base64EncodeArrayBuffer(arrayBuffer) {
+  return base64EncodeUint8Array(new Uint8Array(arrayBuffer));
 }
-function writeU8FixedArray(bc, x) {
-  const len = x.length;
-  if (len > 0) {
-    reserve(bc, len);
-    bc.bytes.set(x, bc.offset);
-    bc.offset += len;
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
   }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
-function readUnsafeU8FixedArray(bc, len) {
-  if (DEV) {
-    assert2(isU32(len));
+function encodeJsonCompatValue(input) {
+  var _a2;
+  if (input === null) {
+    return input;
   }
-  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 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);
+  if (input === void 0) {
+    return [JSON_COMPAT_UNDEFINED, 0];
   }
-}
-function readFixedString(bc, byteLen) {
-  if (DEV) {
-    assert2(isU32(byteLen));
+  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+    return input;
   }
-  if (byteLen < TEXT_DECODER_THRESHOLD) {
-    return readUtf8Js(bc, byteLen);
+  if (typeof input === "bigint") {
+    return [JSON_COMPAT_BIGINT, input.toString()];
   }
-  try {
-    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
-  } catch (_cause) {
-    throw new BareError(bc.offset, INVALID_UTF8_STRING);
+  if (input instanceof ArrayBuffer) {
+    return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(input)];
   }
-}
-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);
+  if (input instanceof Uint8Array) {
+    return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(input)];
   }
-  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;
-    }
+  if (isTypedArray(input)) {
+    return input;
   }
-  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++;
-        }
-      }
-    }
+  if (input instanceof Date || input instanceof RegExp || input instanceof Error) {
+    return input;
   }
-  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");
+  if (input instanceof Set) {
+    const encoded = [...input.values()].map(
+      (v) => encodeJsonCompatValue(v)
+    );
+    return [JSON_COMPAT_SET, encoded];
   }
-  return {
-    initialBufferLength,
-    maxBufferLength
-  };
-}
-
-// ../rivetkit/dist/tsup/chunk-QTINS2PE.js
-var config2 = /* @__PURE__ */ Config({});
-function readWorkflowCbor(bc) {
-  return readData(bc);
-}
-function readWorkflowNameIndex(bc) {
-  return readU32(bc);
-}
-function readWorkflowLoopIterationMarker(bc) {
-  return {
-    loop: readWorkflowNameIndex(bc),
-    iteration: readU32(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");
+  if (input instanceof Map) {
+    const encoded = /* @__PURE__ */ new Map();
+    for (const [k, v] of input.entries()) {
+      encoded.set(
+        encodeJsonCompatValue(k),
+        encodeJsonCompatValue(v)
+      );
     }
+    return encoded;
   }
-}
-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);
+  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;
   }
-  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");
+  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 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 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;
   }
-}
-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");
+  if (input instanceof Map) {
+    const revived = /* @__PURE__ */ new Map();
+    for (const [k, v] of input.entries()) {
+      revived.set(
+        reviveJsonCompatValue(k, options),
+        reviveJsonCompatValue(v, options)
+      );
+    }
+    return revived;
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 2 && typeof input[0] === "string" && input[0].startsWith("$")) {
+      if (input[0] === JSON_COMPAT_BIGINT) {
+        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.`
+      );
     }
+    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 input;
 }
-function read0(bc) {
-  return readBool(bc) ? readWorkflowCbor(bc) : null;
+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 read1(bc) {
-  return readBool(bc) ? readString(bc) : null;
+function base64DecodeToArrayBuffer(base643) {
+  return base64DecodeToUint8Array(base643).buffer;
 }
-function readWorkflowStepEntry(bc) {
-  return {
-    output: read0(bc),
-    error: read1(bc)
-  };
+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 readWorkflowLoopEntry(bc) {
-  return {
-    state: readWorkflowCbor(bc),
-    iteration: readU32(bc),
-    output: read0(bc)
-  };
+function jsonParseCompat(input) {
+  return reviveJsonCompatValue(JSON.parse(input));
 }
-function readWorkflowSleepEntry(bc) {
-  return {
-    deadline: readU64(bc),
-    state: readWorkflowSleepState(bc)
-  };
+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 readWorkflowMessageEntry(bc) {
-  return {
-    name: readString(bc),
-    messageData: readWorkflowCbor(bc)
-  };
+function getEnvUniversal(key) {
+  if (typeof Deno !== "undefined") {
+    return Deno.env.get(key);
+  } else if (typeof process !== "undefined") {
+    return process.env[key];
+  }
 }
-function readWorkflowRollbackCheckpointEntry(bc) {
-  return {
-    name: readString(bc)
-  };
+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 readWorkflowBranchStatus(bc) {
-  return {
-    status: readWorkflowBranchStatusType(bc),
-    output: read0(bc),
-    error: read1(bc)
-  };
+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 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 bufferToArrayBuffer(buf) {
+  return buf.buffer.slice(
+    buf.byteOffset,
+    buf.byteOffset + buf.byteLength
+  );
+}
+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)}`
+        );
+      }
     }
-    result.set(key, readWorkflowBranchStatus(bc));
   }
-  return result;
+  const fullQuery = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+  return `${baseUrl.protocol}//${baseUrl.host}${fullPath}${fullQuery}`;
 }
-function readWorkflowJoinEntry(bc) {
-  return {
-    branches: read2(bc)
-  };
+
+// ../../../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;
+  }
 }
-function readWorkflowRaceEntry(bc) {
-  return {
-    winner: read1(bc),
-    branches: read2(bc)
-  };
+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 readWorkflowRemovedEntry(bc) {
-  return {
-    originalType: readString(bc),
-    originalName: read1(bc)
-  };
+function isU32(val) {
+  return val === val >>> 0;
 }
-function readWorkflowVersionCheckEntry(bc) {
-  return {
-    resolved: readU32(bc),
-    latest: readU32(bc)
-  };
+function isU64(val) {
+  return val === BigInt.asUintN(64, val);
 }
-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");
+
+// ../../../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);
     }
+    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");
   }
 }
-function readWorkflowEntry(bc) {
-  return {
-    id: readString(bc),
-    location: readWorkflowLocation(bc),
-    kind: readWorkflowEntryKind(bc)
-  };
+function reserve(bc, min) {
+  if (DEV) {
+    assert2(isU32(min));
+  }
+  const minLen = bc.offset + min | 0;
+  if (minLen > bc.bytes.length) {
+    grow(bc, minLen);
+  }
 }
-function read3(bc) {
-  return readBool(bc) ? readU64(bc) : null;
+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);
+  }
+  bc.bytes = newBytes;
+  bc.view = new DataView(newBytes.buffer);
 }
-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 isEs2024ArrayBufferLike(buffer) {
+  return "maxByteLength" in buffer;
 }
-function read4(bc) {
-  const len = readUintSafe(bc);
-  if (len === 0) {
-    return [];
+
+// ../../../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");
   }
-  const result = [readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readString(bc);
+  return val > 0;
+}
+function writeBool(bc, x) {
+  writeU8(bc, x ? 1 : 0);
+}
+function readU8(bc) {
+  check2(bc, 1);
+  return bc.bytes[bc.offset++];
+}
+function writeU8(bc, x) {
+  if (DEV) {
+    assert2(isU8(x), TOO_LARGE_NUMBER);
   }
+  reserve(bc, 1);
+  bc.bytes[bc.offset++] = x;
+}
+function readU32(bc) {
+  check2(bc, 4);
+  const result = bc.view.getUint32(bc.offset, true);
+  bc.offset += 4;
   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);
-  }
+function readU64(bc) {
+  check2(bc, 8);
+  const result = bc.view.getBigUint64(bc.offset, true);
+  bc.offset += 8;
   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");
+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;
+}
+
+// ../../../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++;
     }
-    result.set(key, readWorkflowEntryMetadata(bc));
+    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 result;
+  return BigInt(low);
 }
-function readWorkflowHistory(bc) {
-  return {
-    nameRegistry: read4(bc),
-    entries: read5(bc),
-    entryMetadata: read6(bc)
-  };
+function writeUint(bc, x) {
+  const truncated = BigInt.asUintN(64, x);
+  if (DEV) {
+    assert2(truncated === x, TOO_LARGE_NUMBER);
+  }
+  writeUintTruncated(bc, truncated);
 }
-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 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;
+    }
   }
-  return result;
+  writeU8(bc, tmp);
 }
-function decodeWorkflowHistoryTransport(data) {
-  return decodeWorkflowHistory(toUint8Array(data));
+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;
 }
-
-// ../rivetkit/dist/tsup/chunk-X3LBDNEH.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(),
-  onHistoryUpdated: zFunction().optional(),
-  replayFromStep: zFunction().optional()
-});
-var RunInspectorConfigSchema = external_exports.object({
-  workflow: WorkflowInspectorConfigSchema.optional()
-}).optional();
-var BUILTIN_INSPECTOR_TAB_IDS = [
-  "workflow",
-  "database",
-  "state",
-  "queue",
-  "connections",
-  "console"
-];
-var BuiltinInspectorTabIdSchema = external_exports.enum(BUILTIN_INSPECTOR_TAB_IDS);
-var CUSTOM_INSPECTOR_TAB_ID_RE = /^[A-Za-z0-9_-]+$/;
-var CustomInspectorTabEntrySchema = external_exports.object({
-  id: external_exports.string().regex(
-    CUSTOM_INSPECTOR_TAB_ID_RE,
-    "inspector.tabs[].id must contain only letters, digits, underscore, or dash"
-  ),
-  label: external_exports.string().min(1),
-  source: external_exports.string().min(1),
-  /**
-   * Optional icon id. The dashboard maps strings to glyphs (see its
-   * icon registry); unknown ids fall back to a generic icon.
-   */
-  icon: external_exports.string().min(1).optional(),
-  hidden: external_exports.literal(false).optional()
-}).strict();
-var HideInspectorTabEntrySchema = external_exports.object({
-  id: BuiltinInspectorTabIdSchema,
-  hidden: external_exports.literal(true)
-}).strict();
-var InspectorTabEntrySchema = external_exports.union([
-  CustomInspectorTabEntrySchema,
-  HideInspectorTabEntrySchema
-]);
-var ActorInspectorConfigSchema = external_exports.object({
-  tabs: external_exports.array(InspectorTabEntrySchema).default(() => [])
-}).strict().refine(
-  (data) => {
-    const ids = data.tabs.map((t) => t.id);
-    return new Set(ids).size === ids.length;
-  },
-  { message: "Duplicate id in inspector.tabs", path: ["tabs"] }
-).refine(
-  (data) => {
-    const builtinSet = new Set(BUILTIN_INSPECTOR_TAB_IDS);
-    return data.tabs.every(
-      (t) => t.hidden === true || !builtinSet.has(t.id)
+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 readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = (
+      /* 2**7 */
+      128
     );
-  },
-  {
-    message: "Custom inspector tab id collides with a built-in (use hidden: true to hide a built-in)",
-    path: ["tabs"]
+    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);
+    }
   }
-);
-var RunConfigSchema = external_exports.object({
-  /** Display name for the actor in the Inspector UI. */
-  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(),
-  /** The run handler function. */
-  run: zFunction(),
-  /** Inspector integration for long-running run handlers. */
-  inspector: RunInspectorConfigSchema.optional()
-});
-var RUN_FUNCTION_CONFIG_SYMBOL = /* @__PURE__ */ Symbol.for(
-  "rivetkit.run_function_config"
-);
-var zRunHandler = external_exports.union([zFunction(), RunConfigSchema]).optional();
-function getRunFunction(run) {
-  if (!run) return void 0;
-  if (typeof run === "function") return run;
-  return run.run;
+  return result;
 }
-function getRunMetadata(run) {
-  if (!run) return {};
-  if (typeof run === "function") {
-    const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
-    if (!config3) return {};
-    return { name: config3.name, icon: config3.icon };
+
+// ../../../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 writeU8Array(bc, x) {
+  writeUintSafe32(bc, x.length);
+  writeU8FixedArray(bc, x);
+}
+function readU8FixedArray(bc, len) {
+  return readUnsafeU8FixedArray(bc, len).slice();
+}
+function writeU8FixedArray(bc, x) {
+  const len = x.length;
+  if (len > 0) {
+    reserve(bc, len);
+    bc.bytes.set(x, bc.offset);
+    bc.offset += len;
   }
-  return { name: run.name, icon: run.icon };
 }
-function getRunInspectorConfig(run, actor2) {
-  if (!run) return void 0;
-  if (typeof run === "function") {
-    const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
-    return (config3 == null ? void 0 : config3.inspectorFactory) ? config3.inspectorFactory(actor2) : config3 == null ? void 0 : config3.inspector;
+function readUnsafeU8FixedArray(bc, len) {
+  if (DEV) {
+    assert2(isU32(len));
   }
-  return run.inspector;
+  check2(bc, len);
+  const offset = bc.offset;
+  bc.offset += len;
+  return bc.bytes.subarray(offset, offset + len);
 }
-function disposeRunInspector(run, actorId) {
-  var _a2;
-  if (!run || typeof run !== "function") {
-    return;
+
+// ../../../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);
   }
-  const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
-  (_a2 = config3 == null ? void 0 : config3.disposeInspector) == null ? void 0 : _a2.call(config3, actorId);
 }
-var GlobalActorOptionsBaseSchema = external_exports.object({
-  /** Display name for the actor in the Inspector UI. */
-  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.
-   *
-   * WebSockets using actions/events are hibernatable by default.
-   *
-   * @experimental
-   **/
-  canHibernateWebSocket: external_exports.union([external_exports.boolean(), zFunction()]).default(false)
-}).strict();
-var GlobalActorOptionsSchema = GlobalActorOptionsBaseSchema.prefault(
-  () => ({})
-);
-var InstanceActorOptionsBaseSchema = external_exports.object({
-  createVarsTimeout: external_exports.number().positive().default(5e3),
-  createConnStateTimeout: external_exports.number().positive().default(5e3),
-  onBeforeConnectTimeout: external_exports.number().positive().default(5e3),
-  onConnectTimeout: external_exports.number().positive().default(5e3),
-  onMigrateTimeout: external_exports.number().positive().default(3e4),
-  sleepGracePeriod: external_exports.number().positive().default(DEFAULT_SLEEP_GRACE_PERIOD),
-  /** @deprecated `onDestroyTimeout` is folded into `sleepGracePeriod`, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0. */
-  onDestroyTimeout: external_exports.number().positive().optional(),
-  /** @deprecated `waitUntilTimeout` is folded into `sleepGracePeriod`, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0. */
-  waitUntilTimeout: external_exports.number().positive().optional(),
-  stateSaveInterval: external_exports.number().positive().default(1e3),
-  actionTimeout: external_exports.number().positive().default(6e4),
-  connectionLivenessTimeout: external_exports.number().positive().default(2500),
-  connectionLivenessInterval: external_exports.number().positive().default(5e3),
-  /** @deprecated Use `c.keepAwake(promise)` to scope keep-awake to a specific operation, or keep `noSleep` for actors that must stay awake indefinitely. Will be removed in 2.2.0. */
-  noSleep: external_exports.boolean().default(false),
-  sleepTimeout: external_exports.number().positive().default(3e4),
-  maxQueueSize: external_exports.number().positive().default(1e3),
-  maxQueueMessageSize: external_exports.number().positive().default(64 * 1024),
-  /** @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(),
-  /** @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(() => ({}));
-var ActorOptionsSchema = GlobalActorOptionsBaseSchema.extend(
-  InstanceActorOptionsBaseSchema.shape
-).strict().prefault(() => ({}));
-var ActorConfigSchema = external_exports.object({
-  onCreate: zFunction().optional(),
-  onDestroy: zFunction().optional(),
-  onMigrate: zFunction().optional(),
-  onWake: zFunction().optional(),
-  onSleep: zFunction().optional(),
-  run: zRunHandler,
-  onStateChange: zFunction().optional(),
-  onBeforeConnect: zFunction().optional(),
-  onConnect: zFunction().optional(),
-  onDisconnect: zFunction().optional(),
-  onBeforeActionResponse: zFunction().optional(),
-  onRequest: zFunction().optional(),
-  onWebSocket: zFunction().optional(),
-  actions: external_exports.record(external_exports.string(), zFunction()).default(() => ({})),
-  actionInputSchemas: external_exports.record(external_exports.string(), external_exports.any()).optional(),
-  connParamsSchema: external_exports.any().optional(),
-  events: external_exports.record(external_exports.string(), external_exports.any()).optional(),
-  queues: external_exports.record(external_exports.string(), external_exports.any()).optional(),
-  state: external_exports.any().optional(),
-  createState: zFunction().optional(),
-  connState: external_exports.any().optional(),
-  createConnState: zFunction().optional(),
-  vars: external_exports.any().optional(),
-  db: external_exports.any().optional(),
-  createVars: zFunction().optional(),
-  options: ActorOptionsSchema,
-  inspector: ActorInspectorConfigSchema.optional()
-}).strict().refine(
-  (data) => !(data.state !== void 0 && data.createState !== void 0),
-  {
-    message: "Cannot define both 'state' and 'createState'",
-    path: ["state"]
-  }
-).refine(
-  (data) => !(data.connState !== void 0 && data.createConnState !== void 0),
-  {
-    message: "Cannot define both 'connState' and 'createConnState'",
-    path: ["connState"]
+function readFixedString(bc, byteLen) {
+  if (DEV) {
+    assert2(isU32(byteLen));
   }
-).refine(
-  (data) => !(data.vars !== void 0 && data.createVars !== void 0),
-  {
-    message: "Cannot define both 'vars' and 'createVars'",
-    path: ["vars"]
+  if (byteLen < TEXT_DECODER_THRESHOLD) {
+    return readUtf8Js(bc, byteLen);
   }
-);
-var DocActorOptionsSchema = external_exports.object({
-  name: external_exports.string().optional().describe("Display name for the actor in the Inspector UI."),
-  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"
-  ),
-  onMigrateTimeout: external_exports.number().optional().describe("Timeout in ms for onMigrate handler. Default: 30000"),
-  onBeforeConnectTimeout: external_exports.number().optional().describe(
-    "Timeout in ms for onBeforeConnect handler. Default: 5000"
-  ),
-  onConnectTimeout: external_exports.number().optional().describe("Timeout in ms for onConnect handler. Default: 5000"),
-  sleepGracePeriod: external_exports.number().optional().describe(
-    `Max time in ms for the graceful shutdown window. Covers lifecycle hooks (onSleep, onDestroy), the run handler wait, async raw WebSocket handlers, disconnect callbacks, and final state serialization. Default: ${DEFAULT_SLEEP_GRACE_PERIOD}.`
-  ),
-  onDestroyTimeout: external_exports.number().optional().describe(
-    "Deprecated. Folded into sleepGracePeriod, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0."
-  ),
-  waitUntilTimeout: external_exports.number().optional().describe(
-    "Deprecated. Folded into sleepGracePeriod, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0."
-  ),
-  stateSaveInterval: external_exports.number().optional().describe(
-    "Interval in ms between automatic state saves. Default: 1000"
-  ),
-  actionTimeout: external_exports.number().optional().describe("Timeout in ms for action handlers. Default: 60000"),
-  connectionLivenessTimeout: external_exports.number().optional().describe(
-    "Timeout in ms for connection liveness checks. Default: 2500"
-  ),
-  connectionLivenessInterval: external_exports.number().optional().describe(
-    "Interval in ms between connection liveness checks. Default: 5000"
-  ),
-  noSleep: external_exports.boolean().optional().describe(
-    "Deprecated. If true, the actor will never sleep. Use c.keepAwake(promise) to scope keep-awake to a specific operation instead. Default: false"
-  ),
-  sleepTimeout: external_exports.number().optional().describe(
-    "Time in ms of inactivity before the actor sleeps. Default: 30000"
-  ),
-  maxQueueSize: external_exports.number().optional().describe(
-    "Maximum number of queue messages before rejecting new messages. 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"
-  )
-}).describe("Actor options for timeouts and behavior configuration.");
-var DocActorConfigSchema = external_exports.object({
-  state: external_exports.unknown().optional().describe(
-    "Initial state value for the actor. Cannot be used with createState."
-  ),
-  createState: external_exports.unknown().optional().describe(
-    "Function to create initial state. Receives context and input. Cannot be used with state."
-  ),
-  connState: external_exports.unknown().optional().describe(
-    "Initial connection state value. Cannot be used with createConnState."
-  ),
-  createConnState: external_exports.unknown().optional().describe(
-    "Function to create connection state. Receives context and connection params. The pending connection is not visible in c.conns until this succeeds. Cannot be used with connState."
-  ),
-  vars: external_exports.unknown().optional().describe(
-    "Initial ephemeral variables value. Cannot be used with createVars."
-  ),
-  createVars: external_exports.unknown().optional().describe(
-    "Function to create ephemeral variables. Receives context and driver context. Cannot be used with vars."
-  ),
-  db: external_exports.unknown().optional().describe("Database provider instance for the actor."),
-  onCreate: external_exports.unknown().optional().describe(
-    "Called when the actor is first initialized. Use to initialize state."
-  ),
-  onDestroy: external_exports.unknown().optional().describe("Called when the actor is destroyed."),
-  onMigrate: external_exports.unknown().optional().describe(
-    "Called on every actor start after persisted state loads and before onWake. Use for repeatable schema migrations."
-  ),
-  onWake: external_exports.unknown().optional().describe(
-    "Called when the actor wakes up and is ready to receive connections and actions."
-  ),
-  onSleep: external_exports.unknown().optional().describe(
-    "Called when the actor is stopping or sleeping. Use to clean up resources."
-  ),
-  run: external_exports.unknown().optional().describe(
-    "Called after actor starts. Does not block startup. Use for background tasks like queue processing or tick loops. If it exits, the actor follows the normal idle sleep timeout once idle. If it throws, the actor logs the error and then follows the normal idle sleep timeout once idle."
-  ),
-  onStateChange: external_exports.unknown().optional().describe(
-    "Called when the actor's state changes. State changes within this hook won't trigger recursion."
-  ),
-  onBeforeConnect: external_exports.unknown().optional().describe(
-    "Called before a client connects. Throw an error to reject the connection. The pending connection is not visible in c.conns while this runs."
-  ),
-  onConnect: external_exports.unknown().optional().describe(
-    "Called when a client successfully connects. The connection is visible in c.conns before this runs."
-  ),
-  onDisconnect: external_exports.unknown().optional().describe("Called when a client disconnects."),
-  onBeforeActionResponse: external_exports.unknown().optional().describe(
-    "Called before sending an action response. Use to transform output."
-  ),
-  onRequest: external_exports.unknown().optional().describe(
-    "Called for raw HTTP requests to /actors/{name}/http/* endpoints."
-  ),
-  onWebSocket: external_exports.unknown().optional().describe(
-    "Called for raw WebSocket connections to /actors/{name}/websocket/* endpoints."
-  ),
-  actions: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
-    "Map of action name to handler function. Defaults to an empty object."
-  ),
-  actionInputSchemas: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
-    "Optional schema map for validating action argument tuples in native runtimes."
-  ),
-  connParamsSchema: external_exports.unknown().optional().describe(
-    "Optional schema for validating connection params in native runtimes."
-  ),
-  events: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Map of event names to schemas."),
-  queues: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Map of queue names to schemas."),
-  options: DocActorOptionsSchema.optional()
-}).describe("Actor configuration passed to the actor() function.");
-
-// ../rivetkit/dist/tsup/chunk-JI6GZ2C2.js
-var EMPTY_KEY = "/";
-var KEY_SEPARATOR = "/";
-var KEYS = {
-  PERSIST_DATA: Uint8Array.from([1]),
-  CONN_PREFIX: Uint8Array.from([2]),
-  INSPECTOR_TOKEN: Uint8Array.from([3]),
-  KV: Uint8Array.from([4]),
-  QUEUE_PREFIX: Uint8Array.from([5]),
-  LAST_PUSHED_ALARM: Uint8Array.from([6]),
-  WORKFLOW_PREFIX: Uint8Array.from([6]),
-  TRACES_PREFIX: Uint8Array.from([7])
-};
-var STORAGE_VERSION = {
-  QUEUE: 1,
-  WORKFLOW: 1,
-  TRACES: 1
-};
-var STORAGE_VERSION_BYTES = {
-  QUEUE: Uint8Array.from([STORAGE_VERSION.QUEUE]),
-  WORKFLOW: Uint8Array.from([STORAGE_VERSION.WORKFLOW]),
-  TRACES: Uint8Array.from([STORAGE_VERSION.TRACES])
-};
-var QUEUE_NAMESPACE = {
-  METADATA: Uint8Array.from([1]),
-  MESSAGES: Uint8Array.from([2])
-};
-function concatPrefix(prefix, suffix) {
-  const merged = new Uint8Array(prefix.length + suffix.length);
-  merged.set(prefix, 0);
-  merged.set(suffix, prefix.length);
-  return merged;
-}
-var QUEUE_STORAGE_PREFIX = concatPrefix(
-  KEYS.QUEUE_PREFIX,
-  STORAGE_VERSION_BYTES.QUEUE
-);
-var QUEUE_METADATA_KEY = concatPrefix(
-  QUEUE_STORAGE_PREFIX,
-  QUEUE_NAMESPACE.METADATA
-);
-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;
+  try {
+    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
+  } catch (_cause) {
+    throw new BareError(bc.offset, INVALID_UTF8_STRING);
   }
-  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);
+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);
       }
-      currentPart = "";
-    } else {
-      currentPart += char;
     }
+    result += String.fromCodePoint(codePoint);
   }
-  if (escaping) {
-    parts.push(`${currentPart}\\`);
-  } else if (isEmptyStringMarker) {
-    parts.push("");
-  } else if (currentPart !== "" || parts.length > 0) {
-    parts.push(currentPart);
+  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;
+    }
   }
-  return parts;
+  bc.offset = offset;
 }
-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 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;
 }
-function removePrefixFromKey(prefixedKey) {
-  return prefixedKey.slice(KEYS.KV.length);
+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
+  };
 }
 
-// ../rivetkit/dist/tsup/chunk-PM4ACAVN.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;
+// ../rivetkit/dist/tsup/chunk-ULYPJPHB.js
+var config2 = /* @__PURE__ */ Config({});
+function readWorkflowCbor(bc) {
+  return readData(bc);
 }
-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)})`);
+function readWorkflowNameIndex(bc) {
+  return readU32(bc);
+}
+function readWorkflowLoopIterationMarker(bc) {
+  return {
+    loop: readWorkflowNameIndex(bc),
+    iteration: readU32(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;
   }
-  if (value instanceof Set) {
-    let index = 0;
-    for (const item of value.values()) {
-      assertJsonCompatValue(item, `${path2 || "root"}.set[${index}]`);
-      index++;
-    }
-    return;
+}
+function readWorkflowLocation(bc) {
+  const len = readUintSafe(bc);
+  if (len === 0) {
+    return [];
   }
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      assertJsonCompatValue(value[i], `${path2 || "root"}[${i}]`);
-    }
-    return;
+  const result = [readWorkflowPathSegment(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readWorkflowPathSegment(bc);
   }
-  if (isPlainObject2(value)) {
-    for (const key in value) {
-      assertJsonCompatValue(
-        value[key],
-        path2 ? `${path2}.${key}` : key
-      );
+  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");
     }
-    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);
+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");
+    }
   }
-  throw new Error("Malformed message");
 }
-function base64EncodeUint8Array(uint8Array) {
-  let binary = "";
-  for (const value of uint8Array) {
-    binary += String.fromCharCode(value);
+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");
+    }
   }
-  return btoa(binary);
 }
-function base64EncodeArrayBuffer(arrayBuffer) {
-  return base64EncodeUint8Array(new Uint8Array(arrayBuffer));
+function read0(bc) {
+  return readBool(bc) ? readWorkflowCbor(bc) : null;
 }
-function isPlainObject2(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
+function read1(bc) {
+  return readBool(bc) ? readString(bc) : null;
 }
-function encodeJsonCompatValue(input) {
-  var _a2;
-  if (input === null) {
-    return input;
+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));
   }
-  if (input === void 0) {
-    return [JSON_COMPAT_UNDEFINED, 0];
+  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");
+    }
   }
-  if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
-    return input;
+}
+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 [];
   }
-  if (typeof input === "bigint") {
-    return [JSON_COMPAT_BIGINT, input.toString()];
+  const result = [readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readString(bc);
   }
-  if (input instanceof ArrayBuffer) {
-    return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(input)];
+  return result;
+}
+function read5(bc) {
+  const len = readUintSafe(bc);
+  if (len === 0) {
+    return [];
   }
-  if (input instanceof Uint8Array) {
-    return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(input)];
+  const result = [readWorkflowEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readWorkflowEntry(bc);
   }
-  if (isTypedArray(input)) {
-    return input;
+  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));
   }
-  if (input instanceof Date || input instanceof RegExp || input instanceof Error) {
-    return input;
+  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");
   }
-  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 result;
+}
+function decodeWorkflowHistoryTransport(data) {
+  return decodeWorkflowHistory(toUint8Array(data));
+}
+
+// ../rivetkit/dist/tsup/chunk-QWLJCP3X.js
+function flattenActionHandlers(actions) {
+  const flattened = /* @__PURE__ */ Object.create(null);
+  for (const { name, handler } of collectActionEntries(actions)) {
+    flattened[name] = handler;
+  }
+  return flattened;
+}
+function flattenActionInputSchemas(actions, schemas) {
+  if (schemas === void 0) return void 0;
+  if (!isRecord(schemas)) {
+    throw new TypeError("actionInputSchemas must be an object");
+  }
+  const flattened = /* @__PURE__ */ Object.create(null);
+  for (const { name, path: path2 } of collectActionEntries(actions)) {
+    const nestedSchema = lookupNestedSchema(schemas, path2);
+    const flatSchema = schemas[name];
+    if (nestedSchema !== void 0 && flatSchema !== void 0 && nestedSchema !== flatSchema) {
+      throw new TypeError(
+        `Action input schema \`${name}\` is defined by both a nested path and a dotted key`
       );
     }
-    return encoded;
+    const schema = nestedSchema ?? flatSchema;
+    if (schema !== void 0) {
+      flattened[name] = schema;
+    }
   }
-  if (Array.isArray(input)) {
-    const encoded = input.map(
-      (value) => encodeJsonCompatValue(value)
+  return flattened;
+}
+function collectActionEntries(actions) {
+  const entries = [];
+  const names = /* @__PURE__ */ new Set();
+  visitActionGroup(actions ?? {}, [], entries, names);
+  return entries;
+}
+function visitActionGroup(value, path2, entries, names) {
+  if (!isRecord(value)) {
+    throw new TypeError(
+      `${formatActionPath(path2)} must be an action handler or group`
     );
-    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);
+  for (const [segment, child] of Object.entries(value)) {
+    const childPath = [...path2, segment];
+    if (typeof child === "function") {
+      const name = childPath.join(".");
+      if (names.has(name)) {
+        throw new TypeError(
+          `Multiple action definitions flatten to \`${name}\``
+        );
+      }
+      names.add(name);
+      entries.push({
+        name,
+        path: childPath,
+        handler: child
+      });
+    } else {
+      visitActionGroup(child, childPath, entries, names);
     }
-    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);
+function lookupNestedSchema(schemas, path2) {
+  let value = schemas;
+  for (const segment of path2) {
+    if (!isRecord(value) || !Object.hasOwn(value, segment)) {
+      return void 0;
     }
-    return input;
+    value = value[segment];
   }
-  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;
+  return value;
+}
+function isRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
   }
-  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.`
-      );
-    }
-    return input.map((value) => reviveJsonCompatValue(value, options));
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function formatActionPath(path2) {
+  return path2.length === 0 ? "actions" : `Action \`${path2.join(".")}\``;
+}
+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 zActionTree = external_exports.custom((value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
   }
-  if (isPlainObject2(input)) {
-    const decoded = {};
-    for (const [key, value] of Object.entries(input)) {
-      decoded[key] = reviveJsonCompatValue(value, options);
-    }
-    return decoded;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}).superRefine((actions, ctx) => {
+  try {
+    flattenActionHandlers(actions);
+  } catch (error46) {
+    ctx.addIssue({
+      code: "custom",
+      message: error46 instanceof Error ? error46.message : "Invalid action definition"
+    });
   }
-  return input;
+});
+var WorkflowInspectorConfigSchema = external_exports.object({
+  getHistory: zFunction(),
+  onHistoryUpdated: zFunction().optional(),
+  replayFromStep: zFunction().optional()
+});
+var RunInspectorConfigSchema = external_exports.object({
+  workflow: WorkflowInspectorConfigSchema.optional()
+}).optional();
+var BUILTIN_INSPECTOR_TAB_IDS = [
+  "workflow",
+  "database",
+  "state",
+  "queue",
+  "schedules",
+  "connections",
+  "console"
+];
+var BuiltinInspectorTabIdSchema = external_exports.enum(BUILTIN_INSPECTOR_TAB_IDS);
+var CUSTOM_INSPECTOR_TAB_ID_RE = /^[A-Za-z0-9_-]+$/;
+var CustomInspectorTabEntrySchema = external_exports.object({
+  id: external_exports.string().regex(
+    CUSTOM_INSPECTOR_TAB_ID_RE,
+    "inspector.tabs[].id must contain only letters, digits, underscore, or dash"
+  ),
+  label: external_exports.string().min(1),
+  source: external_exports.string().min(1),
+  /**
+   * Optional icon id. The dashboard maps strings to glyphs (see its
+   * icon registry); unknown ids fall back to a generic icon.
+   */
+  icon: external_exports.string().min(1).optional(),
+  hidden: external_exports.literal(false).optional()
+}).strict();
+var HideInspectorTabEntrySchema = external_exports.object({
+  id: BuiltinInspectorTabIdSchema,
+  hidden: external_exports.literal(true)
+}).strict();
+var InspectorTabEntrySchema = external_exports.union([
+  CustomInspectorTabEntrySchema,
+  HideInspectorTabEntrySchema
+]);
+var ActorInspectorConfigSchema = external_exports.object({
+  tabs: external_exports.array(InspectorTabEntrySchema).default(() => [])
+}).strict().refine(
+  (data) => {
+    const ids = data.tabs.map((t) => t.id);
+    return new Set(ids).size === ids.length;
+  },
+  { message: "Duplicate id in inspector.tabs", path: ["tabs"] }
+).refine(
+  (data) => {
+    const builtinSet = new Set(BUILTIN_INSPECTOR_TAB_IDS);
+    return data.tabs.every(
+      (t) => t.hidden === true || !builtinSet.has(t.id)
+    );
+  },
+  {
+    message: "Custom inspector tab id collides with a built-in (use hidden: true to hide a built-in)",
+    path: ["tabs"]
+  }
+);
+var RunConfigSchema = external_exports.object({
+  /** Display name for the actor in the Inspector UI. */
+  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(),
+  /** The run handler function. */
+  run: zFunction(),
+  /** Inspector integration for long-running run handlers. */
+  inspector: RunInspectorConfigSchema.optional()
+});
+var RUN_FUNCTION_CONFIG_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "rivetkit.run_function_config"
+);
+var zRunHandler = external_exports.union([zFunction(), RunConfigSchema]).optional();
+function getRunFunction(run) {
+  if (!run) return void 0;
+  if (typeof run === "function") return run;
+  return run.run;
+}
+function getRunMetadata(run) {
+  if (!run) return {};
+  if (typeof run === "function") {
+    const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
+    if (!config3) return {};
+    return { name: config3.name, icon: config3.icon };
+  }
+  return { name: run.name, icon: run.icon };
+}
+function getRunInspectorConfig(run, actor2) {
+  if (!run) return void 0;
+  if (typeof run === "function") {
+    const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
+    return (config3 == null ? void 0 : config3.inspectorFactory) ? config3.inspectorFactory(actor2) : config3 == null ? void 0 : config3.inspector;
+  }
+  return run.inspector;
+}
+function disposeRunInspector(run, actorId) {
+  var _a2;
+  if (!run || typeof run !== "function") {
+    return;
+  }
+  const config3 = run[RUN_FUNCTION_CONFIG_SYMBOL];
+  (_a2 = config3 == null ? void 0 : config3.disposeInspector) == null ? void 0 : _a2.call(config3, actorId);
+}
+var GlobalActorOptionsBaseSchema = external_exports.object({
+  /** Display name for the actor in the Inspector UI. */
+  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.
+   *
+   * WebSockets using actions/events are hibernatable by default.
+   *
+   * @experimental
+   **/
+  canHibernateWebSocket: external_exports.union([external_exports.boolean(), zFunction()]).default(false)
+}).strict();
+var GlobalActorOptionsSchema = GlobalActorOptionsBaseSchema.prefault(
+  () => ({})
+);
+var InstanceActorOptionsBaseSchema = external_exports.object({
+  createVarsTimeout: external_exports.number().positive().default(5e3),
+  createConnStateTimeout: external_exports.number().positive().default(5e3),
+  onBeforeConnectTimeout: external_exports.number().positive().default(5e3),
+  onConnectTimeout: external_exports.number().positive().default(5e3),
+  onMigrateTimeout: external_exports.number().positive().default(3e4),
+  sleepGracePeriod: external_exports.number().positive().default(DEFAULT_SLEEP_GRACE_PERIOD),
+  /** @deprecated `onDestroyTimeout` is folded into `sleepGracePeriod`, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0. */
+  onDestroyTimeout: external_exports.number().positive().optional(),
+  /** @deprecated `waitUntilTimeout` is folded into `sleepGracePeriod`, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0. */
+  waitUntilTimeout: external_exports.number().positive().optional(),
+  stateSaveInterval: external_exports.number().positive().default(1e3),
+  actionTimeout: external_exports.number().positive().default(6e4),
+  connectionLivenessTimeout: external_exports.number().positive().default(2500),
+  connectionLivenessInterval: external_exports.number().positive().default(5e3),
+  /** @deprecated Use `c.keepAwake(promise)` to scope keep-awake to a specific operation, or keep `noSleep` for actors that must stay awake indefinitely. Will be removed in 2.2.0. */
+  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),
+  /** @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(),
+  /** @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(() => ({}));
+var ActorOptionsSchema = GlobalActorOptionsBaseSchema.extend(
+  InstanceActorOptionsBaseSchema.shape
+).strict().prefault(() => ({}));
+var ActorConfigSchema = external_exports.object({
+  onCreate: zFunction().optional(),
+  onDestroy: zFunction().optional(),
+  onMigrate: zFunction().optional(),
+  onWake: zFunction().optional(),
+  onSleep: zFunction().optional(),
+  run: zRunHandler,
+  onStateChange: zFunction().optional(),
+  onBeforeConnect: zFunction().optional(),
+  onConnect: zFunction().optional(),
+  onDisconnect: zFunction().optional(),
+  onBeforeActionResponse: zFunction().optional(),
+  onRequest: zFunction().optional(),
+  onWebSocket: zFunction().optional(),
+  actions: zActionTree.default(() => ({})),
+  actionInputSchemas: external_exports.record(external_exports.string(), external_exports.any()).optional(),
+  connParamsSchema: external_exports.any().optional(),
+  events: external_exports.record(external_exports.string(), external_exports.any()).optional(),
+  queues: external_exports.record(external_exports.string(), external_exports.any()).optional(),
+  state: external_exports.any().optional(),
+  createState: zFunction().optional(),
+  connState: external_exports.any().optional(),
+  createConnState: zFunction().optional(),
+  vars: external_exports.any().optional(),
+  db: external_exports.any().optional(),
+  createVars: zFunction().optional(),
+  options: ActorOptionsSchema,
+  inspector: ActorInspectorConfigSchema.optional()
+}).strict().refine(
+  (data) => !(data.state !== void 0 && data.createState !== void 0),
+  {
+    message: "Cannot define both 'state' and 'createState'",
+    path: ["state"]
+  }
+).refine(
+  (data) => !(data.connState !== void 0 && data.createConnState !== void 0),
+  {
+    message: "Cannot define both 'connState' and 'createConnState'",
+    path: ["connState"]
+  }
+).refine(
+  (data) => !(data.vars !== void 0 && data.createVars !== void 0),
+  {
+    message: "Cannot define both 'vars' and 'createVars'",
+    path: ["vars"]
+  }
+);
+var DocActorOptionsSchema = external_exports.object({
+  name: external_exports.string().optional().describe("Display name for the actor in the Inspector UI."),
+  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"
+  ),
+  onMigrateTimeout: external_exports.number().optional().describe("Timeout in ms for onMigrate handler. Default: 30000"),
+  onBeforeConnectTimeout: external_exports.number().optional().describe(
+    "Timeout in ms for onBeforeConnect handler. Default: 5000"
+  ),
+  onConnectTimeout: external_exports.number().optional().describe("Timeout in ms for onConnect handler. Default: 5000"),
+  sleepGracePeriod: external_exports.number().optional().describe(
+    `Max time in ms for the graceful shutdown window. Covers lifecycle hooks (onSleep, onDestroy), the run handler wait, async raw WebSocket handlers, disconnect callbacks, and final state serialization. Default: ${DEFAULT_SLEEP_GRACE_PERIOD}.`
+  ),
+  onDestroyTimeout: external_exports.number().optional().describe(
+    "Deprecated. Folded into sleepGracePeriod, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0."
+  ),
+  waitUntilTimeout: external_exports.number().optional().describe(
+    "Deprecated. Folded into sleepGracePeriod, which now bounds the entire graceful shutdown window for both sleep and destroy. Will be removed in 2.2.0."
+  ),
+  stateSaveInterval: external_exports.number().optional().describe(
+    "Interval in ms between automatic state saves. Default: 1000"
+  ),
+  actionTimeout: external_exports.number().optional().describe("Timeout in ms for action handlers. Default: 60000"),
+  connectionLivenessTimeout: external_exports.number().optional().describe(
+    "Timeout in ms for connection liveness checks. Default: 2500"
+  ),
+  connectionLivenessInterval: external_exports.number().optional().describe(
+    "Interval in ms between connection liveness checks. Default: 5000"
+  ),
+  noSleep: external_exports.boolean().optional().describe(
+    "Deprecated. If true, the actor will never sleep. Use c.keepAwake(promise) to scope keep-awake to a specific operation instead. Default: false"
+  ),
+  sleepTimeout: external_exports.number().optional().describe(
+    "Time in ms of inactivity before the actor sleeps. Default: 30000"
+  ),
+  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"
+  )
+}).describe("Actor options for timeouts and behavior configuration.");
+var DocActorConfigSchema = external_exports.object({
+  state: external_exports.unknown().optional().describe(
+    "Initial state value for the actor. Cannot be used with createState."
+  ),
+  createState: external_exports.unknown().optional().describe(
+    "Function to create initial state. Receives context and input. Cannot be used with state."
+  ),
+  connState: external_exports.unknown().optional().describe(
+    "Initial connection state value. Cannot be used with createConnState."
+  ),
+  createConnState: external_exports.unknown().optional().describe(
+    "Function to create connection state. Receives context and connection params. The pending connection is not visible in c.conns until this succeeds. Cannot be used with connState."
+  ),
+  vars: external_exports.unknown().optional().describe(
+    "Initial ephemeral variables value. Cannot be used with createVars."
+  ),
+  createVars: external_exports.unknown().optional().describe(
+    "Function to create ephemeral variables. Receives context and driver context. Cannot be used with vars."
+  ),
+  db: external_exports.unknown().optional().describe("Database provider instance for the actor."),
+  onCreate: external_exports.unknown().optional().describe(
+    "Called when the actor is first initialized. Use to initialize state."
+  ),
+  onDestroy: external_exports.unknown().optional().describe("Called when the actor is destroyed."),
+  onMigrate: external_exports.unknown().optional().describe(
+    "Called on every actor start after persisted state loads and before onWake. Use for repeatable schema migrations."
+  ),
+  onWake: external_exports.unknown().optional().describe(
+    "Called when the actor wakes up and is ready to receive connections and actions."
+  ),
+  onSleep: external_exports.unknown().optional().describe(
+    "Called when the actor is stopping or sleeping. Use to clean up resources."
+  ),
+  run: external_exports.unknown().optional().describe(
+    "Called after actor starts. Does not block startup. Use for background tasks like queue processing or tick loops. If it exits, the actor follows the normal idle sleep timeout once idle. If it throws, the actor logs the error and then follows the normal idle sleep timeout once idle."
+  ),
+  onStateChange: external_exports.unknown().optional().describe(
+    "Called when the actor's state changes. State changes within this hook won't trigger recursion."
+  ),
+  onBeforeConnect: external_exports.unknown().optional().describe(
+    "Called before a client connects. Throw an error to reject the connection. The pending connection is not visible in c.conns while this runs."
+  ),
+  onConnect: external_exports.unknown().optional().describe(
+    "Called when a client successfully connects. The connection is visible in c.conns before this runs."
+  ),
+  onDisconnect: external_exports.unknown().optional().describe("Called when a client disconnects."),
+  onBeforeActionResponse: external_exports.unknown().optional().describe(
+    "Called before sending an action response. Use to transform output."
+  ),
+  onRequest: external_exports.unknown().optional().describe(
+    "Called for raw HTTP requests to /actors/{name}/http/* endpoints."
+  ),
+  onWebSocket: external_exports.unknown().optional().describe(
+    "Called for raw WebSocket connections to /actors/{name}/websocket/* endpoints."
+  ),
+  actions: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
+    "Tree of action names or nested groups to handler functions. Nested paths use dot-separated low-level action names. Defaults to an empty object."
+  ),
+  actionInputSchemas: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
+    "Optional schemas for validating action argument tuples in native runtimes. May mirror nested action groups or use dot-separated low-level action names."
+  ),
+  connParamsSchema: external_exports.unknown().optional().describe(
+    "Optional schema for validating connection params in native runtimes."
+  ),
+  events: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Map of event names to schemas."),
+  queues: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Map of queue names to schemas."),
+  options: DocActorOptionsSchema.optional()
+}).describe("Actor configuration passed to the actor() function.");
+
+// ../rivetkit/dist/tsup/chunk-JI6GZ2C2.js
+var EMPTY_KEY = "/";
+var KEY_SEPARATOR = "/";
+var KEYS = {
+  PERSIST_DATA: Uint8Array.from([1]),
+  CONN_PREFIX: Uint8Array.from([2]),
+  INSPECTOR_TOKEN: Uint8Array.from([3]),
+  KV: Uint8Array.from([4]),
+  QUEUE_PREFIX: Uint8Array.from([5]),
+  LAST_PUSHED_ALARM: Uint8Array.from([6]),
+  WORKFLOW_PREFIX: Uint8Array.from([6]),
+  TRACES_PREFIX: Uint8Array.from([7])
+};
+var STORAGE_VERSION = {
+  QUEUE: 1,
+  WORKFLOW: 1,
+  TRACES: 1
+};
+var STORAGE_VERSION_BYTES = {
+  QUEUE: Uint8Array.from([STORAGE_VERSION.QUEUE]),
+  WORKFLOW: Uint8Array.from([STORAGE_VERSION.WORKFLOW]),
+  TRACES: Uint8Array.from([STORAGE_VERSION.TRACES])
+};
+var QUEUE_NAMESPACE = {
+  METADATA: Uint8Array.from([1]),
+  MESSAGES: Uint8Array.from([2])
+};
+function concatPrefix(prefix, suffix) {
+  const merged = new Uint8Array(prefix.length + suffix.length);
+  merged.set(prefix, 0);
+  merged.set(suffix, prefix.length);
+  return merged;
 }
-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);
+var QUEUE_STORAGE_PREFIX = concatPrefix(
+  KEYS.QUEUE_PREFIX,
+  STORAGE_VERSION_BYTES.QUEUE
+);
+var QUEUE_METADATA_KEY = concatPrefix(
+  QUEUE_STORAGE_PREFIX,
+  QUEUE_NAMESPACE.METADATA
+);
+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;
   }
-  return bytes;
-}
-function base64DecodeToArrayBuffer(base643) {
-  return base64DecodeToUint8Array(base643).buffer;
-}
-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]];
+  const escapedParts = key.map((part) => {
+    if (part === "") {
+      return "\\0";
     }
-    return value;
+    let escaped = part.replace(/\\/g, "\\\\");
+    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
+    return escaped;
   });
+  return escapedParts.join(KEY_SEPARATOR);
 }
-function jsonParseCompat(input) {
-  return reviveJsonCompatValue(JSON.parse(input));
-}
-function uint8ArrayToBase642(uint8Array) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(uint8Array).toString("base64");
+function deserializeActorKey(keyString) {
+  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
+    return [];
   }
-  let binary = "";
-  const len = uint8Array.byteLength;
-  for (let i = 0; i < len; i++) {
-    binary += String.fromCharCode(uint8Array[i]);
+  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;
+    }
   }
-  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);
+  if (escaping) {
+    parts.push(`${currentPart}\\`);
+  } else if (isEmptyStringMarker) {
+    parts.push("");
+  } else if (currentPart !== "" || parts.length > 0) {
+    parts.push(currentPart);
   }
+  return parts;
 }
-function encodeCborCompat(value) {
-  return cbor.encode(encodeJsonCompatValue(value));
+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 decodeCborCompat(buffer) {
-  return reviveJsonCompatValue(cbor.decode(buffer));
+function removePrefixFromKey(prefixedKey) {
+  return prefixedKey.slice(KEYS.KV.length);
 }
-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");
+
+// ../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));
     }
-    const bareValue = toBare(value);
-    return versionedDataHandler.serializeWithEmbeddedVersion(
-      bareValue,
-      version2
-    );
-  } else {
-    assertUnreachable(encoding);
+    this.#locked = true;
   }
-}
-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);
+  release() {
+    this.#locked = false;
+    const next = this.#waiting.shift();
+    if (next) {
+      next();
     }
-    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-HTXJT6DN.js
+// ../rivetkit/dist/tsup/chunk-KUWK4UNH.js
 function logger() {
   return getLogger("actor-client");
 }
@@ -15390,50 +15535,22 @@ async function importWebSocket() {
         _WebSocket = ws.default;
         logger().debug("using websocket from npm");
       } catch {
-        _WebSocket = class MockWebSocket {
-          constructor() {
-            throw new Error(
-              'WebSocket support requires installing the "ws" peer dependency.'
-            );
-          }
-        };
-        logger().debug("using mock websocket");
-      }
-    }
-    return _WebSocket;
-  })();
-  return webSocketPromise;
-}
-
-// ../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));
-    }
-    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();
+        _WebSocket = class MockWebSocket {
+          constructor() {
+            throw new Error(
+              'WebSocket support requires installing the "ws" peer dependency.'
+            );
+          }
+        };
+        logger().debug("using mock websocket");
+      }
     }
-  }
-};
+    return _WebSocket;
+  })();
+  return webSocketPromise;
+}
 
-// ../rivetkit/dist/tsup/chunk-2Y5LK2Q3.js
+// ../rivetkit/dist/tsup/chunk-J2TA4HLA.js
 var import_invariant2 = __toESM(require_invariant(), 1);
 
 // ../../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
@@ -15611,7 +15728,7 @@ function createVersionedDataHandler(config3) {
   return new VersionedDataHandler(config3);
 }
 
-// ../rivetkit/dist/tsup/chunk-2Y5LK2Q3.js
+// ../rivetkit/dist/tsup/chunk-J2TA4HLA.js
 var import_invariant3 = __toESM(require_invariant(), 1);
 var import_invariant4 = __toESM(require_invariant(), 1);
 var PATH_CONNECT = "/connect";
@@ -15620,6 +15737,7 @@ var PATH_WEBSOCKET_PREFIX = "/websocket/";
 var HEADER_ACTOR_QUERY = "x-rivet-query";
 var HEADER_ENCODING = "x-rivet-encoding";
 var HEADER_CONN_PARAMS = "x-rivet-conn-params";
+var HEADER_ORIGINAL_REQUEST_URL = "x-rivet-internal-original-request-url";
 var HEADER_ACTOR_ID = "x-rivet-actor";
 var HEADER_ACTOR_GENERATION = "x-rivet-actor-generation";
 var HEADER_ACTOR_KEY = "x-rivet-actor-key";
@@ -17672,6 +17790,18 @@ async function checkForSchedulingError(group, code, actorId, query, driver) {
   }
   return null;
 }
+function isUrlLike(value) {
+  return typeof value === "object" && value !== null && typeof value.href === "string" && typeof value.pathname === "string" && typeof value.search === "string";
+}
+function isRequestLike(value) {
+  return typeof value === "object" && value !== null && typeof value.url === "string" && typeof value.method === "string" && isHeadersLike(value.headers);
+}
+function isResponseLike(value) {
+  return typeof value === "object" && value !== null && typeof value.status === "number" && isHeadersLike(value.headers) && typeof value.arrayBuffer === "function";
+}
+function isHeadersLike(value) {
+  return typeof value === "object" && value !== null && typeof value.entries === "function";
+}
 function* walkErrorChain(error46, maxDepth = 8) {
   let current = error46;
   let depth = 0;
@@ -18097,14 +18227,17 @@ function createQueueSender(senderOptions) {
 }
 async function rawHttpFetch(driver, target, params, input, init, options = {}) {
   let path2;
+  let originalUrl;
   let mergedInit = init || {};
   if (typeof input === "string") {
     path2 = input;
-  } else if (input instanceof URL) {
+  } else if (isUrlLike(input)) {
     path2 = input.pathname + input.search;
-  } else if (input instanceof Request) {
+    originalUrl = input.toString();
+  } else if (isRequestLike(input)) {
     const url2 = new URL(input.url);
     path2 = url2.pathname + url2.search;
+    originalUrl = url2.toString();
     const requestHeaders = new Headers(input.headers);
     const initHeaders = new Headers((init == null ? void 0 : init.headers) || {});
     const mergedHeaders = new Headers(requestHeaders);
@@ -18146,6 +18279,10 @@ async function rawHttpFetch(driver, target, params, input, init, options = {}) {
     const normalizedPath = path2.startsWith("/") ? path2.slice(1) : path2;
     const url2 = new URL(`http://actor/request/${normalizedPath}`);
     const proxyRequestHeaders = new Headers(mergedInit.headers);
+    proxyRequestHeaders.delete(HEADER_ORIGINAL_REQUEST_URL);
+    if (originalUrl) {
+      proxyRequestHeaders.set(HEADER_ORIGINAL_REQUEST_URL, originalUrl);
+    }
     if (params) {
       proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
     }
@@ -18614,6 +18751,7 @@ var ActorHandleRaw = class {
   async #fetchWithResolvedActor(input, init) {
     const maxAttempts = this.#getDynamicQueryMaxAttempts();
     let useQueryTarget = false;
+    const retryableRequest = isRequestLike(input) ? input.clone() : void 0;
     const { skipReadyWait, ...requestInit } = init ?? {};
     const gatewayOptions = resolveActorGatewayOptions(
       this.#gatewayOptions,
@@ -18633,7 +18771,7 @@ var ActorHandleRaw = class {
           this.#driver,
           target,
           this.#params,
-          input,
+          retryableRequest ? retryableRequest.clone() : input,
           requestInit,
           gatewayOptions
         );
@@ -19058,6 +19196,23 @@ function createClientWithDriver(driver, config3 = {}) {
 }
 function createActorProxy(handle) {
   const methodCache = /* @__PURE__ */ new Map();
+  const actionPath = (name) => {
+    let method2 = methodCache.get(name);
+    if (method2) return method2;
+    method2 = new Proxy(
+      (...args) => handle.action({ name, args }),
+      {
+        get(target, prop) {
+          if (typeof prop === "symbol")
+            return Reflect.get(target, prop);
+          if (prop === "then") return void 0;
+          return actionPath(`${name}.${prop}`);
+        }
+      }
+    );
+    methodCache.set(name, method2);
+    return method2;
+  };
   return new Proxy(handle, {
     get(target, prop, receiver) {
       if (typeof prop === "symbol") {
@@ -19072,12 +19227,7 @@ function createActorProxy(handle) {
       }
       if (typeof prop === "string") {
         if (prop === "then") return void 0;
-        let method2 = methodCache.get(prop);
-        if (!method2) {
-          method2 = (...args) => target.action({ name: prop, args });
-          methodCache.set(prop, method2);
-        }
-        return method2;
+        return actionPath(prop);
       }
     },
     // Support for 'in' operator
@@ -19095,6 +19245,7 @@ function createActorProxy(handle) {
     },
     // Support proper property descriptors
     getOwnPropertyDescriptor(target, prop) {
+      if (prop === "then") return void 0;
       const targetDescriptor = Reflect.getOwnPropertyDescriptor(
         target,
         prop
@@ -19107,7 +19258,7 @@ function createActorProxy(handle) {
           configurable: true,
           enumerable: false,
           writable: false,
-          value: (...args) => target.action({ name: prop, args })
+          value: actionPath(prop)
         };
       }
       return void 0;
@@ -20343,103 +20494,6 @@ function convertRegistryConfigToClientConfig(config3) {
     devtools: typeof window !== "undefined" && (((_a2 = window == null ? void 0 : window.location) == null ? void 0 : _a2.hostname) === "127.0.0.1" || ((_b = window == null ? void 0 : window.location) == null ? void 0 : _b.hostname) === "localhost")
   };
 }
-function logger2() {
-  return getLogger("engine-client");
-}
-function getEndpoint(config3) {
-  return config3.endpoint ?? "http://127.0.0.1:6420";
-}
-async function apiCall(config3, method2, path2, body) {
-  const endpoint = getEndpoint(config3);
-  const url2 = combineUrlPath(endpoint, path2, {
-    namespace: config3.namespace
-  });
-  logger2().debug({ msg: "making api call", method: method2, url: url2 });
-  const headers = {
-    ...config3.headers
-  };
-  if (config3.token) {
-    headers.Authorization = `Bearer ${config3.token}`;
-  }
-  return await sendHttpRequest({
-    method: method2,
-    url: url2,
-    headers,
-    body,
-    encoding: "json",
-    skipParseResponse: false,
-    requestVersionedDataHandler: void 0,
-    requestVersion: void 0,
-    responseVersionedDataHandler: void 0,
-    responseVersion: void 0,
-    requestZodSchema: external_exports.any(),
-    responseZodSchema: external_exports.any(),
-    // Identity conversions (passthrough for generic API calls)
-    requestToJson: (value) => value,
-    requestToBare: (value) => value,
-    responseFromJson: (value) => value,
-    responseFromBare: (value) => value
-  });
-}
-async function getActor(config3, _, actorId) {
-  return apiCall(
-    config3,
-    "GET",
-    `/actors?actor_ids=${encodeURIComponent(actorId)}`
-  );
-}
-async function getActorByKey(config3, name, key) {
-  const serializedKey = serializeActorKey(key);
-  return apiCall(
-    config3,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
-  );
-}
-async function listActorsByName(config3, name) {
-  return apiCall(
-    config3,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}`
-  );
-}
-async function getOrCreateActor(config3, request) {
-  return apiCall(
-    config3,
-    "PUT",
-    `/actors`,
-    request
-  );
-}
-async function createActor(config3, request) {
-  return apiCall(
-    config3,
-    "POST",
-    `/actors`,
-    request
-  );
-}
-async function destroyActor(config3, actorId) {
-  return apiCall(
-    config3,
-    "DELETE",
-    `/actors/${encodeURIComponent(actorId)}`
-  );
-}
-async function getMetadata(config3) {
-  return apiCall(config3, "GET", `/metadata`);
-}
-async function getDatacenters(config3) {
-  return apiCall(config3, "GET", `/datacenters`);
-}
-async function updateRunnerConfig(config3, runnerName, request) {
-  return apiCall(
-    config3,
-    "PUT",
-    `/runner-configs/${runnerName}`,
-    request
-  );
-}
 function shouldSkipReadyWait(options = {}) {
   return options.skipReadyWait === true;
 }
@@ -20450,23 +20504,19 @@ async function sendHttpRequestToGateway(runConfig, gatewayUrl, actorRequest, opt
     if (actorRequest.bodyUsed) {
       throw new Error("Request body has already been consumed");
     }
-    const reqBody = await actorRequest.arrayBuffer();
-    if (reqBody.byteLength !== 0) {
-      bodyToSend = reqBody;
+    if (actorRequest.body) {
+      bodyToSend = actorRequest.body;
       guardHeaders.delete("transfer-encoding");
       guardHeaders.delete("content-length");
     }
   }
-  const guardRequest = new Request(gatewayUrl, {
+  return fetch(gatewayUrl, {
     method: actorRequest.method,
     headers: guardHeaders,
     body: bodyToSend,
-    signal: actorRequest.signal
+    signal: actorRequest.signal,
+    ...bodyToSend ? { duplex: "half" } : {}
   });
-  return mutableResponse(await fetch(guardRequest));
-}
-function mutableResponse(fetchRes) {
-  return new Response(fetchRes.body, fetchRes);
 }
 function buildGuardHeaders(runConfig, actorRequest, options) {
   const headers = new Headers();
@@ -20527,6 +20577,9 @@ function setRemoteHibernatableWebSocketAckTestHooks(websocket, token, enabled) {
     enabled
   );
 }
+function logger2() {
+  return getLogger("engine-client");
+}
 var BufferedRemoteWebSocket = class {
   CONNECTING = 0;
   OPEN = 1;
@@ -20804,6 +20857,100 @@ function buildWebSocketProtocols(runConfig, encoding, params, ackHookToken, targ
   }
   return protocols;
 }
+function getEndpoint(config3) {
+  return config3.endpoint ?? "http://127.0.0.1:6420";
+}
+async function apiCall(config3, method2, path2, body) {
+  const endpoint = getEndpoint(config3);
+  const url2 = combineUrlPath(endpoint, path2, {
+    namespace: config3.namespace
+  });
+  logger2().debug({ msg: "making api call", method: method2, url: url2 });
+  const headers = {
+    ...config3.headers
+  };
+  if (config3.token) {
+    headers.Authorization = `Bearer ${config3.token}`;
+  }
+  return await sendHttpRequest({
+    method: method2,
+    url: url2,
+    headers,
+    body,
+    encoding: "json",
+    skipParseResponse: false,
+    requestVersionedDataHandler: void 0,
+    requestVersion: void 0,
+    responseVersionedDataHandler: void 0,
+    responseVersion: void 0,
+    requestZodSchema: external_exports.any(),
+    responseZodSchema: external_exports.any(),
+    // Identity conversions (passthrough for generic API calls)
+    requestToJson: (value) => value,
+    requestToBare: (value) => value,
+    responseFromJson: (value) => value,
+    responseFromBare: (value) => value
+  });
+}
+async function getActor(config3, _, actorId) {
+  return apiCall(
+    config3,
+    "GET",
+    `/actors?actor_ids=${encodeURIComponent(actorId)}`
+  );
+}
+async function getActorByKey(config3, name, key) {
+  const serializedKey = serializeActorKey(key);
+  return apiCall(
+    config3,
+    "GET",
+    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
+  );
+}
+async function listActorsByName(config3, name) {
+  return apiCall(
+    config3,
+    "GET",
+    `/actors?name=${encodeURIComponent(name)}`
+  );
+}
+async function getOrCreateActor(config3, request) {
+  return apiCall(
+    config3,
+    "PUT",
+    `/actors`,
+    request
+  );
+}
+async function createActor(config3, request) {
+  return apiCall(
+    config3,
+    "POST",
+    `/actors`,
+    request
+  );
+}
+async function destroyActor(config3, actorId) {
+  return apiCall(
+    config3,
+    "DELETE",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+async function getMetadata(config3) {
+  return apiCall(config3, "GET", `/metadata`);
+}
+async function getDatacenters(config3) {
+  return apiCall(config3, "GET", `/datacenters`);
+}
+async function updateRunnerConfig(config3, runnerName, request) {
+  return apiCall(
+    config3,
+    "PUT",
+    `/runner-configs/${runnerName}`,
+    request
+  );
+}
 var metadataLookupCache = /* @__PURE__ */ new Map();
 async function lookupMetadataCached(config3) {
   const endpoint = getEndpoint(config3);
@@ -22563,6 +22710,8 @@ function actor(input) {
     input == null ? void 0 : input.options
   );
   const config3 = ActorConfigSchema.parse(input);
+  flattenActionHandlers(config3.actions);
+  flattenActionInputSchemas(config3.actions, config3.actionInputSchemas);
   return new ActorDefinition(config3);
 }
 function isStaticActorDefinition(definition) {
@@ -23219,7 +23368,7 @@ var RegistryConfigSchema = external_exports.object({
     config3.engineHost,
     config3.enginePort
   );
-  const endpoint = config3.startEngine ? localEngineEndpoint : (parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint) ?? (isDevEnv ? buildEngineEndpoint(ENGINE_HOST, ENGINE_PORT) : void 0);
+  const endpoint = config3.startEngine ? localEngineEndpoint : (parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint) ?? (isDevEnv ? localEngineEndpoint : void 0);
   const validateServerlessEndpoint = Boolean(
     config3.startEngine || parsedEndpoint
   );
@@ -23236,7 +23385,7 @@ var RegistryConfigSchema = external_exports.object({
       path: ["serverless", "publicEndpoint"]
     });
   }
-  const publicEndpoint = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.endpoint) ?? (isDevEnv && config3.startEngine ? endpoint : void 0);
+  const publicEndpoint = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.endpoint) ?? (isDevEnv && !parsedEndpoint ? endpoint : void 0);
   const publicNamespace = parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.namespace;
   const publicToken = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.token) ?? config3.serverless.publicToken;
   return {
@@ -23842,6 +23991,36 @@ function toNapiSqlBatchStatement(statement) {
 function toNapiBuffer(value) {
   return Buffer.from(value);
 }
+function toNapiApplication(application) {
+  return async (error46, request) => {
+    if (error46) throw error46;
+    if (!request) {
+      throw new Error("application fetch callback received no request");
+    }
+    const response = await application(
+      {
+        ...request,
+        body: new Uint8Array(request.body),
+        cancelToken: request.cancelToken
+      },
+      request.responseBodyStream ? fromNapiHttpResponseBodyStream(
+        request.responseBodyStream
+      ) : void 0
+    );
+    return {
+      ...response,
+      body: response.body === void 0 ? void 0 : toNapiBuffer(response.body)
+    };
+  };
+}
+function fromNapiHttpResponseBodyStream(stream) {
+  return {
+    cancelled: () => stream.cancelled(),
+    write: (chunk) => stream.write(Buffer.from(chunk)),
+    end: () => stream.end(),
+    error: (message) => stream.error(message)
+  };
+}
 function toNapiHttpRequest(request) {
   if (!request) {
     return request;
@@ -23906,6 +24085,9 @@ var NapiCoreRuntime = class {
   async serveRegistry(registry2, config3) {
     await asNativeRegistry(registry2).serve(config3);
   }
+  async waitRegistryReady(registry2) {
+    await asNativeRegistry(registry2).waitReady();
+  }
   async shutdownRegistry(registry2) {
     await asNativeRegistry(registry2).shutdown();
   }
@@ -23945,12 +24127,25 @@ var NapiCoreRuntime = class {
     );
   }
   async serveListener(registry2, listener, config3) {
+    const application = listener.application ? toNapiApplication(listener.application) : void 0;
     await asNativeRegistry(registry2).serveListener(
       {
         port: listener.port,
         host: listener.host,
         publicDir: listener.publicDir
       },
+      config3,
+      application
+    );
+  }
+  async serveApplicationListener(registry2, listener, config3) {
+    await asNativeRegistry(registry2).serveApplicationListener(
+      {
+        port: listener.port,
+        host: listener.host,
+        publicDir: listener.publicDir
+      },
+      toNapiApplication(listener.application),
       config3
     );
   }
@@ -24247,17 +24442,57 @@ var NapiCoreRuntime = class {
   actorQueueMaxSize(ctx) {
     return asNativeActorContext(ctx).queue().maxSize();
   }
-  async actorQueueInspectMessages(ctx) {
-    return await asNativeActorContext(ctx).queue().inspectMessages();
+  async actorQueueInspectMessages(ctx) {
+    return await asNativeActorContext(ctx).queue().inspectMessages();
+  }
+  async actorQueueReset(ctx) {
+    await asNativeActorContext(ctx).queue().reset();
+  }
+  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;
   }
-  async actorQueueReset(ctx) {
-    await asNativeActorContext(ctx).queue().reset();
+  async actorCronList(ctx) {
+    return await asNativeActorContext(ctx).schedule().cronList();
   }
-  actorScheduleAfter(ctx, durationMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().after(durationMs, actionName, toNapiBuffer(args));
+  async actorCronDelete(ctx, name) {
+    return await asNativeActorContext(ctx).schedule().cronDelete(name);
   }
-  actorScheduleAt(ctx, timestampMs, actionName, args) {
-    asNativeActorContext(ctx).schedule().at(timestampMs, actionName, toNapiBuffer(args));
+  async actorCronHistory(ctx, name, limit) {
+    return await asNativeActorContext(ctx).schedule().cronHistory(name, limit);
   }
   connId(conn) {
     return asNativeConn(conn).id();
@@ -24297,6 +24532,135 @@ async function loadNapiRuntime() {
     runtime: new NapiCoreRuntime(bindings)
   };
 }
+var HTTP_BODY_CHUNK_SIZE = 64 * 1024;
+function runtimeBytesToArrayBuffer(value) {
+  return value.buffer.slice(
+    value.byteOffset,
+    value.byteOffset + value.byteLength
+  );
+}
+function buildNativeHttpRequest(init) {
+  var _a2;
+  const headers = new Headers(init.headers);
+  const originalUrl = headers.get(HEADER_ORIGINAL_REQUEST_URL);
+  headers.delete(HEADER_ORIGINAL_REQUEST_URL);
+  const url2 = originalUrl ?? (init.uri.startsWith("http") ? init.uri : new URL(init.uri, "http://127.0.0.1").toString());
+  const method2 = init.method.toUpperCase();
+  const bodyForbidden = method2 === "GET" || method2 === "HEAD";
+  const body = bodyForbidden ? void 0 : init.bodyStream ? new ReadableStream({
+    async pull(controller) {
+      var _a22, _b;
+      try {
+        if (init.body && init.body.length > 0) {
+          controller.enqueue(new Uint8Array(init.body));
+          init.body = void 0;
+          return;
+        }
+        const chunk = await ((_a22 = init.bodyStream) == null ? void 0 : _a22.read());
+        if (!chunk) {
+          controller.close();
+        } else {
+          controller.enqueue(new Uint8Array(chunk));
+        }
+      } catch (error46) {
+        (_b = init.abortController) == null ? void 0 : _b.abort(error46);
+        controller.error(error46);
+      }
+    },
+    async cancel() {
+      var _a22;
+      await ((_a22 = init.bodyStream) == null ? void 0 : _a22.cancel());
+    }
+  }) : init.body && init.body.length > 0 ? runtimeBytesToArrayBuffer(init.body) : void 0;
+  const streamInit = init.bodyStream && !bodyForbidden ? { duplex: "half" } : {};
+  return new Request(url2, {
+    method: method2,
+    headers,
+    body,
+    signal: ((_a2 = init.abortController) == null ? void 0 : _a2.signal) ?? init.signal,
+    ...streamInit
+  });
+}
+async function cancelNativeHttpRequestBody(bodyStream) {
+  await (bodyStream == null ? void 0 : bodyStream.cancel());
+}
+async function writeResponseChunk(stream, chunk) {
+  for (let offset = 0; offset < chunk.byteLength; offset += HTTP_BODY_CHUNK_SIZE) {
+    await stream.write(
+      chunk.subarray(offset, offset + HTTP_BODY_CHUNK_SIZE)
+    );
+  }
+}
+async function pumpResponseBody(reader, stream) {
+  var _a2;
+  const cancelled = stream.cancelled().then(() => ({ cancelled: true }));
+  try {
+    for (; ; ) {
+      const read = reader.read().then((next2) => ({ cancelled: false, next: next2 }));
+      const result = await Promise.race([read, cancelled]);
+      if (result.cancelled) {
+        await reader.cancel(
+          new Error("native http response stream receiver dropped")
+        );
+        return;
+      }
+      const { next } = result;
+      if (next.done) {
+        await stream.end();
+        return;
+      }
+      if ((_a2 = next.value) == null ? void 0 : _a2.byteLength) {
+        await writeResponseChunk(stream, next.value);
+      }
+    }
+  } catch (error46) {
+    try {
+      await stream.error(stringifyError(error46));
+    } catch (streamError) {
+      logger22().debug({
+        msg: "failed to report native http response stream error",
+        error: streamError
+      });
+    }
+    try {
+      await reader.cancel(error46);
+    } catch {
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function convertNativeHttpResponse(response, responseBodyStream) {
+  const headers = Object.fromEntries(response.headers.entries());
+  if (!response.body) {
+    return {
+      response: {
+        status: response.status,
+        headers,
+        body: new Uint8Array()
+      }
+    };
+  }
+  if (responseBodyStream) {
+    const reader = response.body.getReader();
+    const bodyCompletion = pumpResponseBody(reader, responseBodyStream);
+    return {
+      response: {
+        status: response.status,
+        headers,
+        stream: true
+      },
+      bodyCompletion
+    };
+  }
+  return {
+    response: {
+      status: response.status,
+      headers,
+      body: new Uint8Array(await response.arrayBuffer())
+    }
+  };
+}
 var CONN_PARAMS_KEY = "__conn_params__";
 function validateActionArgs(schemas, name, args) {
   if (!(schemas == null ? void 0 : schemas[name])) {
@@ -24530,6 +24894,11 @@ var WasmCoreRuntime = class {
   async serveRegistry(registry2, config3) {
     await callWasm(() => asWasmRegistry(registry2).serve(config3));
   }
+  async waitRegistryReady() {
+    throw new Error(
+      "registry.startAndWait() is not supported by the WASM runtime"
+    );
+  }
   async shutdownRegistry(registry2) {
     await callWasm(() => asWasmRegistry(registry2).shutdown());
   }
@@ -24561,6 +24930,11 @@ var WasmCoreRuntime = class {
       "registry.listen() is not supported on the wasm runtime; use registry.serve() and mount the handler in your platform's HTTP server instead"
     );
   }
+  async serveApplicationListener(_registry, _listener, _config) {
+    throw new Error(
+      "registry.listen() is not supported on the wasm runtime; use an application-owned HTTP server instead"
+    );
+  }
   createActorFactory(callbacks, config3) {
     return callWasmSync(
       () => asActorFactoryHandle2(
@@ -24950,13 +25324,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");
+    return await callHandleAsync(
+      schedule,
+      "cronList"
+    );
+  }
+  async actorCronDelete(ctx, name) {
     const schedule = childHandle(asWasmActorContext(ctx), "schedule");
-    callHandle(schedule, "after", wasmNumber(durationMs), actionName, args);
+    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");
@@ -25329,7 +25787,7 @@ function toRuntimeBytes(value) {
 function arrayBufferViewToRuntimeBytes(value) {
   return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
 }
-function runtimeBytesToArrayBuffer(value) {
+function runtimeBytesToArrayBuffer2(value) {
   return value.buffer.slice(
     value.byteOffset,
     value.byteOffset + value.byteLength
@@ -25659,24 +26117,6 @@ function decodeArgs(value) {
   const decoded = decodeValue(value);
   return normalizeArgs(decoded);
 }
-function buildRequest(init) {
-  const url2 = init.uri.startsWith("http") ? init.uri : new URL(init.uri, "http://127.0.0.1").toString();
-  const body = init.body && init.body.length > 0 ? runtimeBytesToArrayBuffer(init.body) : void 0;
-  return new Request(url2, {
-    method: init.method,
-    headers: init.headers,
-    body
-  });
-}
-async function toRuntimeHttpResponse(response) {
-  const headers = Object.fromEntries(response.headers.entries());
-  const body = new Uint8Array(await response.arrayBuffer());
-  return {
-    status: response.status,
-    headers,
-    body
-  };
-}
 function toActorKey(segments) {
   return segments.map(
     (segment) => segment.kind === "number" ? String(segment.numberValue ?? 0) : segment.stringValue ?? ""
@@ -25801,26 +26241,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;
@@ -26251,7 +26781,7 @@ var NativeWebSocketAdapter = class {
     this.#runtime.webSocketSetEventCallback(this.#ws, (event2) => {
       if (event2.kind === "message") {
         this.#virtual.triggerMessage(
-          event2.binary ? runtimeBytesToArrayBuffer(event2.data) : event2.data,
+          event2.binary ? runtimeBytesToArrayBuffer2(event2.data) : event2.data,
           event2.messageIndex
         );
         return;
@@ -26601,6 +27131,7 @@ var ActorContextHandleAdapter = class {
   #client;
   #clientFactory;
   #connMap;
+  #cron;
   #databaseProvider;
   #db;
   #dispatchCancelToken;
@@ -26735,6 +27266,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));
   }
@@ -27332,12 +27869,13 @@ 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,
     preloadMaxWorkflowBytes: options.preloadMaxWorkflowBytes,
     preloadMaxConnectionsBytes: options.preloadMaxConnectionsBytes,
-    actions: Object.keys(config3.actions ?? {}).sort().map((name) => ({ name })),
+    actions: Object.keys(flattenActionHandlers(config3.actions)).sort().map((name) => ({ name })),
     inspectorTabs: buildInspectorTabs(config3.inspector, runtimeKind)
   };
 }
@@ -27414,15 +27952,16 @@ function buildNativeFactory(runtime, registryConfig, definition) {
   var _a2;
   const config3 = definition.config;
   const databaseProvider = config3.db;
+  const actionHandlers = flattenActionHandlers(config3.actions);
   const schemaConfig = {
-    actionInputSchemas: config3.actionInputSchemas,
+    actionInputSchemas: flattenActionInputSchemas(
+      config3.actions,
+      config3.actionInputSchemas
+    ),
     connParamsSchema: config3.connParamsSchema,
     events: config3.events,
     queues: config3.queues
   };
-  const actionHandlers = Object.fromEntries(
-    Object.entries(config3.actions ?? {}).map(([name, handler]) => [name, handler])
-  );
   const createClient = () => createClientWithDriver(
     new RemoteEngineControlClient(
       convertRegistryConfigToClientConfig(registryConfig)
@@ -27474,12 +28013,14 @@ function buildNativeFactory(runtime, registryConfig, definition) {
     onStateChange,
     cancelToken
   );
-  const maybeHandleNativeInspectorRequest = async (ctx, _rawRequest, jsRequest) => {
+  const maybeHandleNativeInspectorRequest = async (ctx, rawRequest) => {
     var _a22, _b, _c, _d;
-    const url2 = new URL(jsRequest.url);
+    const rawUrl = rawRequest.uri.startsWith("http") ? rawRequest.uri : new URL(rawRequest.uri, "http://127.0.0.1").toString();
+    const url2 = new URL(rawUrl);
     if (!url2.pathname.startsWith("/inspector/")) {
       return void 0;
     }
+    const jsRequest = buildNativeHttpRequest(rawRequest);
     const jsonResponse = (body, init) => new Response(JSON.stringify(body), {
       status: (init == null ? void 0 : init.status) ?? 200,
       headers: {
@@ -28010,7 +28551,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
         );
         const actorCtx = makeActorCtx(
           ctx,
-          request ? buildRequest(request) : void 0
+          request ? buildNativeHttpRequest(request) : void 0
         );
         try {
           await config3.onBeforeConnect(
@@ -28030,7 +28571,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
         const { ctx, conn, params, request } = unwrapTsfnPayload(error46, payload);
         const actorCtx = makeActorCtx(
           ctx,
-          request ? buildRequest(request) : void 0
+          request ? buildNativeHttpRequest(request) : void 0
         );
         const connAdapter = new NativeConnAdapter(
           runtime,
@@ -28067,7 +28608,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
         );
         const actorCtx = makeActorCtx(
           ctx,
-          request ? buildRequest(request) : void 0
+          request ? buildNativeHttpRequest(request) : void 0
         );
         const connAdapter = new NativeConnAdapter(
           runtime,
@@ -28172,27 +28713,45 @@ function buildNativeFactory(runtime, registryConfig, definition) {
     onRequest: wrapNativeCallback(
       async (error46, payload) => {
         try {
-          const { ctx, request, cancelToken } = unwrapTsfnPayload(
-            error46,
-            payload
-          );
-          const jsRequest = buildRequest(request);
-          const inspectorResponse = await maybeHandleNativeInspectorRequest(
-            ctx,
-            request,
-            jsRequest
-          );
+          const { ctx, request, cancelToken, responseBodyStream } = unwrapTsfnPayload(error46, payload);
+          const inspectorResponse = await maybeHandleNativeInspectorRequest(ctx, request);
           if (inspectorResponse) {
-            return await toRuntimeHttpResponse(inspectorResponse);
+            await cancelNativeHttpRequestBody(request.bodyStream);
+            return (await convertNativeHttpResponse(
+              inspectorResponse,
+              responseBodyStream
+            )).response;
           }
           if (typeof config3.onRequest !== "function") {
-            return await toRuntimeHttpResponse(
-              new Response(null, { status: 404 })
-            );
+            await cancelNativeHttpRequestBody(request.bodyStream);
+            return (await convertNativeHttpResponse(
+              new Response(null, { status: 404 }),
+              responseBodyStream
+            )).response;
           }
-          const rawConnParams = jsRequest.headers.get(HEADER_CONN_PARAMS);
+          const requestAbortController = new AbortController();
+          const handlerRequest = buildNativeHttpRequest({
+            ...request,
+            abortController: requestAbortController
+          });
+          const rawConnParams = handlerRequest.headers.get(HEADER_CONN_PARAMS);
           let requestCtx;
           let conn;
+          let removeRequestAbortListener;
+          let cleanupDeferredToBody = false;
+          let cleanedUp = false;
+          const cleanupRequest = async () => {
+            if (cleanedUp) return;
+            cleanedUp = true;
+            removeRequestAbortListener == null ? void 0 : removeRequestAbortListener();
+            try {
+              await (requestCtx == null ? void 0 : requestCtx.dispose());
+            } finally {
+              if (conn) {
+                await runtime.connDisconnect(conn);
+              }
+            }
+          };
           try {
             const connParams = validateConnParams(
               schemaConfig.connParamsSchema,
@@ -28208,23 +28767,56 @@ function buildNativeFactory(runtime, registryConfig, definition) {
             requestCtx = makeConnCtx(
               ctx,
               conn,
-              jsRequest,
+              handlerRequest,
               cancelToken
             );
+            const ctxAbortSignal = requestCtx.abortSignal;
+            const abortRequest = () => requestAbortController.abort(ctxAbortSignal.reason);
+            if (ctxAbortSignal.aborted) {
+              abortRequest();
+            } else {
+              ctxAbortSignal.addEventListener(
+                "abort",
+                abortRequest,
+                { once: true }
+              );
+              removeRequestAbortListener = () => ctxAbortSignal.removeEventListener(
+                "abort",
+                abortRequest
+              );
+            }
             const response = await config3.onRequest(
               requestCtx,
-              jsRequest
+              handlerRequest
             );
-            if (!(response instanceof Response)) {
+            if (!isResponseLike(response)) {
               throw new Error(
                 "onRequest handler must return a Response"
               );
             }
-            return await toRuntimeHttpResponse(response);
+            const conversion = await convertNativeHttpResponse(
+              response,
+              responseBodyStream
+            );
+            if (conversion.bodyCompletion) {
+              cleanupDeferredToBody = true;
+              void conversion.bodyCompletion.then(cleanupRequest).catch((cleanupError) => {
+                logger22().error({
+                  msg: "failed to clean up native streaming http request",
+                  error: cleanupError
+                });
+              });
+            }
+            return conversion.response;
           } finally {
-            await (requestCtx == null ? void 0 : requestCtx.dispose());
-            if (conn) {
-              await runtime.connDisconnect(conn);
+            try {
+              await cancelNativeHttpRequestBody(
+                request.bodyStream
+              );
+            } finally {
+              if (!cleanupDeferredToBody) {
+                await cleanupRequest();
+              }
             }
           }
         } catch (error210) {
@@ -28239,7 +28831,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
     onWebSocket: typeof config3.onWebSocket === "function" ? wrapNativeCallback(
       async (error46, payload) => {
         const { ctx, conn, ws, request } = unwrapTsfnPayload(error46, payload);
-        const jsRequest = request ? buildRequest(request) : void 0;
+        const jsRequest = request ? buildNativeHttpRequest(request) : void 0;
         const actorCtx = makeConnCtx(ctx, conn, jsRequest);
         try {
           await config3.onWebSocket(
@@ -28303,7 +28895,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(
@@ -28313,7 +28905,8 @@ function buildNativeFactory(runtime, registryConfig, definition) {
                     schemaConfig.actionInputSchemas,
                     name,
                     decodeArgs(args)
-                  )
+                  ),
+                  ...scheduledFire ? [scheduledFire] : []
                 )
               );
             } finally {
@@ -28335,7 +28928,7 @@ function buildNativeFactory(runtime, registryConfig, definition) {
           timeoutMs,
           cancelToken
         } = unwrapTsfnPayload(error46, payload);
-        const jsRequest = buildRequest(request);
+        const jsRequest = buildNativeHttpRequest(request);
         const actorCtx = withConnContext(
           runtime,
           ctx,
@@ -28469,6 +29062,7 @@ async function buildConfiguredRegistry(config3) {
     runtime
   );
 }
+var REGISTRY_READY_TIMEOUT_MS = 3e4;
 function signalExitCode(signal) {
   switch (signal) {
     case "SIGINT":
@@ -28483,6 +29077,54 @@ function finishShutdownSignal(signal) {
   }
   process.kill(process.pid, signal);
 }
+function createApplicationFetch(application, runtime) {
+  return async (request, responseBodyStream) => {
+    const method2 = request.method.toUpperCase();
+    const body = method2 === "GET" || method2 === "HEAD" || request.body.length === 0 ? void 0 : Uint8Array.from(request.body).buffer;
+    const abortController = new AbortController();
+    if (request.cancelToken) {
+      if (runtime.cancellationTokenAborted(request.cancelToken)) {
+        abortController.abort();
+      } else {
+        runtime.onCancellationTokenCancelled(
+          request.cancelToken,
+          () => abortController.abort()
+        );
+      }
+    }
+    const response = await application.fetch(
+      new Request(request.url, {
+        method: method2,
+        headers: request.headers,
+        body,
+        signal: abortController.signal
+      })
+    );
+    if (!isResponseLike(response)) {
+      throw new TypeError(
+        "registry.listen() application fetch must return a Response"
+      );
+    }
+    const conversion = await convertNativeHttpResponse(
+      response,
+      responseBodyStream
+    );
+    if (conversion.bodyCompletion) {
+      void conversion.bodyCompletion.catch((error46) => {
+        logger22().error({
+          msg: "application response stream failed",
+          error: error46
+        });
+      });
+    }
+    return {
+      status: conversion.response.status ?? response.status,
+      headers: conversion.response.headers ?? Object.fromEntries(response.headers.entries()),
+      body: conversion.response.body,
+      stream: conversion.response.stream
+    };
+  };
+}
 var Registry = class {
   #config;
   #buildConfiguredRegistry;
@@ -28494,8 +29136,11 @@ var Registry = class {
     return RegistryConfigSchema.parse(this.#config);
   }
   #runtimeServePromise;
+  #runtimeServeLifecyclePromise;
+  #runtimeReadyPromise;
   #runtimeServeConfiguredPromise;
   #runtimeServerlessPromise;
+  #applicationListenerPromise;
   #configureServerlessPoolPromise;
   #welcomePrinted = false;
   #shutdownInstalled = false;
@@ -28721,18 +29366,67 @@ var Registry = class {
    * @param opts.host      Address to bind. Defaults to `0.0.0.0`.
    * @param opts.publicDir If set, serves static files from this directory
    *                       as a fallback below the framework routes.
+   * @param opts.application If set, handles requests that do not match a
+   *                         framework route.
    *
    * @example
    * ```ts
    * await registry.listen();
-   * await registry.listen({ port: 8080, publicDir: "./public" });
+   * await registry.listen({ application: app });
    * ```
    */
   async listen(opts = {}) {
     const port = opts.port ?? parsePortEnv(process.env.RIVET_PORT) ?? 3e3;
     const publicDir = opts.publicDir ?? getRivetkitPublicDir();
     const config3 = this.parseConfig();
-    const configuredRegistryPromise = buildConfiguredRegistry(config3);
+    if (opts.application && getRivetkitRuntimeMode() !== "serverless") {
+      if (config3.runtime === "wasm") {
+        throw new Error(
+          "registry.listen() requires the native runtime; use an application-owned HTTP server with WebAssembly"
+        );
+      }
+      this.#installSignalHandlers(config3);
+      this.#printWelcome(config3, "serverful", {
+        port,
+        host: opts.host,
+        publicDir
+      });
+      this.#startEnvoy(config3, true);
+      const readyPromise = this.startAndWait();
+      const configuredRegistryPromise2 = this.#runtimeServeConfiguredPromise;
+      if (!configuredRegistryPromise2) {
+        throw new Error("registry envoy startup did not initialize");
+      }
+      const { runtime: runtime2, registry: registry22, serveConfig: serveConfig2 } = await configuredRegistryPromise2;
+      const application2 = createApplicationFetch(
+        opts.application,
+        runtime2
+      );
+      await readyPromise;
+      const listenerPromise = runtime2.serveApplicationListener(
+        registry22,
+        {
+          port,
+          host: opts.host,
+          publicDir,
+          application: application2
+        },
+        serveConfig2
+      );
+      this.#applicationListenerPromise = listenerPromise;
+      const serveLifecyclePromise = this.#runtimeServeLifecyclePromise;
+      if (!serveLifecyclePromise) {
+        throw new Error(
+          "registry envoy serve lifecycle did not initialize"
+        );
+      }
+      await Promise.all([
+        listenerPromise,
+        serveLifecyclePromise
+      ]);
+      return;
+    }
+    const configuredRegistryPromise = this.#buildConfiguredRegistry(config3);
     this.#runtimeServeConfiguredPromise = configuredRegistryPromise;
     this.#runtimeServerlessPromise = configuredRegistryPromise;
     this.#installSignalHandlers(config3);
@@ -28743,9 +29437,15 @@ var Registry = class {
     });
     this.#ensureServerlessPoolConfigured(config3);
     const { runtime, registry: registry2, serveConfig } = await configuredRegistryPromise;
+    const application = opts.application ? createApplicationFetch(opts.application, runtime) : void 0;
     await runtime.serveListener(
       registry2,
-      { port, host: opts.host, publicDir },
+      {
+        port,
+        host: opts.host,
+        publicDir,
+        application
+      },
       serveConfig
     );
   }
@@ -28840,9 +29540,12 @@ var Registry = class {
     if (!this.#runtimeServePromise) {
       const configuredRegistryPromise = this.#buildConfiguredRegistry(config3);
       this.#runtimeServeConfiguredPromise = configuredRegistryPromise;
-      this.#runtimeServePromise = configuredRegistryPromise.then(async ({ runtime, registry: registry2, serveConfig }) => {
-        await runtime.serveRegistry(registry2, serveConfig);
-      }).catch((error46) => {
+      this.#runtimeServeLifecyclePromise = configuredRegistryPromise.then(
+        async ({ runtime, registry: registry2, serveConfig }) => {
+          await runtime.serveRegistry(registry2, serveConfig);
+        }
+      );
+      this.#runtimeServePromise = this.#runtimeServeLifecyclePromise.catch((error46) => {
         logger22().warn({ error: error46 }, "runtime registry serve errored");
       });
       this.#installSignalHandlers(config3);
@@ -28951,6 +29654,9 @@ var Registry = class {
       if (runtimeServePromise !== void 0) {
         await runtimeServePromise.catch(() => void 0);
       }
+      if (this.#applicationListenerPromise !== void 0) {
+        await this.#applicationListenerPromise.catch(() => void 0);
+      }
     };
     await Promise.race([
       drain(),
@@ -28990,6 +29696,79 @@ var Registry = class {
   startEnvoy() {
     this.#startEnvoy(this.parseConfig(), true);
   }
+  /**
+   * Starts the serverful registry if needed and waits until its envoy has
+   * registered with the Engine. Repeated and concurrent calls share one
+   * startup lifecycle and readiness promise.
+   *
+   * Unlike {@link start}, this reports startup failures and does not resolve
+   * merely because an HTTP health endpoint is listening.
+   */
+  startAndWait() {
+    if (this.#shutdownInFlight !== null) {
+      return Promise.reject(
+        new Error(
+          "registry.startAndWait() cannot run after shutdown has begun"
+        )
+      );
+    }
+    if (this.#runtimeReadyPromise) return this.#runtimeReadyPromise;
+    if (getRivetkitRuntimeMode() === "serverless") {
+      return Promise.reject(
+        new Error(
+          "registry.startAndWait() requires envoy runtime mode; serverless registries become ready per request"
+        )
+      );
+    }
+    const config3 = this.parseConfig();
+    if (config3.runtime === "wasm") {
+      return Promise.reject(
+        new Error(
+          "registry.startAndWait() requires the native runtime; WebAssembly registries do not host an envoy"
+        )
+      );
+    }
+    this.#startEnvoy(config3, true);
+    const configuredRegistryPromise = this.#runtimeServeConfiguredPromise;
+    const serveLifecyclePromise = this.#runtimeServeLifecyclePromise;
+    if (!configuredRegistryPromise || !serveLifecyclePromise) {
+      throw new Error("registry envoy startup did not initialize");
+    }
+    let timeout;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      var _a2;
+      timeout = setTimeout(
+        () => reject(
+          new Error(
+            `RivetKit registry did not register with the Engine within ${REGISTRY_READY_TIMEOUT_MS}ms`
+          )
+        ),
+        REGISTRY_READY_TIMEOUT_MS
+      );
+      (_a2 = timeout.unref) == null ? void 0 : _a2.call(timeout);
+    });
+    const readinessPromise = (async () => {
+      const { runtime, registry: registry2 } = await configuredRegistryPromise;
+      const stoppedBeforeReady = serveLifecyclePromise.then(() => {
+        throw new Error(
+          "RivetKit registry stopped before becoming ready"
+        );
+      });
+      await Promise.race([
+        runtime.waitRegistryReady(registry2),
+        stoppedBeforeReady
+      ]);
+    })();
+    this.#runtimeReadyPromise = Promise.race([
+      readinessPromise,
+      timeoutPromise
+    ]).finally(() => {
+      if (timeout !== void 0) clearTimeout(timeout);
+    });
+    this.#runtimeReadyPromise.catch(() => {
+    });
+    return this.#runtimeReadyPromise;
+  }
   /**
    * Starts the actor envoy for standalone server deployments.
    *