rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/chunk-KCOVZOPS.js

@@ -1,1946 +0,0 @@
-import {
-  createClientWithDriver,
-  lookupInRegistry
-} from "./chunk-Q6W7RJJP.js";
-import {
-  CONN_DRIVER_SYMBOL,
-  PATH_CONNECT,
-  PATH_INSPECTOR_CONNECT,
-  PATH_WEBSOCKET_PREFIX,
-  getInitialActorKvState,
-  handleAction,
-  handleRawRequest,
-  handleRouteError,
-  handleRouteNotFound,
-  loggerMiddleware,
-  loggerWithoutContext,
-  parseWebSocketProtocols,
-  routeWebSocket
-} from "./chunk-GMAVRZSF.js";
-import {
-  VERSION,
-  arrayBuffersEqual,
-  bufferToArrayBuffer,
-  getLogger,
-  noopNext,
-  promiseWithResolvers,
-  setLongTimeout,
-  stringifyError
-} from "./chunk-FJ3KTN4V.js";
-import {
-  ActorDuplicateKey,
-  ActorStopping
-} from "./chunk-LFVF5SCU.js";
-
-// src/actor/router.ts
-import { Hono } from "hono";
-function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
-  const router = new Hono({
-    strict: false
-  });
-  router.use("*", loggerMiddleware(loggerWithoutContext()));
-  router.use("*", async (c, next) => {
-    const actor = await actorDriver.loadActor(c.env.actorId);
-    actor.beginHonoHttpRequest();
-    try {
-      await next();
-    } finally {
-      actor.endHonoHttpRequest();
-    }
-  });
-  router.get("/", (c) => {
-    return c.text(
-      "This is an RivetKit actor.\n\nLearn more at https://rivetkit.org"
-    );
-  });
-  router.get("/health", (c) => {
-    return c.text("ok");
-  });
-  router.get("/metadata", async (c) => {
-    return c.json({
-      runtime: "rivetkit",
-      version: VERSION
-    });
-  });
-  if (isTest) {
-    router.post("/.test/force-disconnect", async (c) => {
-      var _a;
-      const connId = c.req.query("conn");
-      if (!connId) {
-        return c.text("Missing conn query parameter", 400);
-      }
-      const actor = await actorDriver.loadActor(c.env.actorId);
-      const conn = actor.connectionManager.getConnForId(connId);
-      if (!conn) {
-        return c.text(`Connection not found: ${connId}`, 404);
-      }
-      if ((_a = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.terminate) {
-        conn[CONN_DRIVER_SYMBOL].terminate(actor, conn);
-      }
-      return c.json({ success: true });
-    });
-  }
-  if (getUpgradeWebSocket) {
-    router.on(
-      "GET",
-      [PATH_CONNECT, `${PATH_WEBSOCKET_PREFIX}*`, PATH_INSPECTOR_CONNECT],
-      async (c) => {
-        const upgradeWebSocket = getUpgradeWebSocket();
-        if (upgradeWebSocket) {
-          return upgradeWebSocket(async (c2) => {
-            const protocols = c2.req.header(
-              "sec-websocket-protocol"
-            );
-            const { encoding, connParams } = parseWebSocketProtocols(protocols);
-            return await routeWebSocket(
-              c2.req.raw,
-              c2.req.path,
-              c2.req.header(),
-              config4,
-              actorDriver,
-              c2.env.actorId,
-              encoding,
-              connParams,
-              void 0,
-              void 0,
-              false,
-              false
-            );
-          })(c, noopNext());
-        } else {
-          return c.text(
-            "WebSockets are not enabled for this driver.",
-            400
-          );
-        }
-      }
-    );
-  }
-  router.post("/action/:action", async (c) => {
-    const actionName = c.req.param("action");
-    return handleAction(c, config4, actorDriver, actionName, c.env.actorId);
-  });
-  router.all("/request/*", async (c) => {
-    const url = new URL(c.req.url);
-    const originalPath = url.pathname.replace(/^\/request/, "") || "/";
-    const correctedUrl = new URL(originalPath + url.search, url.origin);
-    const correctedRequest = new Request(correctedUrl, {
-      method: c.req.method,
-      headers: c.req.raw.headers,
-      body: c.req.raw.body,
-      duplex: "half"
-    });
-    loggerWithoutContext().debug({
-      msg: "rewriting http url",
-      from: c.req.url,
-      to: correctedRequest.url
-    });
-    return await handleRawRequest(
-      c,
-      correctedRequest,
-      actorDriver,
-      c.env.actorId
-    );
-  });
-  router.notFound(handleRouteNotFound);
-  router.onError(handleRouteError);
-  return router;
-}
-
-// src/common/inline-websocket-adapter.ts
-import { WSContext } from "hono/ws";
-import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
-function logger() {
-  return getLogger("inline-websocket-adapter");
-}
-var InlineWebSocketAdapter = class {
-  #handler;
-  #wsContext;
-  #readyState = 0;
-  #clientWs;
-  #actorWs;
-  constructor(handler) {
-    this.#handler = handler;
-    this.#clientWs = new VirtualWebSocket({
-      getReadyState: () => this.#readyState,
-      onSend: (data) => {
-        try {
-          this.#handler.onMessage({ data }, this.#wsContext);
-          this.#actorWs.triggerMessage(data);
-        } catch (err) {
-          this.#handleError(err);
-          this.#close(1011, "Internal error processing message");
-        }
-      },
-      onClose: (code, reason) => this.#close(code, reason)
-    });
-    this.#actorWs = new VirtualWebSocket({
-      getReadyState: () => this.#readyState,
-      onSend: (data) => this.#clientWs.triggerMessage(data),
-      onClose: (code, reason) => this.#close(code, reason)
-    });
-    this.#wsContext = new WSContext({
-      raw: this.#actorWs,
-      send: (data) => {
-        logger().debug({ msg: "WSContext.send called" });
-        this.#clientWs.triggerMessage(data);
-      },
-      close: (code, reason) => {
-        logger().debug({ msg: "WSContext.close called", code, reason });
-        this.#close(code || 1e3, reason || "");
-      },
-      readyState: 1
-    });
-    setTimeout(() => {
-      this.#initialize();
-    }, 0);
-  }
-  /** Get the client-side WebSocket (for proxy/client code) */
-  get clientWebSocket() {
-    return this.#clientWs;
-  }
-  /** Get the actor-side WebSocket (passed to actor via wsContext.raw) */
-  get actorWebSocket() {
-    return this.#actorWs;
-  }
-  async #initialize() {
-    try {
-      logger().debug({ msg: "websocket initializing" });
-      this.#readyState = 1;
-      logger().debug({ msg: "calling handler.onOpen with WSContext" });
-      this.#handler.onOpen(void 0, this.#wsContext);
-      this.#clientWs.triggerOpen();
-      this.#actorWs.triggerOpen();
-    } catch (err) {
-      this.#handleError(err);
-      this.#close(1011, "Internal error during initialization");
-    }
-  }
-  #handleError(err) {
-    logger().error({
-      msg: "error in websocket",
-      error: err,
-      errorMessage: err instanceof Error ? err.message : String(err),
-      stack: err instanceof Error ? err.stack : void 0
-    });
-    try {
-      this.#handler.onError(err, this.#wsContext);
-    } catch (handlerErr) {
-      logger().error({ msg: "error in onError handler", error: handlerErr });
-    }
-    this.#clientWs.triggerError(err);
-    this.#actorWs.triggerError(err);
-  }
-  #close(code, reason) {
-    if (this.#readyState === 3 || this.#readyState === 2) {
-      return;
-    }
-    logger().debug({ msg: "closing websocket", code, reason });
-    this.#readyState = 2;
-    try {
-      this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
-    } catch (err) {
-      logger().error({ msg: "error closing websocket", error: err });
-    } finally {
-      this.#readyState = 3;
-      this.#clientWs.triggerClose(code, reason);
-      this.#actorWs.triggerClose(code, reason);
-    }
-  }
-};
-function createInlineWebSocket(handler) {
-  const adapter = new InlineWebSocketAdapter(handler);
-  return adapter.clientWebSocket;
-}
-
-// src/utils/node.ts
-import { createRequire } from "module";
-var nodeCrypto;
-var nodeFsSync;
-var nodeFs;
-var nodePath;
-var nodeOs;
-var nodeChildProcess;
-var nodeStream;
-var hasImportedDependencies = false;
-function getRequireFn() {
-  return createRequire(import.meta.url);
-}
-function importNodeDependencies() {
-  if (hasImportedDependencies) return;
-  try {
-    const requireFn = getRequireFn();
-    nodeCrypto = requireFn(
-      /* webpackIgnore: true */
-      "node:crypto"
-    );
-    nodeFsSync = requireFn(
-      /* webpackIgnore: true */
-      "node:fs"
-    );
-    nodeFs = requireFn(
-      /* webpackIgnore: true */
-      "node:fs/promises"
-    );
-    nodePath = requireFn(
-      /* webpackIgnore: true */
-      "node:path"
-    );
-    nodeOs = requireFn(
-      /* webpackIgnore: true */
-      "node:os"
-    );
-    nodeChildProcess = requireFn(
-      /* webpackIgnore: true */
-      "node:child_process"
-    );
-    nodeStream = requireFn(
-      /* webpackIgnore: true */
-      "node:stream/promises"
-    );
-    hasImportedDependencies = true;
-  } catch (err) {
-    console.warn(
-      "Node.js modules not available, file system driver will not work",
-      err
-    );
-    throw err;
-  }
-}
-function getNodeCrypto() {
-  if (!nodeCrypto) {
-    throw new Error(
-      "Node crypto module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeCrypto;
-}
-function getNodeFsSync() {
-  if (!nodeFsSync) {
-    throw new Error(
-      "Node fs module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeFsSync;
-}
-function getNodeFs() {
-  if (!nodeFs) {
-    throw new Error(
-      "Node fs/promises module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeFs;
-}
-function getNodePath() {
-  if (!nodePath) {
-    throw new Error(
-      "Node path module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodePath;
-}
-function getNodeOs() {
-  if (!nodeOs) {
-    throw new Error(
-      "Node os module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeOs;
-}
-function getNodeChildProcess() {
-  if (!nodeChildProcess) {
-    throw new Error(
-      "Node child_process module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeChildProcess;
-}
-function getNodeStream() {
-  if (!nodeStream) {
-    throw new Error(
-      "Node stream/promises module not loaded. Ensure importNodeDependencies() has been called."
-    );
-  }
-  return nodeStream;
-}
-
-// src/drivers/file-system/actor.ts
-var FileSystemActorDriver = class {
-  #config;
-  #managerDriver;
-  #inlineClient;
-  #state;
-  constructor(config4, managerDriver, inlineClient, state) {
-    this.#config = config4;
-    this.#managerDriver = managerDriver;
-    this.#inlineClient = inlineClient;
-    this.#state = state;
-  }
-  async loadActor(actorId) {
-    return this.#state.startActor(
-      this.#config,
-      this.#inlineClient,
-      this,
-      actorId
-    );
-  }
-  /**
-   * Get the current storage directory path
-   */
-  get storagePath() {
-    return this.#state.storagePath;
-  }
-  getContext(_actorId) {
-    return {};
-  }
-  async kvBatchPut(actorId, entries) {
-    await this.#state.kvBatchPut(actorId, entries);
-  }
-  async kvBatchGet(actorId, keys) {
-    return await this.#state.kvBatchGet(actorId, keys);
-  }
-  async kvBatchDelete(actorId, keys) {
-    await this.#state.kvBatchDelete(actorId, keys);
-  }
-  async kvListPrefix(actorId, prefix) {
-    return await this.#state.kvListPrefix(actorId, prefix);
-  }
-  async setAlarm(actor, timestamp) {
-    await this.#state.setActorAlarm(actor.id, timestamp);
-  }
-  getDatabase(actorId) {
-    return this.#state.createDatabase(actorId);
-  }
-  startSleep(actorId) {
-    this.#state.sleepActor(actorId);
-  }
-  async startDestroy(actorId) {
-    await this.#state.destroyActor(actorId);
-  }
-};
-
-// src/drivers/file-system/global-state.ts
-import invariant from "invariant";
-
-// src/schemas/file-system-driver/versioned.ts
-import { createVersionedDataHandler } from "vbare";
-
-// dist/schemas/file-system-driver/v1.ts
-import * as bare from "@rivetkit/bare-ts";
-var config = /* @__PURE__ */ bare.Config({});
-function read0(bc) {
-  const len = bare.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [bare.readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = bare.readString(bc);
-  }
-  return result;
-}
-function write0(bc, x) {
-  bare.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    bare.writeString(bc, x[i]);
-  }
-}
-function readActorState(bc) {
-  return {
-    actorId: bare.readString(bc),
-    name: bare.readString(bc),
-    key: read0(bc),
-    persistedData: bare.readData(bc),
-    createdAt: bare.readU64(bc)
-  };
-}
-function writeActorState(bc, x) {
-  bare.writeString(bc, x.actorId);
-  bare.writeString(bc, x.name);
-  write0(bc, x.key);
-  bare.writeData(bc, x.persistedData);
-  bare.writeU64(bc, x.createdAt);
-}
-function encodeActorState(x) {
-  const bc = new bare.ByteCursor(
-    new Uint8Array(config.initialBufferLength),
-    config
-  );
-  writeActorState(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorState(bytes) {
-  const bc = new bare.ByteCursor(bytes, config);
-  const result = readActorState(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-function readActorAlarm(bc) {
-  return {
-    actorId: bare.readString(bc),
-    timestamp: bare.readUint(bc)
-  };
-}
-function writeActorAlarm(bc, x) {
-  bare.writeString(bc, x.actorId);
-  bare.writeUint(bc, x.timestamp);
-}
-function encodeActorAlarm(x) {
-  const bc = new bare.ByteCursor(
-    new Uint8Array(config.initialBufferLength),
-    config
-  );
-  writeActorAlarm(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorAlarm(bytes) {
-  const bc = new bare.ByteCursor(bytes, config);
-  const result = readActorAlarm(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-
-// dist/schemas/file-system-driver/v2.ts
-import * as bare2 from "@rivetkit/bare-ts";
-var config2 = /* @__PURE__ */ bare2.Config({});
-function readActorKvEntry(bc) {
-  return {
-    key: bare2.readData(bc),
-    value: bare2.readData(bc)
-  };
-}
-function writeActorKvEntry(bc, x) {
-  bare2.writeData(bc, x.key);
-  bare2.writeData(bc, x.value);
-}
-function read02(bc) {
-  const len = bare2.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [bare2.readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = bare2.readString(bc);
-  }
-  return result;
-}
-function write02(bc, x) {
-  bare2.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    bare2.writeString(bc, x[i]);
-  }
-}
-function read1(bc) {
-  const len = bare2.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readActorKvEntry(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readActorKvEntry(bc);
-  }
-  return result;
-}
-function write1(bc, x) {
-  bare2.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    writeActorKvEntry(bc, x[i]);
-  }
-}
-function readActorState2(bc) {
-  return {
-    actorId: bare2.readString(bc),
-    name: bare2.readString(bc),
-    key: read02(bc),
-    kvStorage: read1(bc),
-    createdAt: bare2.readU64(bc)
-  };
-}
-function writeActorState2(bc, x) {
-  bare2.writeString(bc, x.actorId);
-  bare2.writeString(bc, x.name);
-  write02(bc, x.key);
-  write1(bc, x.kvStorage);
-  bare2.writeU64(bc, x.createdAt);
-}
-function encodeActorState2(x) {
-  const bc = new bare2.ByteCursor(
-    new Uint8Array(config2.initialBufferLength),
-    config2
-  );
-  writeActorState2(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorState2(bytes) {
-  const bc = new bare2.ByteCursor(bytes, config2);
-  const result = readActorState2(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare2.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-function readActorAlarm2(bc) {
-  return {
-    actorId: bare2.readString(bc),
-    timestamp: bare2.readUint(bc)
-  };
-}
-function writeActorAlarm2(bc, x) {
-  bare2.writeString(bc, x.actorId);
-  bare2.writeUint(bc, x.timestamp);
-}
-function encodeActorAlarm2(x) {
-  const bc = new bare2.ByteCursor(
-    new Uint8Array(config2.initialBufferLength),
-    config2
-  );
-  writeActorAlarm2(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorAlarm2(bytes) {
-  const bc = new bare2.ByteCursor(bytes, config2);
-  const result = readActorAlarm2(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare2.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-
-// dist/schemas/file-system-driver/v3.ts
-import * as bare3 from "@rivetkit/bare-ts";
-var config3 = /* @__PURE__ */ bare3.Config({});
-function readActorKvEntry2(bc) {
-  return {
-    key: bare3.readData(bc),
-    value: bare3.readData(bc)
-  };
-}
-function writeActorKvEntry2(bc, x) {
-  bare3.writeData(bc, x.key);
-  bare3.writeData(bc, x.value);
-}
-function read03(bc) {
-  const len = bare3.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [bare3.readString(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = bare3.readString(bc);
-  }
-  return result;
-}
-function write03(bc, x) {
-  bare3.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    bare3.writeString(bc, x[i]);
-  }
-}
-function read12(bc) {
-  const len = bare3.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readActorKvEntry2(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readActorKvEntry2(bc);
-  }
-  return result;
-}
-function write12(bc, x) {
-  bare3.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    writeActorKvEntry2(bc, x[i]);
-  }
-}
-function read2(bc) {
-  return bare3.readBool(bc) ? bare3.readU64(bc) : null;
-}
-function write2(bc, x) {
-  bare3.writeBool(bc, x !== null);
-  if (x !== null) {
-    bare3.writeU64(bc, x);
-  }
-}
-function readActorState3(bc) {
-  return {
-    actorId: bare3.readString(bc),
-    name: bare3.readString(bc),
-    key: read03(bc),
-    kvStorage: read12(bc),
-    createdAt: bare3.readU64(bc),
-    startTs: read2(bc),
-    connectableTs: read2(bc),
-    sleepTs: read2(bc),
-    destroyTs: read2(bc)
-  };
-}
-function writeActorState3(bc, x) {
-  bare3.writeString(bc, x.actorId);
-  bare3.writeString(bc, x.name);
-  write03(bc, x.key);
-  write12(bc, x.kvStorage);
-  bare3.writeU64(bc, x.createdAt);
-  write2(bc, x.startTs);
-  write2(bc, x.connectableTs);
-  write2(bc, x.sleepTs);
-  write2(bc, x.destroyTs);
-}
-function encodeActorState3(x) {
-  const bc = new bare3.ByteCursor(
-    new Uint8Array(config3.initialBufferLength),
-    config3
-  );
-  writeActorState3(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorState3(bytes) {
-  const bc = new bare3.ByteCursor(bytes, config3);
-  const result = readActorState3(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-function readActorAlarm3(bc) {
-  return {
-    actorId: bare3.readString(bc),
-    timestamp: bare3.readUint(bc)
-  };
-}
-function writeActorAlarm3(bc, x) {
-  bare3.writeString(bc, x.actorId);
-  bare3.writeUint(bc, x.timestamp);
-}
-function encodeActorAlarm3(x) {
-  const bc = new bare3.ByteCursor(
-    new Uint8Array(config3.initialBufferLength),
-    config3
-  );
-  writeActorAlarm3(bc, x);
-  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
-}
-function decodeActorAlarm3(bytes) {
-  const bc = new bare3.ByteCursor(bytes, config3);
-  const result = readActorAlarm3(bc);
-  if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
-  }
-  return result;
-}
-
-// src/schemas/file-system-driver/versioned.ts
-var CURRENT_VERSION = 3;
-var v1ToV2 = (v1State) => {
-  const kvStorage = [];
-  if (v1State.persistedData) {
-    const key = new Uint8Array([1]);
-    kvStorage.push({
-      key: bufferToArrayBuffer(key),
-      value: v1State.persistedData
-    });
-  }
-  return {
-    actorId: v1State.actorId,
-    name: v1State.name,
-    key: v1State.key,
-    kvStorage,
-    createdAt: v1State.createdAt
-  };
-};
-var v2ToV3 = (v2State) => {
-  return {
-    actorId: v2State.actorId,
-    name: v2State.name,
-    key: v2State.key,
-    kvStorage: v2State.kvStorage,
-    createdAt: v2State.createdAt,
-    startTs: null,
-    connectableTs: null,
-    sleepTs: null,
-    destroyTs: null
-  };
-};
-var v3ToV2 = (v3State) => {
-  return {
-    actorId: v3State.actorId,
-    name: v3State.name,
-    key: v3State.key,
-    kvStorage: v3State.kvStorage,
-    createdAt: v3State.createdAt
-  };
-};
-var v2ToV1 = (v2State) => {
-  const persistDataEntry = v2State.kvStorage.find((entry) => {
-    const key = new Uint8Array(entry.key);
-    return key.length === 1 && key[0] === 1;
-  });
-  return {
-    actorId: v2State.actorId,
-    name: v2State.name,
-    key: v2State.key,
-    persistedData: (persistDataEntry == null ? void 0 : persistDataEntry.value) || new ArrayBuffer(0),
-    createdAt: v2State.createdAt
-  };
-};
-var ACTOR_STATE_VERSIONED = createVersionedDataHandler({
-  deserializeVersion: (bytes, version) => {
-    switch (version) {
-      case 1:
-        return decodeActorState(bytes);
-      case 2:
-        return decodeActorState2(bytes);
-      case 3:
-        return decodeActorState3(bytes);
-      default:
-        throw new Error(`Unknown version ${version}`);
-    }
-  },
-  serializeVersion: (data, version) => {
-    switch (version) {
-      case 1:
-        return encodeActorState(data);
-      case 2:
-        return encodeActorState2(data);
-      case 3:
-        return encodeActorState3(data);
-      default:
-        throw new Error(`Unknown version ${version}`);
-    }
-  },
-  deserializeConverters: () => [v1ToV2, v2ToV3],
-  serializeConverters: () => [v3ToV2, v2ToV1]
-});
-var ACTOR_ALARM_VERSIONED = createVersionedDataHandler({
-  deserializeVersion: (bytes, version) => {
-    switch (version) {
-      case 1:
-        return decodeActorAlarm(bytes);
-      case 2:
-        return decodeActorAlarm2(bytes);
-      case 3:
-        return decodeActorAlarm3(bytes);
-      default:
-        throw new Error(`Unknown version ${version}`);
-    }
-  },
-  serializeVersion: (data, version) => {
-    switch (version) {
-      case 1:
-        return encodeActorAlarm(data);
-      case 2:
-        return encodeActorAlarm2(data);
-      case 3:
-        return encodeActorAlarm3(data);
-      default:
-        throw new Error(`Unknown version ${version}`);
-    }
-  },
-  deserializeConverters: () => [],
-  serializeConverters: () => []
-});
-
-// src/drivers/file-system/log.ts
-function logger2() {
-  return getLogger("driver-fs");
-}
-
-// src/drivers/file-system/utils.ts
-function generateActorId(name, key) {
-  const jsonString = JSON.stringify([name, key]);
-  const crypto2 = getNodeCrypto();
-  const hash = crypto2.createHash("sha256").update(jsonString).digest("hex").substring(0, 16);
-  return hash;
-}
-function createHashForPath(dirPath) {
-  const path = getNodePath();
-  const normalizedPath = path.normalize(dirPath);
-  const lastComponent = path.basename(normalizedPath);
-  const crypto2 = getNodeCrypto();
-  const hash = crypto2.createHash("sha256").update(normalizedPath).digest("hex").substring(0, 8);
-  return `${lastComponent}-${hash}`;
-}
-function getStoragePath() {
-  const dataPath = getDataPath("rivetkit");
-  const dirHash = createHashForPath(process.cwd());
-  const path = getNodePath();
-  return path.join(dataPath, dirHash);
-}
-async function pathExists(path) {
-  try {
-    const fs = getNodeFs();
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDirectoryExists(directoryPath) {
-  if (!await pathExists(directoryPath)) {
-    const fs = getNodeFs();
-    await fs.mkdir(directoryPath, { recursive: true });
-  }
-}
-function ensureDirectoryExistsSync(directoryPath) {
-  const fsSync = getNodeFsSync();
-  if (!fsSync.existsSync(directoryPath)) {
-    fsSync.mkdirSync(directoryPath, { recursive: true });
-  }
-}
-function getDataPath(appName) {
-  const platform = process.platform;
-  const os = getNodeOs();
-  const homeDir = os.homedir();
-  const path = getNodePath();
-  switch (platform) {
-    case "win32":
-      return path.join(
-        process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
-        appName
-      );
-    case "darwin":
-      return path.join(
-        homeDir,
-        "Library",
-        "Application Support",
-        appName
-      );
-    default:
-      return path.join(
-        process.env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"),
-        appName
-      );
-  }
-}
-
-// src/drivers/file-system/global-state.ts
-var FileSystemGlobalState = class {
-  #storagePath;
-  #stateDir;
-  #dbsDir;
-  #alarmsDir;
-  #persist;
-  // IMPORTANT: Never delete from this map. Doing so will result in race
-  // conditions since the actor generation will cease to be tracked
-  // correctly. Always increment generation if a new actor is created.
-  #actors = /* @__PURE__ */ new Map();
-  #actorCountOnStartup = 0;
-  #runnerParams;
-  get persist() {
-    return this.#persist;
-  }
-  get storagePath() {
-    return this.#storagePath;
-  }
-  get actorCountOnStartup() {
-    return this.#actorCountOnStartup;
-  }
-  constructor(persist = true, customPath) {
-    this.#persist = persist;
-    this.#storagePath = persist ? customPath ?? getStoragePath() : "/tmp";
-    const path = getNodePath();
-    this.#stateDir = path.join(this.#storagePath, "state");
-    this.#dbsDir = path.join(this.#storagePath, "databases");
-    this.#alarmsDir = path.join(this.#storagePath, "alarms");
-    if (this.#persist) {
-      ensureDirectoryExistsSync(this.#stateDir);
-      ensureDirectoryExistsSync(this.#dbsDir);
-      ensureDirectoryExistsSync(this.#alarmsDir);
-      try {
-        const fsSync = getNodeFsSync();
-        const actorIds = fsSync.readdirSync(this.#stateDir);
-        this.#actorCountOnStartup = actorIds.length;
-      } catch (error) {
-        logger2().error({ msg: "failed to count actors", error });
-      }
-      logger2().debug({
-        msg: "file system driver ready",
-        dir: this.#storagePath,
-        actorCount: this.#actorCountOnStartup
-      });
-      try {
-        this.#cleanupTempFilesSync();
-      } catch (err) {
-        logger2().error({
-          msg: "failed to cleanup temp files",
-          error: err
-        });
-      }
-    } else {
-      logger2().debug({ msg: "memory driver ready" });
-    }
-  }
-  getActorStatePath(actorId) {
-    return getNodePath().join(this.#stateDir, actorId);
-  }
-  getActorDbPath(actorId) {
-    return getNodePath().join(this.#dbsDir, `${actorId}.db`);
-  }
-  getActorAlarmPath(actorId) {
-    return getNodePath().join(this.#alarmsDir, actorId);
-  }
-  async *getActorsIterator(params) {
-    let actorIds = Array.from(this.#actors.keys()).sort();
-    const fsSync = getNodeFsSync();
-    if (fsSync.existsSync(this.#stateDir)) {
-      actorIds = fsSync.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp")).sort();
-    }
-    const startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;
-    for (let i = startIndex; i < actorIds.length; i++) {
-      const actorId = actorIds[i];
-      if (!actorId) {
-        continue;
-      }
-      try {
-        const state = await this.loadActorStateOrError(actorId);
-        yield state;
-      } catch (error) {
-        logger2().error({
-          msg: "failed to load actor state",
-          actorId,
-          error
-        });
-      }
-    }
-  }
-  /**
-   * Ensures an entry exists for this actor.
-   *
-   * Used for #createActor and #loadActor.
-   */
-  #upsertEntry(actorId) {
-    let entry = this.#actors.get(actorId);
-    if (entry) {
-      return entry;
-    }
-    entry = {
-      id: actorId,
-      lifecycleState: 0 /* NONEXISTENT */,
-      generation: crypto.randomUUID()
-    };
-    this.#actors.set(actorId, entry);
-    return entry;
-  }
-  /**
-   * Creates a new actor and writes to file system.
-   */
-  async createActor(actorId, name, key, input) {
-    const entry = this.#upsertEntry(actorId);
-    if (entry.state) {
-      throw new ActorDuplicateKey(name, key);
-    }
-    if (this.isActorStopping(actorId)) {
-      throw new Error(`Actor ${actorId} is stopping`);
-    }
-    if (entry.lifecycleState === 4 /* DESTROYED */) {
-      entry.lifecycleState = 0 /* NONEXISTENT */;
-      entry.generation = crypto.randomUUID();
-    }
-    const kvStorage = [];
-    const initialKvState = getInitialActorKvState(input);
-    for (const [key2, value] of initialKvState) {
-      kvStorage.push({
-        key: bufferToArrayBuffer(key2),
-        value: bufferToArrayBuffer(value)
-      });
-    }
-    entry.state = {
-      actorId,
-      name,
-      key,
-      createdAt: BigInt(Date.now()),
-      kvStorage,
-      startTs: null,
-      connectableTs: null,
-      sleepTs: null,
-      destroyTs: null
-    };
-    entry.lifecycleState = 1 /* AWAKE */;
-    await this.writeActor(actorId, entry.generation, entry.state);
-    return entry;
-  }
-  /**
-   * Loads the actor from disk or returns the existing actor entry. This will return an entry even if the actor does not actually exist.
-   */
-  async loadActor(actorId) {
-    const entry = this.#upsertEntry(actorId);
-    if (entry.lifecycleState === 4 /* DESTROYED */) {
-      return entry;
-    }
-    if (entry.state) {
-      return entry;
-    }
-    if (!this.#persist) {
-      return entry;
-    }
-    if (entry.loadPromise) {
-      await entry.loadPromise;
-      return entry;
-    }
-    entry.loadPromise = this.loadActorState(entry);
-    return entry.loadPromise;
-  }
-  async loadActorState(entry) {
-    const stateFilePath = this.getActorStatePath(entry.id);
-    try {
-      const fs = getNodeFs();
-      const stateData = await fs.readFile(stateFilePath);
-      entry.state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
-        new Uint8Array(stateData)
-      );
-      return entry;
-    } catch (innerError) {
-      if (innerError.code === "ENOENT") {
-        entry.loadPromise = void 0;
-        return entry;
-      }
-      const error = new Error(
-        `Failed to load actor state: ${innerError}`
-      );
-      throw error;
-    }
-  }
-  async loadOrCreateActor(actorId, name, key, input) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      if (this.isActorStopping(actorId)) {
-        throw new Error(`Actor ${actorId} stopping`);
-      }
-      if (entry.lifecycleState === 4 /* DESTROYED */) {
-        entry.lifecycleState = 0 /* NONEXISTENT */;
-        entry.generation = crypto.randomUUID();
-      }
-      const kvStorage = [];
-      const initialKvState = getInitialActorKvState(input);
-      for (const [key2, value] of initialKvState) {
-        kvStorage.push({
-          key: bufferToArrayBuffer(key2),
-          value: bufferToArrayBuffer(value)
-        });
-      }
-      entry.state = {
-        actorId,
-        name,
-        key,
-        createdAt: BigInt(Date.now()),
-        kvStorage,
-        startTs: null,
-        connectableTs: null,
-        sleepTs: null,
-        destroyTs: null
-      };
-      await this.writeActor(actorId, entry.generation, entry.state);
-    }
-    return entry;
-  }
-  async sleepActor(actorId) {
-    var _a;
-    invariant(
-      this.#persist,
-      "cannot sleep actor with memory driver, must use file system driver"
-    );
-    const actor = this.#upsertEntry(actorId);
-    invariant(actor, `tried to sleep ${actorId}, does not exist`);
-    if (this.isActorStopping(actorId)) {
-      return;
-    }
-    actor.lifecycleState = 2 /* STARTING_SLEEP */;
-    if (actor.loadPromise) await actor.loadPromise.catch();
-    if ((_a = actor.startPromise) == null ? void 0 : _a.promise)
-      await actor.startPromise.promise.catch();
-    if (actor.state) {
-      actor.state = {
-        ...actor.state,
-        sleepTs: BigInt(Date.now())
-      };
-      await this.writeActor(actorId, actor.generation, actor.state);
-    }
-    invariant(actor.actor, "actor should be loaded");
-    await actor.actor.onStop("sleep");
-    this.#actors.delete(actorId);
-  }
-  async destroyActor(actorId) {
-    var _a;
-    const actor = this.#upsertEntry(actorId);
-    if (this.isActorStopping(actorId)) {
-      return;
-    }
-    actor.lifecycleState = 3 /* STARTING_DESTROY */;
-    if (actor.loadPromise) await actor.loadPromise.catch();
-    if ((_a = actor.startPromise) == null ? void 0 : _a.promise)
-      await actor.startPromise.promise.catch();
-    if (actor.state) {
-      actor.state = {
-        ...actor.state,
-        destroyTs: BigInt(Date.now())
-      };
-      await this.writeActor(actorId, actor.generation, actor.state);
-    }
-    if (actor.actor) {
-      await actor.actor.onStop("destroy");
-    }
-    if (actor.alarmTimeout) {
-      actor.alarmTimeout.abort();
-    }
-    if (this.#persist) {
-      const fs = getNodeFs();
-      await Promise.all([
-        // Delete actor state file
-        (async () => {
-          try {
-            await fs.unlink(this.getActorStatePath(actorId));
-          } catch (err) {
-            if ((err == null ? void 0 : err.code) !== "ENOENT") {
-              logger2().error({
-                msg: "failed to delete actor state file",
-                actorId,
-                error: stringifyError(err)
-              });
-            }
-          }
-        })(),
-        // Delete actor database file
-        (async () => {
-          try {
-            await fs.unlink(this.getActorDbPath(actorId));
-          } catch (err) {
-            if ((err == null ? void 0 : err.code) !== "ENOENT") {
-              logger2().error({
-                msg: "failed to delete actor database file",
-                actorId,
-                error: stringifyError(err)
-              });
-            }
-          }
-        })(),
-        // Delete actor alarm file
-        (async () => {
-          try {
-            await fs.unlink(this.getActorAlarmPath(actorId));
-          } catch (err) {
-            if ((err == null ? void 0 : err.code) !== "ENOENT") {
-              logger2().error({
-                msg: "failed to delete actor alarm file",
-                actorId,
-                error: stringifyError(err)
-              });
-            }
-          }
-        })()
-      ]);
-    }
-    actor.state = void 0;
-    actor.loadPromise = void 0;
-    actor.actor = void 0;
-    actor.startPromise = void 0;
-    actor.alarmTimeout = void 0;
-    actor.alarmTimeout = void 0;
-    actor.pendingWriteResolver = void 0;
-    actor.lifecycleState = 4 /* DESTROYED */;
-  }
-  /**
-   * Save actor state to disk.
-   */
-  async writeActor(actorId, generation, state) {
-    if (!this.#persist) {
-      return;
-    }
-    const entry = this.#actors.get(actorId);
-    invariant(entry, "actor entry does not exist");
-    await this.#performWrite(actorId, generation, state);
-  }
-  isGenerationCurrentAndNotDestroyed(actorId, generation) {
-    const entry = this.#upsertEntry(actorId);
-    if (!entry) return false;
-    return entry.generation === generation && entry.lifecycleState !== 3 /* STARTING_DESTROY */;
-  }
-  isActorStopping(actorId) {
-    const entry = this.#upsertEntry(actorId);
-    if (!entry) return false;
-    return entry.lifecycleState === 2 /* STARTING_SLEEP */ || entry.lifecycleState === 3 /* STARTING_DESTROY */;
-  }
-  async setActorAlarm(actorId, timestamp) {
-    const entry = this.#actors.get(actorId);
-    invariant(entry, "actor entry does not exist");
-    const writeGeneration = entry.generation;
-    if (this.isActorStopping(actorId)) {
-      logger2().info("skipping set alarm since actor stopping");
-      return;
-    }
-    if (this.#persist) {
-      const alarmPath = this.getActorAlarmPath(actorId);
-      const crypto2 = getNodeCrypto();
-      const tempPath = `${alarmPath}.tmp.${crypto2.randomUUID()}`;
-      try {
-        const path = getNodePath();
-        await ensureDirectoryExists(path.dirname(alarmPath));
-        const alarmData = {
-          actorId,
-          timestamp: BigInt(timestamp)
-        };
-        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
-          alarmData,
-          CURRENT_VERSION
-        );
-        const fs = getNodeFs();
-        await fs.writeFile(tempPath, data);
-        if (!this.isGenerationCurrentAndNotDestroyed(
-          actorId,
-          writeGeneration
-        )) {
-          logger2().debug(
-            "skipping writing alarm since actor destroying or new generation"
-          );
-          return;
-        }
-        await fs.rename(tempPath, alarmPath);
-      } catch (error) {
-        try {
-          const fs = getNodeFs();
-          await fs.unlink(tempPath);
-        } catch {
-        }
-        logger2().error({
-          msg: "failed to write alarm",
-          actorId,
-          error
-        });
-        throw new Error(`Failed to write alarm: ${error}`);
-      }
-    }
-    this.#scheduleAlarmTimeout(actorId, timestamp);
-  }
-  /**
-   * Perform the actual write operation with atomic writes
-   */
-  async #performWrite(actorId, generation, state) {
-    const dataPath = this.getActorStatePath(actorId);
-    const crypto2 = getNodeCrypto();
-    const tempPath = `${dataPath}.tmp.${crypto2.randomUUID()}`;
-    try {
-      const path = getNodePath();
-      await ensureDirectoryExists(path.dirname(dataPath));
-      const bareState = {
-        actorId: state.actorId,
-        name: state.name,
-        key: state.key,
-        createdAt: state.createdAt,
-        kvStorage: state.kvStorage,
-        startTs: state.startTs,
-        connectableTs: state.connectableTs,
-        sleepTs: state.sleepTs,
-        destroyTs: state.destroyTs
-      };
-      const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(
-        bareState,
-        CURRENT_VERSION
-      );
-      const fs = getNodeFs();
-      await fs.writeFile(tempPath, serializedState);
-      if (!this.isGenerationCurrentAndNotDestroyed(actorId, generation)) {
-        logger2().debug(
-          "skipping writing alarm since actor destroying or new generation"
-        );
-        return;
-      }
-      await fs.rename(tempPath, dataPath);
-    } catch (error) {
-      try {
-        const fs = getNodeFs();
-        await fs.unlink(tempPath);
-      } catch {
-      }
-      logger2().error({
-        msg: "failed to save actor state",
-        actorId,
-        error
-      });
-      throw new Error(`Failed to save actor state: ${error}`);
-    }
-  }
-  /**
-   * Call this method after the actor driver has been initiated.
-   *
-   * This will trigger all initial alarms from the file system.
-   *
-   * This needs to be sync since DriverConfig.actor is sync
-   */
-  onRunnerStart(config4, inlineClient, actorDriver) {
-    if (this.#runnerParams) {
-      return;
-    }
-    this.#runnerParams = {
-      config: config4,
-      inlineClient,
-      actorDriver
-    };
-    try {
-      this.#loadAlarmsSync();
-    } catch (err) {
-      logger2().error({
-        msg: "failed to load alarms on startup",
-        error: err
-      });
-    }
-  }
-  async startActor(config4, inlineClient, actorDriver, actorId) {
-    var _a;
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      throw new Error(
-        `Actor does not exist and cannot be started: "${actorId}"`
-      );
-    }
-    if (entry.startPromise) {
-      await entry.startPromise.promise;
-      invariant(entry.actor, "actor should have loaded");
-      return entry.actor;
-    }
-    if (entry.actor) {
-      return entry.actor;
-    }
-    entry.startPromise = promiseWithResolvers();
-    try {
-      const definition = lookupInRegistry(
-        config4,
-        entry.state.name
-      );
-      entry.actor = definition.instantiate();
-      await entry.actor.start(
-        actorDriver,
-        inlineClient,
-        actorId,
-        entry.state.name,
-        entry.state.key,
-        "unknown"
-      );
-      const now = BigInt(Date.now());
-      entry.state = {
-        ...entry.state,
-        startTs: now,
-        connectableTs: now,
-        sleepTs: null
-        // Clear sleep timestamp when actor wakes up
-      };
-      await this.writeActor(actorId, entry.generation, entry.state);
-      entry.startPromise.resolve();
-      entry.startPromise = void 0;
-      return entry.actor;
-    } catch (innerError) {
-      const error = new Error(
-        `Failed to start actor ${actorId}: ${innerError}`,
-        { cause: innerError }
-      );
-      (_a = entry.startPromise) == null ? void 0 : _a.reject(error);
-      entry.startPromise = void 0;
-      throw error;
-    }
-  }
-  async loadActorStateOrError(actorId) {
-    const state = (await this.loadActor(actorId)).state;
-    if (!state) throw new Error(`Actor does not exist: ${actorId}`);
-    return state;
-  }
-  getActorOrError(actorId) {
-    const entry = this.#actors.get(actorId);
-    if (!entry) throw new Error(`No entry for actor: ${actorId}`);
-    return entry;
-  }
-  async createDatabase(actorId) {
-    return this.getActorDbPath(actorId);
-  }
-  /**
-   * Load all persisted alarms from disk and schedule their timers.
-   */
-  #loadAlarmsSync() {
-    try {
-      const fsSync = getNodeFsSync();
-      const files = fsSync.existsSync(this.#alarmsDir) ? fsSync.readdirSync(this.#alarmsDir) : [];
-      for (const file of files) {
-        if (file.includes(".tmp.")) continue;
-        const path = getNodePath();
-        const fullPath = path.join(this.#alarmsDir, file);
-        try {
-          const buf = fsSync.readFileSync(fullPath);
-          const alarmData = ACTOR_ALARM_VERSIONED.deserializeWithEmbeddedVersion(
-            new Uint8Array(buf)
-          );
-          const timestamp = Number(alarmData.timestamp);
-          if (Number.isFinite(timestamp)) {
-            this.#scheduleAlarmTimeout(
-              alarmData.actorId,
-              timestamp
-            );
-          } else {
-            logger2().debug({
-              msg: "invalid alarm file contents",
-              file
-            });
-          }
-        } catch (err) {
-          logger2().error({
-            msg: "failed to read alarm file",
-            file,
-            error: stringifyError(err)
-          });
-        }
-      }
-    } catch (err) {
-      logger2().error({
-        msg: "failed to list alarms directory",
-        error: err
-      });
-    }
-  }
-  /**
-   * Schedule an alarm timer for an actor without writing to disk.
-   */
-  #scheduleAlarmTimeout(actorId, timestamp) {
-    var _a;
-    const entry = this.#upsertEntry(actorId);
-    if (entry.alarmTimestamp !== void 0 && timestamp >= entry.alarmTimestamp) {
-      logger2().debug({
-        msg: "skipping alarm schedule (later than existing)",
-        actorId,
-        timestamp,
-        current: entry.alarmTimestamp
-      });
-      return;
-    }
-    logger2().debug({ msg: "scheduling alarm", actorId, timestamp });
-    (_a = entry.alarmTimeout) == null ? void 0 : _a.abort();
-    entry.alarmTimestamp = timestamp;
-    const delay = Math.max(0, timestamp - Date.now());
-    entry.alarmTimeout = setLongTimeout(async () => {
-      entry.alarmTimestamp = void 0;
-      if (this.#persist) {
-        try {
-          const fs = getNodeFs();
-          await fs.unlink(this.getActorAlarmPath(actorId));
-        } catch (err) {
-          if ((err == null ? void 0 : err.code) !== "ENOENT") {
-            logger2().debug({
-              msg: "failed to remove alarm file",
-              actorId,
-              error: stringifyError(err)
-            });
-          }
-        }
-      }
-      try {
-        logger2().debug({ msg: "triggering alarm", actorId, timestamp });
-        const loaded = await this.loadActor(actorId);
-        if (!loaded.state)
-          throw new Error(`Actor does not exist: ${actorId}`);
-        const runnerParams = this.#runnerParams;
-        invariant(runnerParams, "missing runner params");
-        if (!loaded.actor) {
-          await this.startActor(
-            runnerParams.config,
-            runnerParams.inlineClient,
-            runnerParams.actorDriver,
-            actorId
-          );
-        }
-        invariant(loaded.actor, "actor should be loaded after wake");
-        await loaded.actor.onAlarm();
-      } catch (err) {
-        logger2().error({
-          msg: "failed to handle alarm",
-          actorId,
-          error: stringifyError(err)
-        });
-      }
-    }, delay);
-  }
-  /**
-   * Cleanup stale temp files on startup (synchronous)
-   */
-  #cleanupTempFilesSync() {
-    try {
-      const fsSync = getNodeFsSync();
-      const files = fsSync.readdirSync(this.#stateDir);
-      const tempFiles = files.filter((f) => f.includes(".tmp."));
-      const oneHourAgo = Date.now() - 36e5;
-      for (const tempFile of tempFiles) {
-        try {
-          const path = getNodePath();
-          const fullPath = path.join(this.#stateDir, tempFile);
-          const stat = fsSync.statSync(fullPath);
-          if (stat.mtimeMs < oneHourAgo) {
-            fsSync.unlinkSync(fullPath);
-            logger2().info({
-              msg: "cleaned up stale temp file",
-              file: tempFile
-            });
-          }
-        } catch (err) {
-          logger2().debug({
-            msg: "failed to cleanup temp file",
-            file: tempFile,
-            error: err
-          });
-        }
-      }
-    } catch (err) {
-      logger2().error({
-        msg: "failed to read actors directory for cleanup",
-        error: err
-      });
-    }
-  }
-  /**
-   * Batch put KV entries for an actor.
-   */
-  async kvBatchPut(actorId, entries) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      if (this.isActorStopping(actorId)) {
-        return;
-      } else {
-        throw new Error(`Actor ${actorId} state not loaded`);
-      }
-    }
-    const newKvStorage = [...entry.state.kvStorage];
-    for (const [key, value] of entries) {
-      const existingIndex = newKvStorage.findIndex(
-        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
-      );
-      if (existingIndex >= 0) {
-        newKvStorage[existingIndex] = {
-          key: bufferToArrayBuffer(key),
-          value: bufferToArrayBuffer(value)
-        };
-      } else {
-        newKvStorage.push({
-          key: bufferToArrayBuffer(key),
-          value: bufferToArrayBuffer(value)
-        });
-      }
-    }
-    entry.state = {
-      ...entry.state,
-      kvStorage: newKvStorage
-    };
-    await this.writeActor(actorId, entry.generation, entry.state);
-  }
-  /**
-   * Batch get KV entries for an actor.
-   */
-  async kvBatchGet(actorId, keys) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      if (this.isActorStopping(actorId)) {
-        throw new Error(`Actor ${actorId} is stopping`);
-      } else {
-        throw new Error(`Actor ${actorId} state not loaded`);
-      }
-    }
-    const results = [];
-    for (const key of keys) {
-      const foundEntry = entry.state.kvStorage.find(
-        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
-      );
-      if (foundEntry) {
-        results.push(new Uint8Array(foundEntry.value));
-      } else {
-        results.push(null);
-      }
-    }
-    return results;
-  }
-  /**
-   * Batch delete KV entries for an actor.
-   */
-  async kvBatchDelete(actorId, keys) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      if (this.isActorStopping(actorId)) {
-        return;
-      } else {
-        throw new Error(`Actor ${actorId} state not loaded`);
-      }
-    }
-    const newKvStorage = [...entry.state.kvStorage];
-    for (const key of keys) {
-      const indexToDelete = newKvStorage.findIndex(
-        (e) => arrayBuffersEqual(e.key, bufferToArrayBuffer(key))
-      );
-      if (indexToDelete >= 0) {
-        newKvStorage.splice(indexToDelete, 1);
-      }
-    }
-    entry.state = {
-      ...entry.state,
-      kvStorage: newKvStorage
-    };
-    await this.writeActor(actorId, entry.generation, entry.state);
-  }
-  /**
-   * List KV entries with a given prefix for an actor.
-   */
-  async kvListPrefix(actorId, prefix) {
-    const entry = await this.loadActor(actorId);
-    if (!entry.state) {
-      if (this.isActorStopping(actorId)) {
-        throw new Error(`Actor ${actorId} is destroying`);
-      } else {
-        throw new Error(`Actor ${actorId} state not loaded`);
-      }
-    }
-    const results = [];
-    for (const kvEntry of entry.state.kvStorage) {
-      const keyBytes = new Uint8Array(kvEntry.key);
-      if (keyBytes.length >= prefix.length) {
-        let hasPrefix = true;
-        for (let i = 0; i < prefix.length; i++) {
-          if (keyBytes[i] !== prefix[i]) {
-            hasPrefix = false;
-            break;
-          }
-        }
-        if (hasPrefix) {
-          results.push([keyBytes, new Uint8Array(kvEntry.value)]);
-        }
-      }
-    }
-    return results;
-  }
-};
-
-// src/drivers/file-system/manager.ts
-import invariant2 from "invariant";
-var FileSystemManagerDriver = class {
-  #config;
-  #state;
-  #driverConfig;
-  #getUpgradeWebSocket;
-  #actorDriver;
-  #actorRouter;
-  constructor(config4, state, driverConfig) {
-    this.#config = config4;
-    this.#state = state;
-    this.#driverConfig = driverConfig;
-    const inlineClient = createClientWithDriver(this);
-    this.#actorDriver = this.#driverConfig.actor(
-      config4,
-      this,
-      inlineClient
-    );
-    this.#actorRouter = createActorRouter(
-      this.#config,
-      this.#actorDriver,
-      void 0,
-      config4.test.enabled
-    );
-  }
-  async sendRequest(actorId, actorRequest) {
-    return await this.#actorRouter.fetch(actorRequest, {
-      actorId
-    });
-  }
-  async openWebSocket(path, actorId, encoding, params) {
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    const fakeUrl = `http://inline-actor${normalizedPath}`;
-    const fakeRequest = new Request(fakeUrl, {
-      method: "GET"
-    });
-    const pathOnly = normalizedPath.split("?")[0];
-    const wsHandler = await routeWebSocket(
-      fakeRequest,
-      pathOnly,
-      {},
-      this.#config,
-      this.#actorDriver,
-      actorId,
-      encoding,
-      params,
-      void 0,
-      void 0,
-      false,
-      false
-    );
-    return createInlineWebSocket(wsHandler);
-  }
-  async proxyRequest(c, actorRequest, actorId) {
-    return await this.#actorRouter.fetch(actorRequest, {
-      actorId
-    });
-  }
-  async proxyWebSocket(c, path, actorId, encoding, params) {
-    var _a;
-    const upgradeWebSocket = (_a = this.#getUpgradeWebSocket) == null ? void 0 : _a.call(this);
-    invariant2(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const pathOnly = path.split("?")[0];
-    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-    const wsHandler = await routeWebSocket(
-      // TODO: Create new request with new path
-      c.req.raw,
-      normalizedPath,
-      c.req.header(),
-      this.#config,
-      this.#actorDriver,
-      actorId,
-      encoding,
-      params,
-      void 0,
-      void 0,
-      false,
-      false
-    );
-    return upgradeWebSocket(() => wsHandler)(c, noopNext());
-  }
-  async buildGatewayUrl(actorId) {
-    const port = this.#config.managerPort ?? 6420;
-    return `http://127.0.0.1:${port}/gateway/${encodeURIComponent(actorId)}`;
-  }
-  async getForId({
-    actorId
-  }) {
-    const actor = await this.#state.loadActor(actorId);
-    if (!actor.state) {
-      return void 0;
-    }
-    if (this.#state.isActorStopping(actorId)) {
-      throw new ActorStopping(actorId);
-    }
-    return actorStateToOutput(actor.state);
-  }
-  async getWithKey({
-    name,
-    key
-  }) {
-    const actorId = generateActorId(name, key);
-    const actor = await this.#state.loadActor(actorId);
-    if (actor.state) {
-      return actorStateToOutput(actor.state);
-    }
-    return void 0;
-  }
-  async getOrCreateWithKey(input) {
-    const actorId = generateActorId(input.name, input.key);
-    await this.#state.loadOrCreateActor(
-      actorId,
-      input.name,
-      input.key,
-      input.input
-    );
-    await this.#actorDriver.loadActor(actorId);
-    const state = await this.#state.loadActorStateOrError(actorId);
-    return actorStateToOutput(state);
-  }
-  async createActor({ name, key, input }) {
-    const actorId = generateActorId(name, key);
-    await this.#state.createActor(actorId, name, key, input);
-    await this.#actorDriver.loadActor(actorId);
-    const state = await this.#state.loadActorStateOrError(actorId);
-    return actorStateToOutput(state);
-  }
-  async listActors({ name }) {
-    const actors = [];
-    const itr = this.#state.getActorsIterator({});
-    for await (const actor of itr) {
-      if (actor.name === name) {
-        actors.push(actorStateToOutput(actor));
-      }
-    }
-    actors.sort((a, b) => {
-      const aTs = a.createTs ?? 0;
-      const bTs = b.createTs ?? 0;
-      return bTs - aTs;
-    });
-    return actors;
-  }
-  async kvGet(actorId, key) {
-    const response = await this.#state.kvBatchGet(actorId, [key]);
-    return response[0] !== null ? new TextDecoder().decode(response[0]) : null;
-  }
-  displayInformation() {
-    return {
-      properties: {
-        ...this.#state.persist ? { Data: this.#state.storagePath } : {},
-        Instances: this.#state.actorCountOnStartup.toString()
-      }
-    };
-  }
-  extraStartupLog() {
-    return {
-      instances: this.#state.actorCountOnStartup,
-      data: this.#state.storagePath
-    };
-  }
-  setGetUpgradeWebSocket(getUpgradeWebSocket) {
-    this.#getUpgradeWebSocket = getUpgradeWebSocket;
-  }
-};
-function actorStateToOutput(state) {
-  return {
-    actorId: state.actorId,
-    name: state.name,
-    key: state.key,
-    createTs: Number(state.createdAt),
-    startTs: state.startTs !== null ? Number(state.startTs) : null,
-    connectableTs: state.connectableTs !== null ? Number(state.connectableTs) : null,
-    sleepTs: state.sleepTs !== null ? Number(state.sleepTs) : null,
-    destroyTs: state.destroyTs !== null ? Number(state.destroyTs) : null
-  };
-}
-
-// src/drivers/file-system/mod.ts
-function createFileSystemOrMemoryDriver(persist = true, customPath) {
-  importNodeDependencies();
-  const state = new FileSystemGlobalState(persist, customPath);
-  const driverConfig = {
-    name: persist ? "file-system" : "memory",
-    displayName: persist ? "File System" : "Memory",
-    manager: (config4) => new FileSystemManagerDriver(
-      config4,
-      state,
-      driverConfig
-    ),
-    actor: (config4, managerDriver, inlineClient) => {
-      const actorDriver = new FileSystemActorDriver(
-        config4,
-        managerDriver,
-        inlineClient,
-        state
-      );
-      state.onRunnerStart(
-        config4,
-        inlineClient,
-        actorDriver
-      );
-      return actorDriver;
-    },
-    autoStartActorDriver: true
-  };
-  return driverConfig;
-}
-function createFileSystemDriver(opts) {
-  return createFileSystemOrMemoryDriver(true, opts == null ? void 0 : opts.path);
-}
-function createMemoryDriver() {
-  return createFileSystemOrMemoryDriver(false);
-}
-
-export {
-  createActorRouter,
-  InlineWebSocketAdapter,
-  importNodeDependencies,
-  getNodeCrypto,
-  getNodeFsSync,
-  getNodeFs,
-  getNodePath,
-  getNodeChildProcess,
-  getNodeStream,
-  getStoragePath,
-  ensureDirectoryExists,
-  createFileSystemOrMemoryDriver,
-  createFileSystemDriver,
-  createMemoryDriver
-};
-//# sourceMappingURL=chunk-KCOVZOPS.js.map