rivetkit 2.1.5 → 2.1.6-rc.1

package/dist/tsup/chunk-2LY7RW3Y.cjs

@@ -0,0 +1,2316 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkJJNZQDUNcjs = require('./chunk-JJNZQDUN.cjs');
+
+
+var _chunkGUHXWPGBcjs = require('./chunk-GUHXWPGB.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkCGGGBIDPcjs = require('./chunk-CGGGBIDP.cjs');
+
+
+var _chunkHNE2AK6Ccjs = require('./chunk-HNE2AK6C.cjs');
+
+
+
+
+
+
+
+var _chunkMPLMTJY5cjs = require('./chunk-MPLMTJY5.cjs');
+
+
+
+var _chunk6G7ZNM27cjs = require('./chunk-6G7ZNM27.cjs');
+
+// src/common/inline-websocket-adapter.ts
+var _ws = require('hono/ws');
+var _virtualwebsocket = require('@rivetkit/virtual-websocket');
+function logger() {
+  return _chunkMPLMTJY5cjs.getLogger.call(void 0, "inline-websocket-adapter");
+}
+var InlineWebSocketAdapter = class {
+  #handler;
+  #wsContext;
+  #readyState = 0;
+  #clientWs;
+  #actorWs;
+  constructor(handler) {
+    this.#handler = handler;
+    this.#clientWs = new (0, _virtualwebsocket.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 (0, _virtualwebsocket.VirtualWebSocket)({
+      getReadyState: () => this.#readyState,
+      onSend: (data) => this.#clientWs.triggerMessage(data),
+      onClose: (code, reason) => this.#close(code, reason)
+    });
+    this.#wsContext = new (0, _ws.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/drivers/file-system/mod.ts
+var _zod = require('zod');
+
+// src/drivers/file-system/actor.ts
+var FileSystemActorDriver = class {
+  #config;
+  #managerDriver;
+  #inlineClient;
+  #state;
+  #sqlitePool;
+  
+  constructor(config4, managerDriver, inlineClient, state) {
+    this.#config = config4;
+    this.#managerDriver = managerDriver;
+    this.#inlineClient = inlineClient;
+    this.#state = state;
+    this.#sqlitePool = new (0, _chunkCGGGBIDPcjs.SqliteVfsPoolManager)(config4);
+    if (this.#state.persist) {
+      this.startSleep = (actorId) => {
+        this.#state.sleepActor(actorId);
+      };
+    }
+  }
+  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 kvDeleteRange(actorId, start, end) {
+    await this.#state.kvDeleteRange(actorId, start, end);
+  }
+  async kvListPrefix(actorId, prefix, options) {
+    return await this.#state.kvListPrefix(actorId, prefix, options);
+  }
+  async kvListRange(actorId, start, end, options) {
+    return await this.#state.kvListRange(actorId, start, end, options);
+  }
+  async setAlarm(actor, timestamp) {
+    await this.#state.setActorAlarm(actor.id, timestamp);
+  }
+  /** Creates a SQLite VFS instance for creating KV-backed databases */
+  async createSqliteVfs(actorId) {
+    return await this.#sqlitePool.acquire(actorId);
+  }
+  async shutdownRunner(_immediate) {
+    await this.#sqlitePool.shutdown();
+  }
+  async startDestroy(actorId) {
+    await this.#state.destroyActor(actorId);
+  }
+  async onBeforeActorStart(actor) {
+    await actor.cleanupPersistedConnections("file-system-driver.start");
+  }
+};
+
+// src/drivers/file-system/global-state.ts
+var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
+
+// src/schemas/file-system-driver/versioned.ts
+var _vbare = require('vbare');
+
+// dist/schemas/file-system-driver/v1.ts
+var _barets = require('@rivetkit/bare-ts'); var bare = _interopRequireWildcard(_barets); var bare2 = _interopRequireWildcard(_barets); var bare3 = _interopRequireWildcard(_barets);
+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
+
+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
+
+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: _chunkMPLMTJY5cjs.bufferToArrayBuffer.call(void 0, 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 = _vbare.createVersionedDataHandler.call(void 0, {
+  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 = _vbare.createVersionedDataHandler.call(void 0, {
+  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 _chunkMPLMTJY5cjs.getLogger.call(void 0, "driver-fs");
+}
+
+// src/drivers/file-system/utils.ts
+function generateActorId(name, key) {
+  const jsonString = JSON.stringify([name, key]);
+  const crypto2 = _chunkCGGGBIDPcjs.getNodeCrypto.call(void 0, );
+  const hash = crypto2.createHash("sha256").update(jsonString).digest("hex").substring(0, 16);
+  return hash;
+}
+function createHashForPath(dirPath) {
+  const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+  const normalizedPath = path.normalize(dirPath);
+  const lastComponent = path.basename(normalizedPath);
+  const crypto2 = _chunkCGGGBIDPcjs.getNodeCrypto.call(void 0, );
+  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 = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+  return path.join(dataPath, dirHash);
+}
+async function pathExists(path) {
+  try {
+    const fs = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+    await fs.access(path);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function ensureDirectoryExists(directoryPath) {
+  if (!await pathExists(directoryPath)) {
+    const fs = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+    await fs.mkdir(directoryPath, { recursive: true });
+  }
+}
+function ensureDirectoryExistsSync(directoryPath) {
+  const fsSync = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+  if (!fsSync.existsSync(directoryPath)) {
+    fsSync.mkdirSync(directoryPath, { recursive: true });
+  }
+}
+function getDataPath(appName) {
+  const platform = process.platform;
+  const os = _chunkCGGGBIDPcjs.getNodeOs.call(void 0, );
+  const homeDir = os.homedir();
+  const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+  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/sqlite-runtime.ts
+function normalizeParams(params) {
+  if (!params || params.length === 0) {
+    return [];
+  }
+  return params.map((value) => {
+    if (value instanceof Uint8Array) {
+      return Buffer.from(value);
+    }
+    return value;
+  });
+}
+function createPreparedDatabaseAdapter(rawDb, prepare) {
+  return {
+    exec: (sql) => {
+      rawDb.exec(sql);
+    },
+    run: (sql, params) => {
+      const stmt = prepare(sql);
+      stmt.run(...normalizeParams(params));
+    },
+    get: (sql, params) => {
+      const stmt = prepare(sql);
+      return stmt.get(...normalizeParams(params));
+    },
+    all: (sql, params) => {
+      const stmt = prepare(sql);
+      return stmt.all(...normalizeParams(params));
+    },
+    close: () => {
+      rawDb.close();
+    }
+  };
+}
+function configureSqliteRuntimeDatabase(rawDb, path) {
+  rawDb.exec("PRAGMA busy_timeout = 5000");
+  if (path !== ":memory:") {
+    rawDb.exec("PRAGMA journal_mode = WAL");
+  }
+}
+function loadSqliteRuntime() {
+  const requireFn = _chunkCGGGBIDPcjs.getRequireFn.call(void 0, );
+  const loadErrors = [];
+  try {
+    const bunSqlite = requireFn(
+      /* webpackIgnore: true */
+      "bun:sqlite"
+    );
+    const BunDatabase = bunSqlite.Database;
+    if (BunDatabase) {
+      return {
+        kind: "bun",
+        open: (path) => {
+          var _a;
+          const rawDb = new BunDatabase(path);
+          configureSqliteRuntimeDatabase(rawDb, path);
+          const query = (_a = rawDb.query) == null ? void 0 : _a.bind(rawDb);
+          if (!query)
+            throw new Error(
+              "bun:sqlite database missing query method"
+            );
+          return createPreparedDatabaseAdapter(rawDb, query);
+        }
+      };
+    }
+  } catch (error) {
+    loadErrors.push(`bun:sqlite unavailable: ${String(error)}`);
+  }
+  try {
+    const nodeSqlite = requireFn(
+      /* webpackIgnore: true */
+      "node:sqlite"
+    );
+    const NodeDatabaseSync = nodeSqlite.DatabaseSync;
+    if (NodeDatabaseSync) {
+      return {
+        kind: "node",
+        open: (path) => {
+          var _a;
+          const rawDb = new NodeDatabaseSync(path);
+          configureSqliteRuntimeDatabase(rawDb, path);
+          const prepare = (_a = rawDb.prepare) == null ? void 0 : _a.bind(rawDb);
+          if (!prepare) {
+            throw new Error(
+              "node:sqlite DatabaseSync missing prepare method"
+            );
+          }
+          return createPreparedDatabaseAdapter(rawDb, prepare);
+        }
+      };
+    }
+  } catch (error) {
+    loadErrors.push(`node:sqlite unavailable: ${String(error)}`);
+  }
+  try {
+    const betterSqlite3Module = requireFn(
+      /* webpackIgnore: true */
+      "better-sqlite3"
+    );
+    const BetterSqlite3 = typeof betterSqlite3Module === "function" ? betterSqlite3Module : betterSqlite3Module.default;
+    if (BetterSqlite3) {
+      return {
+        kind: "better-sqlite3",
+        open: (path) => {
+          var _a;
+          const rawDb = new BetterSqlite3(path);
+          configureSqliteRuntimeDatabase(rawDb, path);
+          const prepare = (_a = rawDb.prepare) == null ? void 0 : _a.bind(rawDb);
+          if (!prepare) {
+            throw new Error(
+              "better-sqlite3 database missing prepare method"
+            );
+          }
+          return createPreparedDatabaseAdapter(rawDb, prepare);
+        }
+      };
+    }
+  } catch (error) {
+    loadErrors.push(`better-sqlite3 unavailable: ${String(error)}`);
+    throw new Error(
+      `No SQLite runtime available. Tried bun:sqlite, node:sqlite, and better-sqlite3. Install better-sqlite3 (e.g. "pnpm add better-sqlite3") if native runtimes are unavailable.
+${loadErrors.join("\n")}`
+    );
+  }
+  throw new Error(
+    `No SQLite runtime available. Tried bun:sqlite, node:sqlite, and better-sqlite3.
+${loadErrors.join("\n")}`
+  );
+}
+function computePrefixUpperBound(prefix) {
+  if (prefix.length === 0) {
+    return void 0;
+  }
+  const upperBound = new Uint8Array(prefix);
+  for (let i = upperBound.length - 1; i >= 0; i--) {
+    if (upperBound[i] !== 255) {
+      upperBound[i] += 1;
+      return upperBound.slice(0, i + 1);
+    }
+  }
+  return void 0;
+}
+function ensureUint8Array(value, fieldName) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error(`SQLite row field "${fieldName}" is not binary data`);
+}
+
+// src/drivers/file-system/kv-limits.ts
+var KV_MAX_KEY_SIZE = 2 * 1024;
+var KV_MAX_VALUE_SIZE = 128 * 1024;
+var KV_MAX_KEYS = 128;
+var KV_MAX_PUT_PAYLOAD_SIZE = 976 * 1024;
+var KV_MAX_STORAGE_SIZE = 10 * 1024 * 1024 * 1024;
+var KV_KEY_WRAPPER_OVERHEAD_SIZE = 2;
+function estimateKvSize(db) {
+  const row = db.get(
+    "SELECT COALESCE(SUM(LENGTH(key) + LENGTH(value)), 0) AS total FROM kv"
+  );
+  return row ? Number(_nullishCoalesce(row.total, () => ( 0))) : 0;
+}
+function validateKvKey(key, keyLabel = "key") {
+  if (key.byteLength + KV_KEY_WRAPPER_OVERHEAD_SIZE > KV_MAX_KEY_SIZE) {
+    throw new Error(`${keyLabel} is too long (max 2048 bytes)`);
+  }
+}
+function validateKvKeys(keys) {
+  if (keys.length > KV_MAX_KEYS) {
+    throw new Error("a maximum of 128 keys is allowed");
+  }
+  for (const key of keys) {
+    validateKvKey(key);
+  }
+}
+function validateKvEntries(entries, totalSize) {
+  if (entries.length > KV_MAX_KEYS) {
+    throw new Error("A maximum of 128 key-value entries is allowed");
+  }
+  let payloadSize = 0;
+  for (const [key, value] of entries) {
+    payloadSize += key.byteLength + KV_KEY_WRAPPER_OVERHEAD_SIZE + value.byteLength;
+  }
+  if (payloadSize > KV_MAX_PUT_PAYLOAD_SIZE) {
+    throw new Error("total payload is too large (max 976 KiB)");
+  }
+  const storageRemaining = Math.max(0, KV_MAX_STORAGE_SIZE - totalSize);
+  if (payloadSize > storageRemaining) {
+    throw new Error(
+      `not enough space left in storage (${storageRemaining} bytes remaining, current payload is ${payloadSize} bytes)`
+    );
+  }
+  for (const [key, value] of entries) {
+    validateKvKey(key);
+    if (value.byteLength > KV_MAX_VALUE_SIZE) {
+      throw new Error(
+        `value is too large (max ${KV_MAX_VALUE_SIZE / 1024} KiB)`
+      );
+    }
+  }
+}
+
+// src/drivers/file-system/global-state.ts
+var DEFAULT_LIST_LIMIT = 16384;
+function compareBytes(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+  }
+  return a.length - b.length;
+}
+var FileSystemGlobalState = class {
+  #storagePath;
+  #stateDir;
+  #dbsDir;
+  #alarmsDir;
+  #persist;
+  #sqliteRuntime;
+  #actorKvDatabases = /* @__PURE__ */ new Map();
+  // 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(options = {}) {
+    const { persist = true, customPath, useNativeSqlite = true } = options;
+    if (!useNativeSqlite) {
+      throw new Error(
+        "File-system driver no longer supports non-SQLite KV storage."
+      );
+    }
+    this.#persist = persist;
+    this.#sqliteRuntime = loadSqliteRuntime();
+    this.#storagePath = persist ? _nullishCoalesce(customPath, () => ( getStoragePath())) : "/tmp";
+    const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+    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 = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+        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,
+        sqliteRuntime: this.#sqliteRuntime.kind
+      });
+      try {
+        this.#cleanupTempFilesSync();
+      } catch (err) {
+        logger2().error({
+          msg: "failed to cleanup temp files",
+          error: err
+        });
+      }
+      try {
+        this.#migrateLegacyKvToSqliteOnStartupSync();
+      } catch (error) {
+        logger2().error({
+          msg: "failed legacy kv startup migration",
+          error
+        });
+        throw error;
+      }
+    } else {
+      logger2().debug({
+        msg: "memory driver ready",
+        sqliteRuntime: this.#sqliteRuntime.kind
+      });
+    }
+  }
+  getActorStatePath(actorId) {
+    return _chunkCGGGBIDPcjs.getNodePath.call(void 0, ).join(this.#stateDir, actorId);
+  }
+  getActorDbPath(actorId) {
+    return _chunkCGGGBIDPcjs.getNodePath.call(void 0, ).join(this.#dbsDir, `${actorId}.db`);
+  }
+  getActorAlarmPath(actorId) {
+    return _chunkCGGGBIDPcjs.getNodePath.call(void 0, ).join(this.#alarmsDir, actorId);
+  }
+  #getActorKvDatabasePath(actorId) {
+    if (this.#persist) {
+      return this.getActorDbPath(actorId);
+    }
+    return ":memory:";
+  }
+  #ensureActorKvTables(db) {
+    db.exec(`
+			CREATE TABLE IF NOT EXISTS kv (
+				key BLOB PRIMARY KEY NOT NULL,
+				value BLOB NOT NULL
+			)
+		`);
+  }
+  #getOrCreateActorKvDatabase(actorId) {
+    const existing = this.#actorKvDatabases.get(actorId);
+    if (existing) {
+      return existing;
+    }
+    const dbPath = this.#getActorKvDatabasePath(actorId);
+    if (this.#persist) {
+      const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+      ensureDirectoryExistsSync(path.dirname(dbPath));
+    }
+    let db;
+    try {
+      db = this.#sqliteRuntime.open(dbPath);
+    } catch (error) {
+      throw new Error(
+        `failed to open actor kv database for actor ${actorId} at ${dbPath}: ${error}`
+      );
+    }
+    this.#ensureActorKvTables(db);
+    this.#actorKvDatabases.set(actorId, db);
+    return db;
+  }
+  #closeActorKvDatabase(actorId) {
+    const db = this.#actorKvDatabases.get(actorId);
+    if (!db) {
+      return;
+    }
+    try {
+      db.close();
+    } finally {
+      this.#actorKvDatabases.delete(actorId);
+    }
+  }
+  #putKvEntriesInDb(db, entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    db.exec("BEGIN");
+    try {
+      for (const [key, value] of entries) {
+        db.run("INSERT OR REPLACE INTO kv (key, value) VALUES (?, ?)", [
+          key,
+          value
+        ]);
+      }
+      db.exec("COMMIT");
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch (e2) {
+      }
+      throw error;
+    }
+  }
+  #isKvDbPopulated(db) {
+    const row = db.get(
+      "SELECT COUNT(*) AS count FROM kv"
+    );
+    const count = row ? Number(row.count) : 0;
+    return count > 0;
+  }
+  #migrateLegacyKvToSqliteOnStartupSync() {
+    const fsSync = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+    if (!fsSync.existsSync(this.#stateDir)) {
+      return;
+    }
+    const actorIds = fsSync.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp."));
+    for (const actorId of actorIds) {
+      const statePath = this.getActorStatePath(actorId);
+      let state;
+      try {
+        const stateBytes = fsSync.readFileSync(statePath);
+        state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
+          new Uint8Array(stateBytes)
+        );
+      } catch (error) {
+        logger2().warn({
+          msg: "failed to parse actor state during startup migration",
+          actorId,
+          error
+        });
+        continue;
+      }
+      if (!state.kvStorage || state.kvStorage.length === 0) {
+        continue;
+      }
+      const dbPath = this.getActorDbPath(actorId);
+      const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+      ensureDirectoryExistsSync(path.dirname(dbPath));
+      const db = this.#sqliteRuntime.open(dbPath);
+      try {
+        this.#ensureActorKvTables(db);
+        if (this.#isKvDbPopulated(db)) {
+          continue;
+        }
+        const legacyEntries = state.kvStorage.map((entry) => [
+          new Uint8Array(entry.key),
+          new Uint8Array(entry.value)
+        ]);
+        this.#putKvEntriesInDb(db, legacyEntries);
+        logger2().info({
+          msg: "migrated legacy actor kv storage to sqlite",
+          actorId,
+          entryCount: legacyEntries.length
+        });
+      } finally {
+        db.close();
+      }
+    }
+  }
+  async *getActorsIterator(params) {
+    let actorIds = Array.from(this.#actors.keys()).sort();
+    const fsSync = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+    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) {
+    await this.#waitForActorStop(actorId);
+    let entry = this.#upsertEntry(actorId);
+    if (entry.state) {
+      throw new (0, _chunk6G7ZNM27cjs.ActorDuplicateKey)(name, key);
+    }
+    if (this.isActorStopping(actorId)) {
+      await this.#waitForActorStop(actorId);
+      entry = this.#upsertEntry(actorId);
+    }
+    if (entry.lifecycleState === 4 /* DESTROYED */) {
+      entry.lifecycleState = 0 /* NONEXISTENT */;
+      entry.generation = crypto.randomUUID();
+    }
+    const initialKvState = _chunkCGGGBIDPcjs.getInitialActorKvState.call(void 0, input);
+    await this.#withActorWrite(actorId, async (lockedEntry) => {
+      lockedEntry.state = {
+        actorId,
+        name,
+        key,
+        createdAt: BigInt(Date.now()),
+        kvStorage: [],
+        startTs: null,
+        connectableTs: null,
+        sleepTs: null,
+        destroyTs: null
+      };
+      lockedEntry.lifecycleState = 1 /* AWAKE */;
+      if (this.#persist) {
+        await this.#performWrite(
+          actorId,
+          lockedEntry.generation,
+          lockedEntry.state
+        );
+      }
+      if (initialKvState.length > 0) {
+        const db = this.#getOrCreateActorKvDatabase(actorId);
+        this.#putKvEntriesInDb(db, initialKvState);
+      }
+    });
+    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 = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+      const stateData = await fs.readFile(stateFilePath);
+      const loadedState = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
+        new Uint8Array(stateData)
+      );
+      entry.state = {
+        ...loadedState,
+        kvStorage: []
+      };
+      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) {
+    await this.#waitForActorStop(actorId);
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        await this.#waitForActorStop(actorId);
+        return await this.loadOrCreateActor(actorId, name, key, input);
+      }
+      if (entry.lifecycleState === 4 /* DESTROYED */) {
+        entry.lifecycleState = 0 /* NONEXISTENT */;
+        entry.generation = crypto.randomUUID();
+      }
+      const initialKvState = _chunkCGGGBIDPcjs.getInitialActorKvState.call(void 0, input);
+      await this.#withActorWrite(actorId, async (lockedEntry) => {
+        lockedEntry.state = {
+          actorId,
+          name,
+          key,
+          createdAt: BigInt(Date.now()),
+          kvStorage: [],
+          startTs: null,
+          connectableTs: null,
+          sleepTs: null,
+          destroyTs: null
+        };
+        if (this.#persist) {
+          await this.#performWrite(
+            actorId,
+            lockedEntry.generation,
+            lockedEntry.state
+          );
+        }
+        if (initialKvState.length > 0) {
+          const db = this.#getOrCreateActorKvDatabase(actorId);
+          this.#putKvEntriesInDb(db, initialKvState);
+        }
+      });
+    }
+    return entry;
+  }
+  async sleepActor(actorId) {
+    var _a, _b;
+    _invariant2.default.call(void 0, 
+      this.#persist,
+      "cannot sleep actor with memory driver, must use file system driver"
+    );
+    const actor = this.#upsertEntry(actorId);
+    _invariant2.default.call(void 0, actor, `tried to sleep ${actorId}, does not exist`);
+    if (this.isActorStopping(actorId)) {
+      return;
+    }
+    actor.lifecycleState = 2 /* STARTING_SLEEP */;
+    actor.stopPromise = _chunkMPLMTJY5cjs.promiseWithResolvers.call(void 0, 
+      (reason) => logger2().warn({
+        msg: "unhandled actor sleep stop promise rejection",
+        reason
+      })
+    );
+    if (actor.loadPromise) await actor.loadPromise.catch();
+    if ((_a = actor.startPromise) == null ? void 0 : _a.promise)
+      await actor.startPromise.promise.catch();
+    try {
+      if (actor.state) {
+        await this.#withActorWrite(actorId, async (lockedEntry) => {
+          if (!lockedEntry.state) {
+            return;
+          }
+          lockedEntry.state = {
+            ...lockedEntry.state,
+            sleepTs: BigInt(Date.now())
+          };
+          if (this.#persist) {
+            await this.#performWrite(
+              actorId,
+              lockedEntry.generation,
+              lockedEntry.state
+            );
+          }
+        });
+      }
+      _invariant2.default.call(void 0, actor.actor, "actor should be loaded");
+      await actor.actor.onStop("sleep");
+    } finally {
+      await this.#withActorWrite(actorId, async () => {
+      });
+      this.#closeActorKvDatabase(actorId);
+      (_b = actor.stopPromise) == null ? void 0 : _b.resolve();
+      actor.stopPromise = void 0;
+      this.#actors.delete(actorId);
+    }
+  }
+  async destroyActor(actorId) {
+    var _a, _b;
+    const actor = this.#upsertEntry(actorId);
+    if (this.isActorStopping(actorId)) {
+      return;
+    }
+    actor.lifecycleState = 3 /* STARTING_DESTROY */;
+    actor.stopPromise = _chunkMPLMTJY5cjs.promiseWithResolvers.call(void 0, 
+      (reason) => logger2().warn({
+        msg: "unhandled actor destroy stop promise rejection",
+        reason
+      })
+    );
+    if (actor.loadPromise) await actor.loadPromise.catch();
+    if ((_a = actor.startPromise) == null ? void 0 : _a.promise)
+      await actor.startPromise.promise.catch();
+    try {
+      if (actor.state) {
+        await this.#withActorWrite(actorId, async (lockedEntry) => {
+          if (!lockedEntry.state) {
+            return;
+          }
+          lockedEntry.state = {
+            ...lockedEntry.state,
+            destroyTs: BigInt(Date.now())
+          };
+          if (this.#persist) {
+            await this.#performWrite(
+              actorId,
+              lockedEntry.generation,
+              lockedEntry.state
+            );
+          }
+        });
+      }
+      if (actor.actor) {
+        await actor.actor.onStop("destroy");
+      }
+      await this.#withActorWrite(actorId, async () => {
+      });
+      this.#closeActorKvDatabase(actorId);
+      if (actor.alarmTimeout) {
+        actor.alarmTimeout.abort();
+      }
+      if (this.#persist) {
+        const fs = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+        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: _chunkMPLMTJY5cjs.stringifyError.call(void 0, 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: _chunkMPLMTJY5cjs.stringifyError.call(void 0, 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: _chunkMPLMTJY5cjs.stringifyError.call(void 0, err)
+                });
+              }
+            }
+          })()
+        ]);
+      }
+    } finally {
+      await this.#withActorWrite(actorId, async () => {
+      });
+      (_b = actor.stopPromise) == null ? void 0 : _b.resolve();
+      actor.stopPromise = void 0;
+      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;
+    }
+    await this.#withActorWrite(actorId, async () => {
+      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 #waitForActorStop(actorId) {
+    while (true) {
+      const entry = this.#actors.get(actorId);
+      if (!(entry == null ? void 0 : entry.stopPromise)) {
+        return;
+      }
+      try {
+        await entry.stopPromise.promise;
+      } catch (e3) {
+        return;
+      }
+    }
+  }
+  async #withActorWrite(actorId, fn) {
+    const entry = this.#actors.get(actorId);
+    _invariant2.default.call(void 0, entry, "actor entry does not exist");
+    const previousWrite = entry.pendingWriteResolver;
+    const currentWrite = _chunkMPLMTJY5cjs.promiseWithResolvers.call(void 0, 
+      (reason) => logger2().warn({
+        msg: "unhandled kv write promise rejection",
+        reason
+      })
+    );
+    entry.pendingWriteResolver = currentWrite;
+    if (previousWrite) {
+      try {
+        await previousWrite.promise;
+      } catch (e4) {
+      }
+    }
+    try {
+      return await fn(entry);
+    } finally {
+      currentWrite.resolve();
+      if (entry.pendingWriteResolver === currentWrite) {
+        entry.pendingWriteResolver = void 0;
+      }
+    }
+  }
+  async #waitForPendingWrite(actorId) {
+    const entry = this.#actors.get(actorId);
+    if (!(entry == null ? void 0 : entry.pendingWriteResolver)) {
+      return;
+    }
+    while (entry.pendingWriteResolver) {
+      const pending = entry.pendingWriteResolver;
+      try {
+        await pending.promise;
+      } catch (e5) {
+      }
+    }
+  }
+  async setActorAlarm(actorId, timestamp) {
+    const entry = this.#actors.get(actorId);
+    _invariant2.default.call(void 0, 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 = _chunkCGGGBIDPcjs.getNodeCrypto.call(void 0, );
+      const tempPath = `${alarmPath}.tmp.${crypto2.randomUUID()}`;
+      try {
+        const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+        await ensureDirectoryExists(path.dirname(alarmPath));
+        const alarmData = {
+          actorId,
+          timestamp: BigInt(timestamp)
+        };
+        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
+          alarmData,
+          CURRENT_VERSION
+        );
+        const fs = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+        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 = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+          await fs.unlink(tempPath);
+        } catch (e6) {
+        }
+        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 = _chunkCGGGBIDPcjs.getNodeCrypto.call(void 0, );
+    const tempPath = `${dataPath}.tmp.${crypto2.randomUUID()}`;
+    try {
+      const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+      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 = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+      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 = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+        await fs.unlink(tempPath);
+      } catch (e7) {
+      }
+      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;
+    await this.#waitForActorStop(actorId);
+    let 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;
+      _invariant2.default.call(void 0, entry.actor, "actor should have loaded");
+      return entry.actor;
+    }
+    if (entry.actor) {
+      if (entry.actor.isStopping || this.isActorStopping(actorId)) {
+        await this.#waitForActorStop(actorId);
+        entry = await this.loadActor(actorId);
+        if (!entry.state) {
+          throw new Error(
+            `Actor does not exist and cannot be started: "${actorId}"`
+          );
+        }
+      } else {
+        return entry.actor;
+      }
+    }
+    entry.startPromise = _chunkMPLMTJY5cjs.promiseWithResolvers.call(void 0, 
+      (reason) => logger2().warn({
+        msg: "unhandled actor start promise rejection",
+        reason
+      })
+    );
+    try {
+      const definition = _chunkJJNZQDUNcjs.lookupInRegistry.call(void 0, config4, entry.state.name);
+      entry.actor = await definition.instantiate();
+      entry.lifecycleState = 1 /* AWAKE */;
+      await entry.actor.start(
+        actorDriver,
+        inlineClient,
+        actorId,
+        entry.state.name,
+        entry.state.key,
+        "unknown"
+      );
+      const now = BigInt(Date.now());
+      await this.#withActorWrite(actorId, async (lockedEntry) => {
+        if (!lockedEntry.state) {
+          throw new Error(
+            `Actor does not exist and cannot be started: "${actorId}"`
+          );
+        }
+        lockedEntry.state = {
+          ...lockedEntry.state,
+          startTs: now,
+          connectableTs: now,
+          sleepTs: null
+          // Clear sleep timestamp when actor wakes up
+        };
+        if (this.#persist) {
+          await this.#performWrite(
+            actorId,
+            lockedEntry.generation,
+            lockedEntry.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 = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+      const files = fsSync.existsSync(this.#alarmsDir) ? fsSync.readdirSync(this.#alarmsDir) : [];
+      for (const file of files) {
+        if (file.includes(".tmp.")) continue;
+        const path = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+        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: _chunkMPLMTJY5cjs.stringifyError.call(void 0, 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 = _chunkMPLMTJY5cjs.setLongTimeout.call(void 0, async () => {
+      entry.alarmTimestamp = void 0;
+      if (this.#persist) {
+        try {
+          const fs = _chunkCGGGBIDPcjs.getNodeFs.call(void 0, );
+          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: _chunkMPLMTJY5cjs.stringifyError.call(void 0, 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;
+        _invariant2.default.call(void 0, runnerParams, "missing runner params");
+        if (!loaded.actor) {
+          await this.startActor(
+            runnerParams.config,
+            runnerParams.inlineClient,
+            runnerParams.actorDriver,
+            actorId
+          );
+        }
+        _invariant2.default.call(void 0, loaded.actor, "actor should be loaded after wake");
+        await loaded.actor.onAlarm();
+      } catch (err) {
+        logger2().error({
+          msg: "failed to handle alarm",
+          actorId,
+          error: _chunkMPLMTJY5cjs.stringifyError.call(void 0, err)
+        });
+      }
+    }, delay);
+  }
+  /**
+   * Cleanup stale temp files on startup (synchronous)
+   */
+  #cleanupTempFilesSync() {
+    try {
+      const fsSync = _chunkCGGGBIDPcjs.getNodeFsSync.call(void 0, );
+      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 = _chunkCGGGBIDPcjs.getNodePath.call(void 0, );
+          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) {
+    await this.loadActor(actorId);
+    await this.#withActorWrite(actorId, async (entry) => {
+      if (!entry.state) {
+        if (this.isActorStopping(actorId)) {
+          return;
+        }
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+      const db = this.#getOrCreateActorKvDatabase(actorId);
+      const totalSize = estimateKvSize(db);
+      validateKvEntries(entries, totalSize);
+      this.#putKvEntriesInDb(db, entries);
+    });
+  }
+  /**
+   * Batch get KV entries for an actor.
+   */
+  async kvBatchGet(actorId, keys) {
+    const entry = await this.loadActor(actorId);
+    await this.#waitForPendingWrite(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} is stopping`);
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    validateKvKeys(keys);
+    const db = this.#getOrCreateActorKvDatabase(actorId);
+    const results = [];
+    for (const key of keys) {
+      const row = db.get(
+        "SELECT value FROM kv WHERE key = ?",
+        [key]
+      );
+      if (!row) {
+        results.push(null);
+        continue;
+      }
+      results.push(ensureUint8Array(row.value, "value"));
+    }
+    return results;
+  }
+  /**
+   * Batch delete KV entries for an actor.
+   */
+  async kvBatchDelete(actorId, keys) {
+    await this.loadActor(actorId);
+    await this.#withActorWrite(actorId, async (entry) => {
+      if (!entry.state) {
+        if (this.isActorStopping(actorId)) {
+          return;
+        }
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+      if (keys.length === 0) {
+        return;
+      }
+      validateKvKeys(keys);
+      const db = this.#getOrCreateActorKvDatabase(actorId);
+      db.exec("BEGIN");
+      try {
+        for (const key of keys) {
+          db.run("DELETE FROM kv WHERE key = ?", [key]);
+        }
+        db.exec("COMMIT");
+      } catch (error) {
+        try {
+          db.exec("ROLLBACK");
+        } catch (e8) {
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Delete KV entries in the half-open range [start, end).
+   */
+  async kvDeleteRange(actorId, start, end) {
+    await this.loadActor(actorId);
+    await this.#withActorWrite(actorId, async (entry) => {
+      if (!entry.state) {
+        if (this.isActorStopping(actorId)) {
+          return;
+        }
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+      validateKvKey(start, "start key");
+      validateKvKey(end, "end key");
+      if (compareBytes(start, end) >= 0) {
+        return;
+      }
+      const db = this.#getOrCreateActorKvDatabase(actorId);
+      db.run("DELETE FROM kv WHERE key >= ? AND key < ?", [start, end]);
+    });
+  }
+  /**
+   * List KV entries with a given prefix for an actor.
+   */
+  async kvListPrefix(actorId, prefix, options) {
+    const entry = await this.loadActor(actorId);
+    await this.#waitForPendingWrite(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} is destroying`);
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    validateKvKey(prefix, "prefix key");
+    const db = this.#getOrCreateActorKvDatabase(actorId);
+    const upperBound = computePrefixUpperBound(prefix);
+    const direction = (options == null ? void 0 : options.reverse) ? "DESC" : "ASC";
+    const limit = _nullishCoalesce((options == null ? void 0 : options.limit), () => ( DEFAULT_LIST_LIMIT));
+    const rows = upperBound ? db.all(
+      `SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ${direction} LIMIT ?`,
+      [prefix, upperBound, limit]
+    ) : db.all(
+      `SELECT key, value FROM kv WHERE key >= ? ORDER BY key ${direction} LIMIT ?`,
+      [prefix, limit]
+    );
+    return rows.map((row) => [
+      ensureUint8Array(row.key, "key"),
+      ensureUint8Array(row.value, "value")
+    ]);
+  }
+  /**
+   * List KV entries in the half-open range [start, end).
+   */
+  async kvListRange(actorId, start, end, options) {
+    const entry = await this.loadActor(actorId);
+    await this.#waitForPendingWrite(actorId);
+    if (!entry.state) {
+      if (this.isActorStopping(actorId)) {
+        throw new Error(`Actor ${actorId} is destroying`);
+      } else {
+        throw new Error(`Actor ${actorId} state not loaded`);
+      }
+    }
+    validateKvKey(start, "start key");
+    validateKvKey(end, "end key");
+    if (compareBytes(start, end) >= 0) {
+      return [];
+    }
+    const db = this.#getOrCreateActorKvDatabase(actorId);
+    const direction = (options == null ? void 0 : options.reverse) ? "DESC" : "ASC";
+    const limit = _nullishCoalesce((options == null ? void 0 : options.limit), () => ( DEFAULT_LIST_LIMIT));
+    const rows = db.all(
+      `SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ${direction} LIMIT ?`,
+      [start, end, limit]
+    );
+    return rows.map((row) => [
+      ensureUint8Array(row.key, "key"),
+      ensureUint8Array(row.value, "value")
+    ]);
+  }
+};
+
+// src/drivers/file-system/manager.ts
+
+var FileSystemManagerDriver = class {
+  #config;
+  #state;
+  #driverConfig;
+  #getUpgradeWebSocket;
+  #actorDriver;
+  #actorRouter;
+  constructor(config4, state, driverConfig) {
+    this.#config = config4;
+    this.#state = state;
+    this.#driverConfig = driverConfig;
+    const inlineClient = _chunkGUHXWPGBcjs.createClientWithDriver.call(void 0, this);
+    this.#actorDriver = this.#driverConfig.actor(
+      config4,
+      this,
+      inlineClient
+    );
+    this.#actorRouter = _chunkJJNZQDUNcjs.createActorRouter.call(void 0, 
+      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 { gatewayId, requestId } = createHibernatableRequestMetadata();
+    const wsHandler = await _chunkHNE2AK6Ccjs.routeWebSocket.call(void 0, 
+      fakeRequest,
+      pathOnly,
+      {},
+      this.#config,
+      this.#actorDriver,
+      actorId,
+      encoding,
+      params,
+      gatewayId,
+      requestId,
+      true,
+      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.default.call(void 0, upgradeWebSocket, "missing getUpgradeWebSocket");
+    const pathOnly = path.split("?")[0];
+    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
+    const { gatewayId, requestId } = createHibernatableRequestMetadata();
+    const wsHandler = await _chunkHNE2AK6Ccjs.routeWebSocket.call(void 0, 
+      // TODO: Create new request with new path
+      c.req.raw,
+      normalizedPath,
+      c.req.header(),
+      this.#config,
+      this.#actorDriver,
+      actorId,
+      encoding,
+      params,
+      gatewayId,
+      requestId,
+      true,
+      false
+    );
+    return upgradeWebSocket(() => wsHandler)(c, _chunkMPLMTJY5cjs.noopNext.call(void 0, ));
+  }
+  async buildGatewayUrl(actorId) {
+    const port = _nullishCoalesce(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 (0, _chunk6G7ZNM27cjs.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 = _nullishCoalesce(a.createTs, () => ( 0));
+      const bTs = _nullishCoalesce(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
+  };
+}
+function createHibernatableRequestMetadata() {
+  const gatewayId = new Uint8Array(4);
+  const requestId = new Uint8Array(4);
+  crypto.getRandomValues(gatewayId);
+  crypto.getRandomValues(requestId);
+  return {
+    gatewayId: gatewayId.buffer.slice(0),
+    requestId: requestId.buffer.slice(0)
+  };
+}
+
+// src/drivers/file-system/mod.ts
+var CreateFileSystemDriverOptionsSchema = _zod.z.object({
+  /** Custom path for storage. */
+  path: _zod.z.string().optional(),
+  /** Deprecated: file-system driver KV is now always SQLite-backed. */
+  useNativeSqlite: _zod.z.boolean().optional()
+});
+function createFileSystemOrMemoryDriver(persist = true, options) {
+  _chunkCGGGBIDPcjs.importNodeDependencies.call(void 0, );
+  if ((options == null ? void 0 : options.useNativeSqlite) === false) {
+    throw new Error(
+      "File-system driver no longer supports non-SQLite KV storage. Remove useNativeSqlite: false."
+    );
+  }
+  const stateOptions = {
+    persist,
+    customPath: options == null ? void 0 : options.path,
+    useNativeSqlite: true
+  };
+  const state = new FileSystemGlobalState(stateOptions);
+  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) {
+  const validatedOpts = opts ? CreateFileSystemDriverOptionsSchema.parse(opts) : void 0;
+  return createFileSystemOrMemoryDriver(true, validatedOpts);
+}
+function createMemoryDriver() {
+  return createFileSystemOrMemoryDriver(false);
+}
+
+
+
+
+
+
+
+
+exports.InlineWebSocketAdapter = InlineWebSocketAdapter; exports.getStoragePath = getStoragePath; exports.ensureDirectoryExists = ensureDirectoryExists; exports.createFileSystemOrMemoryDriver = createFileSystemOrMemoryDriver; exports.createFileSystemDriver = createFileSystemDriver; exports.createMemoryDriver = createMemoryDriver;
+//# sourceMappingURL=chunk-2LY7RW3Y.cjs.map