rivetkit 2.1.4 → 2.1.6-rc.1

package/dist/tsup/{chunk-KTWY3K6Z.js → chunk-YGYGANCA.js}

@@ -1,6 +1,6 @@
 import {
-  createClientWithDriver
-} from "./chunk-I6PL6QIY.js";
+  decodeWorkflowHistoryTransport
+} from "./chunk-EONWXYMN.js";
 import {
   ACTOR_VERSIONED,
   ActionContext,
@@ -27,20 +27,11 @@ import {
   ToClientSchema,
   WebSocketContext,
   createHttpDriver,
-  getInitialActorKvState,
-  getNodeCrypto,
-  getNodeFs,
-  getNodeFsSync,
-  getNodeOs,
-  getNodePath,
-  getRequireFn,
   handleAction,
   handleQueueSend,
   handleRawRequest,
   handleRouteError,
   handleRouteNotFound,
-  importNodeDependencies,
-  importSqliteVfs,
   inspectorLogger,
   loggerMiddleware,
   parseWebSocketProtocols,
@@ -48,7 +39,7 @@ import {
   routeWebSocket,
   serializeActorKey,
   timingSafeEqual
-} from "./chunk-UDMRZR6A.js";
+} from "./chunk-PQWI44WD.js";
 import {
   ActorContext,
   DeadlineError,
@@ -69,7 +60,7 @@ import {
   queueMessagesPrefix,
   queueMetadataKey,
   tracesStoragePrefix
-} from "./chunk-ANKZ2FS6.js";
+} from "./chunk-C22JYHVT.js";
 import {
   EXTRA_ERROR_LOG,
   SinglePromiseQueue,
@@ -78,21 +69,17 @@ import {
   bufferToArrayBuffer,
   getBaseLogger,
   getIncludeTarget,
-  getLogger,
   getRivetExperimentalOtel,
   isCborSerializable,
   isDev,
   noopNext,
   promiseWithResolvers,
-  setLongTimeout,
   stringifyError
-} from "./chunk-DZXDUGLL.js";
+} from "./chunk-VWYO36X4.js";
 import {
   ActionNotFound,
   ActionTimedOut,
   ActorAborted,
-  ActorDuplicateKey,
-  ActorStopping,
   DatabaseNotEnabled,
   Forbidden,
   InternalError,
@@ -107,18 +94,255 @@ import {
   RequestHandlerNotDefined,
   StateNotEnabled,
   VarsNotEnabled
-} from "./chunk-7HTNH26M.js";
+} from "./chunk-AKUJ5OTO.js";
 
 // src/actor/instance/mod.ts
 import {
   createNoopTraces,
   createTraces
 } from "@rivetkit/traces";
+
+// src/actor/metrics.ts
+var ActorMetrics = class {
+  // KV operations
+  kvGet = { calls: 0, keys: 0, totalMs: 0 };
+  kvGetBatch = { calls: 0, keys: 0, totalMs: 0 };
+  kvPut = { calls: 0, keys: 0, totalMs: 0 };
+  kvPutBatch = { calls: 0, keys: 0, totalMs: 0 };
+  kvDeleteBatch = { calls: 0, keys: 0, totalMs: 0 };
+  // SQL statements
+  sqlSelects = 0;
+  sqlInserts = 0;
+  sqlUpdates = 0;
+  sqlDeletes = 0;
+  sqlOther = 0;
+  sqlTotalMs = 0;
+  // Actions
+  actionCalls = 0;
+  actionErrors = 0;
+  actionTotalMs = 0;
+  // Connections
+  connectionsOpened = 0;
+  connectionsClosed = 0;
+  trackSql(query, durationMs) {
+    const token = query.trimStart().slice(0, 8).toUpperCase();
+    if (token.startsWith("SELECT") || token.startsWith("PRAGMA") || token.startsWith("WITH")) {
+      this.sqlSelects++;
+    } else if (token.startsWith("INSERT")) {
+      this.sqlInserts++;
+    } else if (token.startsWith("UPDATE")) {
+      this.sqlUpdates++;
+    } else if (token.startsWith("DELETE")) {
+      this.sqlDeletes++;
+    } else {
+      this.sqlOther++;
+    }
+    this.sqlTotalMs += durationMs;
+  }
+  snapshot() {
+    return {
+      kv_operations: {
+        type: "labeled_timing",
+        help: "KV round trips by operation type",
+        values: {
+          get: { ...this.kvGet },
+          getBatch: { ...this.kvGetBatch },
+          put: { ...this.kvPut },
+          putBatch: { ...this.kvPutBatch },
+          deleteBatch: { ...this.kvDeleteBatch }
+        }
+      },
+      sql_statements: {
+        type: "labeled_counter",
+        help: "SQL statements executed by type",
+        values: {
+          select: this.sqlSelects,
+          insert: this.sqlInserts,
+          update: this.sqlUpdates,
+          delete: this.sqlDeletes,
+          other: this.sqlOther
+        }
+      },
+      sql_duration_ms: {
+        type: "counter",
+        help: "Total SQL execution time in milliseconds",
+        value: this.sqlTotalMs
+      },
+      action_calls: {
+        type: "counter",
+        help: "Total action invocations",
+        value: this.actionCalls
+      },
+      action_errors: {
+        type: "counter",
+        help: "Total action errors",
+        value: this.actionErrors
+      },
+      action_duration_ms: {
+        type: "counter",
+        help: "Total action execution time in milliseconds",
+        value: this.actionTotalMs
+      },
+      connections_opened: {
+        type: "counter",
+        help: "Total WebSocket connections opened",
+        value: this.connectionsOpened
+      },
+      connections_closed: {
+        type: "counter",
+        help: "Total WebSocket connections closed",
+        value: this.connectionsClosed
+      }
+    };
+  }
+};
+
+// src/actor/instance/mod.ts
 import invariant2 from "invariant";
 
 // src/inspector/actor-inspector.ts
-import * as cbor from "cbor-x";
+import * as cbor2 from "cbor-x";
 import { createNanoEvents } from "nanoevents";
+
+// src/inspector/workflow-history-json.ts
+import * as cbor from "cbor-x";
+function decodeWorkflowCbor(data) {
+  if (data === null) {
+    return null;
+  }
+  try {
+    return cbor.decode(new Uint8Array(data));
+  } catch {
+    return null;
+  }
+}
+function serializeWorkflowLocation(location) {
+  return location.map((segment) => {
+    if (segment.tag === "WorkflowNameIndex") {
+      return {
+        tag: segment.tag,
+        val: segment.val
+      };
+    }
+    return {
+      tag: segment.tag,
+      val: {
+        loop: segment.val.loop,
+        iteration: segment.val.iteration
+      }
+    };
+  });
+}
+function serializeWorkflowBranches(branches) {
+  return Object.fromEntries(
+    Array.from(branches.entries()).map(([name, branch]) => [
+      name,
+      {
+        status: branch.status,
+        output: decodeWorkflowCbor(branch.output),
+        error: branch.error
+      }
+    ])
+  );
+}
+function serializeWorkflowEntryKind(kind) {
+  switch (kind.tag) {
+    case "WorkflowStepEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          output: decodeWorkflowCbor(kind.val.output),
+          error: kind.val.error
+        }
+      };
+    case "WorkflowLoopEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          state: decodeWorkflowCbor(kind.val.state),
+          iteration: kind.val.iteration,
+          output: decodeWorkflowCbor(kind.val.output)
+        }
+      };
+    case "WorkflowSleepEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          deadline: Number(kind.val.deadline),
+          state: kind.val.state
+        }
+      };
+    case "WorkflowMessageEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          name: kind.val.name,
+          messageData: decodeWorkflowCbor(kind.val.messageData)
+        }
+      };
+    case "WorkflowRollbackCheckpointEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          name: kind.val.name
+        }
+      };
+    case "WorkflowJoinEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          branches: serializeWorkflowBranches(kind.val.branches)
+        }
+      };
+    case "WorkflowRaceEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          winner: kind.val.winner,
+          branches: serializeWorkflowBranches(kind.val.branches)
+        }
+      };
+    case "WorkflowRemovedEntry":
+      return {
+        tag: kind.tag,
+        val: {
+          originalType: kind.val.originalType,
+          originalName: kind.val.originalName
+        }
+      };
+  }
+}
+function serializeWorkflowHistoryForJson(data) {
+  if (data === null) {
+    return null;
+  }
+  const history = decodeWorkflowHistoryTransport(data);
+  return {
+    nameRegistry: [...history.nameRegistry],
+    entries: history.entries.map((entry) => ({
+      id: entry.id,
+      location: serializeWorkflowLocation(entry.location),
+      kind: serializeWorkflowEntryKind(entry.kind)
+    })),
+    entryMetadata: Object.fromEntries(
+      Array.from(history.entryMetadata.entries()).map(([entryId, meta]) => [
+        entryId,
+        {
+          status: meta.status,
+          error: meta.error,
+          attempts: meta.attempts,
+          lastAttemptAt: Number(meta.lastAttemptAt),
+          createdAt: Number(meta.createdAt),
+          completedAt: meta.completedAt === null ? null : Number(meta.completedAt),
+          rollbackCompletedAt: meta.rollbackCompletedAt === null ? null : Number(meta.rollbackCompletedAt),
+          rollbackError: meta.rollbackError
+        }
+      ])
+    )
+  };
+}
+
+// src/inspector/actor-inspector.ts
 var ActorInspector = class {
   constructor(actor) {
     this.actor = actor;
@@ -145,9 +369,7 @@ var ActorInspector = class {
     const maxSize = this.actor.config.options.maxQueueSize;
     const safeLimit = Math.max(0, Math.floor(limit));
     const messages = await this.actor.queueManager.getMessages();
-    const sorted = messages.sort(
-      (a, b) => a.createdAt - b.createdAt
-    );
+    const sorted = messages.sort((a, b) => a.createdAt - b.createdAt);
     const limited = safeLimit > 0 ? sorted.slice(0, safeLimit) : [];
     return {
       size: BigInt(this.#lastQueueSize),
@@ -218,7 +440,7 @@ var ActorInspector = class {
         records: ((_a = countResult == null ? void 0 : countResult[0]) == null ? void 0 : _a.count) ?? 0
       });
     }
-    return bufferToArrayBuffer(cbor.encode({ tables: tableInfos }));
+    return bufferToArrayBuffer(cbor2.encode({ tables: tableInfos }));
   }
   async getDatabaseTableRows(table, limit, offset) {
     if (!this.isDatabaseEnabled()) {
@@ -233,7 +455,7 @@ var ActorInspector = class {
       safeLimit,
       safeOffset
     );
-    return bufferToArrayBuffer(cbor.encode(result));
+    return bufferToArrayBuffer(cbor2.encode(result));
   }
   isStateEnabled() {
     return this.actor.stateEnabled;
@@ -243,7 +465,7 @@ var ActorInspector = class {
       throw new StateNotEnabled();
     }
     return bufferToArrayBuffer(
-      cbor.encode(this.actor.stateManager.persistRaw.state)
+      cbor2.encode(this.actor.stateManager.persistRaw.state)
     );
   }
   getRpcs() {
@@ -259,7 +481,7 @@ var ActorInspector = class {
         type: (_a = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.type,
         id,
         details: bufferToArrayBuffer(
-          cbor.encode({
+          cbor2.encode({
             type: (_b = conn[CONN_DRIVER_SYMBOL]) == null ? void 0 : _b.type,
             params: conn.params,
             stateEnabled: connStateManager.stateEnabled,
@@ -277,7 +499,7 @@ var ActorInspector = class {
     if (!this.actor.stateEnabled) {
       throw new StateNotEnabled();
     }
-    this.actor.stateManager.state = cbor.decode(Buffer.from(state));
+    this.actor.stateManager.state = cbor2.decode(Buffer.from(state));
     await this.actor.stateManager.saveState({ immediate: true });
   }
   async executeAction(name, params) {
@@ -291,11 +513,11 @@ var ActorInspector = class {
     );
     try {
       return bufferToArrayBuffer(
-        cbor.encode(
+        cbor2.encode(
           await this.actor.executeAction(
             new ActionContext(this.actor, conn),
             name,
-            cbor.decode(Buffer.from(params))
+            cbor2.decode(Buffer.from(params))
           )
         )
       );
@@ -318,6 +540,20 @@ var ActorInspector = class {
     this.actor.stateManager.state = state;
     await this.actor.stateManager.saveState({ immediate: true });
   }
+  async getDatabaseSchemaJson() {
+    return toHttpJsonCompatible(
+      cbor2.decode(Buffer.from(await this.getDatabaseSchema()))
+    );
+  }
+  async getDatabaseTableRowsJson(table, limit, offset) {
+    return toHttpJsonCompatible(
+      cbor2.decode(
+        Buffer.from(
+          await this.getDatabaseTableRows(table, limit, offset)
+        )
+      )
+    );
+  }
   getConnectionsJson() {
     return Array.from(
       this.actor.connectionManager.connections.entries()
@@ -361,11 +597,10 @@ var ActorInspector = class {
     return result;
   }
   getWorkflowHistoryJson() {
-    const bigIntReplacer = (_key, value) => typeof value === "bigint" ? Number(value) : value;
-    const history = this.getWorkflowHistory();
-    const safeHistory = history ? JSON.parse(JSON.stringify(history, bigIntReplacer)) : null;
     return {
-      history: safeHistory,
+      history: serializeWorkflowHistoryForJson(
+        this.getWorkflowHistory()
+      ),
       isWorkflowEnabled: this.isWorkflowEnabled()
     };
   }
@@ -385,14 +620,22 @@ var ActorInspector = class {
 function escapeDoubleQuotes(value) {
   return value.replace(/"/g, '""');
 }
+function toHttpJsonCompatible(value) {
+  return JSON.parse(
+    JSON.stringify(
+      value,
+      (_key, nestedValue) => typeof nestedValue === "bigint" ? Number(nestedValue) : nestedValue instanceof Uint8Array ? Array.from(nestedValue) : nestedValue
+    )
+  );
+}
 
 // src/actor/conn/persisted.ts
-import * as cbor2 from "cbor-x";
+import * as cbor3 from "cbor-x";
 function convertConnToBarePersistedConn(persist) {
   return {
     id: persist.id,
-    parameters: bufferToArrayBuffer(cbor2.encode(persist.parameters)),
-    state: bufferToArrayBuffer(cbor2.encode(persist.state)),
+    parameters: bufferToArrayBuffer(cbor3.encode(persist.parameters)),
+    state: bufferToArrayBuffer(cbor3.encode(persist.state)),
     subscriptions: persist.subscriptions.map((sub) => ({
       eventName: sub.eventName
     })),
@@ -407,8 +650,8 @@ function convertConnToBarePersistedConn(persist) {
 function convertConnFromBarePersistedConn(bareData) {
   return {
     id: bareData.id,
-    parameters: cbor2.decode(new Uint8Array(bareData.parameters)),
-    state: cbor2.decode(new Uint8Array(bareData.state)),
+    parameters: cbor3.decode(new Uint8Array(bareData.parameters)),
+    state: cbor3.decode(new Uint8Array(bareData.state)),
     subscriptions: bareData.subscriptions.map((sub) => ({
       eventName: sub.eventName
     })),
@@ -680,7 +923,9 @@ var ConnectionManager = class {
       if (conn.isHibernatable) {
         const key = makeConnKey(conn.id);
         try {
-          await this.#actor.driver.kvBatchDelete(this.#actor.id, [key]);
+          await this.#actor.driver.kvBatchDelete(this.#actor.id, [
+            key
+          ]);
           this.#actor.rLog.debug({
             msg: "removed connection from KV",
             connId: conn.id
@@ -844,7 +1089,7 @@ var ConnectionManager = class {
 };
 
 // src/actor/instance/event-manager.ts
-import * as cbor3 from "cbor-x";
+import * as cbor4 from "cbor-x";
 var EventManager = class {
   #actor;
   #subscriptionIndex = /* @__PURE__ */ new Map();
@@ -972,7 +1217,7 @@ var EventManager = class {
           tag: "Event",
           val: {
             name: value.name,
-            args: bufferToArrayBuffer(cbor3.encode(value.args))
+            args: bufferToArrayBuffer(cbor4.encode(value.args))
           }
         }
       })
@@ -1064,12 +1309,12 @@ var EventManager = class {
 };
 
 // src/actor/instance/persisted.ts
-import * as cbor4 from "cbor-x";
+import * as cbor5 from "cbor-x";
 function convertActorToBarePersisted(persist) {
   return {
-    input: persist.input !== void 0 ? bufferToArrayBuffer(cbor4.encode(persist.input)) : null,
+    input: persist.input !== void 0 ? bufferToArrayBuffer(cbor5.encode(persist.input)) : null,
     hasInitialized: persist.hasInitialized,
-    state: bufferToArrayBuffer(cbor4.encode(persist.state)),
+    state: bufferToArrayBuffer(cbor5.encode(persist.state)),
     scheduledEvents: persist.scheduledEvents.map((event) => ({
       eventId: event.eventId,
       timestamp: BigInt(event.timestamp),
@@ -1080,9 +1325,9 @@ function convertActorToBarePersisted(persist) {
 }
 function convertActorFromBarePersisted(bareData) {
   return {
-    input: bareData.input ? cbor4.decode(new Uint8Array(bareData.input)) : void 0,
+    input: bareData.input ? cbor5.decode(new Uint8Array(bareData.input)) : void 0,
     hasInitialized: bareData.hasInitialized,
-    state: cbor4.decode(new Uint8Array(bareData.state)),
+    state: cbor5.decode(new Uint8Array(bareData.state)),
     scheduledEvents: bareData.scheduledEvents.map((event) => ({
       eventId: event.eventId,
       timestamp: Number(event.timestamp),
@@ -1093,7 +1338,7 @@ function convertActorFromBarePersisted(bareData) {
 }
 
 // src/actor/instance/queue-manager.ts
-import * as cbor5 from "cbor-x";
+import * as cbor6 from "cbor-x";
 var DEFAULT_METADATA = {
   nextId: 1n,
   size: 0
@@ -1156,7 +1401,7 @@ var QueueManager = class {
       throw new QueueMessageInvalid(invalidPath);
     }
     const createdAt = Date.now();
-    const bodyCborBuffer = cbor5.encode(body);
+    const bodyCborBuffer = cbor6.encode(body);
     const encodedMessage = QUEUE_MESSAGE_VERSIONED.serializeWithEmbeddedVersion(
       {
         name,
@@ -1419,7 +1664,7 @@ var QueueManager = class {
         const decodedPayload = QUEUE_MESSAGE_VERSIONED.deserializeWithEmbeddedVersion(
           value
         );
-        const body = cbor5.decode(new Uint8Array(decodedPayload.body));
+        const body = cbor6.decode(new Uint8Array(decodedPayload.body));
         decoded.push({
           id: messageId,
           name: decodedPayload.name,
@@ -1527,7 +1772,7 @@ var QueueManager = class {
 };
 
 // src/actor/instance/schedule-manager.ts
-import * as cbor6 from "cbor-x";
+import * as cbor7 from "cbor-x";
 var ScheduleManager = class {
   #actor;
   #actorDriver;
@@ -1536,10 +1781,10 @@ var ScheduleManager = class {
   // ActorConfig type
   #persist;
   // Reference to PersistedActor
-  constructor(actor, actorDriver, config4) {
+  constructor(actor, actorDriver, config) {
     this.#actor = actor;
     this.#actorDriver = actorDriver;
-    this.#config = config4;
+    this.#config = config;
   }
   // MARK: - Public API
   /**
@@ -1561,7 +1806,7 @@ var ScheduleManager = class {
       eventId: crypto.randomUUID(),
       timestamp,
       action,
-      args: bufferToArrayBuffer(cbor6.encode(args))
+      args: bufferToArrayBuffer(cbor7.encode(args))
     };
     this.#actor.emitTraceEvent("schedule.created", {
       "rivet.schedule.event_id": newEvent.eventId,
@@ -1760,7 +2005,7 @@ var ScheduleManager = class {
             `Scheduled event action ${event.action} is not a function (got ${typeof fn})`
           );
         }
-        const args = event.args ? cbor6.decode(new Uint8Array(event.args)) : [];
+        const args = event.args ? cbor7.decode(new Uint8Array(event.args)) : [];
         const result = this.#actor.traces.withSpan(
           span,
           () => fn.call(void 0, this.#actor.actorContext, ...args)
@@ -1849,11 +2094,11 @@ var StateManager = class {
   #config;
   // ActorConfig type
   #stateSaveInterval;
-  constructor(actor, actorDriver, config4) {
+  constructor(actor, actorDriver, config) {
     this.#actor = actor;
     this.#actorDriver = actorDriver;
-    this.#config = config4;
-    this.#stateSaveInterval = config4.options.stateSaveInterval || 100;
+    this.#config = config;
+    this.#stateSaveInterval = config.options.stateSaveInterval || 100;
   }
   // MARK: - Public API
   get persist() {
@@ -1960,7 +2205,12 @@ var StateManager = class {
         await this.#savePersistInner();
       } else {
         if (!this.#onPersistSavedPromise) {
-          this.#onPersistSavedPromise = promiseWithResolvers((reason) => loggerWithoutContext().warn({ msg: "unhandled persist saved promise rejection", reason }));
+          this.#onPersistSavedPromise = promiseWithResolvers(
+            (reason) => loggerWithoutContext().warn({
+              msg: "unhandled persist saved promise rejection",
+              reason
+            })
+          );
         }
         this.savePersistThrottled(opts.maxWait);
         await ((_a = this.#onPersistSavedPromise) == null ? void 0 : _a.promise);
@@ -2221,14 +2471,15 @@ function concatPrefix(prefix, key) {
 function stripPrefix(prefix, key) {
   return key.slice(prefix.length);
 }
-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];
+function computeUpperBound(prefix) {
+  const upperBound = prefix.slice();
+  for (let i = upperBound.length - 1; i >= 0; i--) {
+    if (upperBound[i] !== 255) {
+      upperBound[i]++;
+      return upperBound.slice(0, i + 1);
     }
   }
-  return a.length - b.length;
+  return null;
 }
 var ActorTracesDriver = class {
   #driver;
@@ -2257,17 +2508,26 @@ var ActorTracesDriver = class {
   }
   async deletePrefix(prefix) {
     const fullPrefix = concatPrefix(this.#prefix, prefix);
-    const entries = await this.#driver.kvListPrefix(
-      this.#actorId,
-      fullPrefix
-    );
-    if (entries.length === 0) {
-      return;
+    const fullEnd = computeUpperBound(fullPrefix);
+    if (fullEnd) {
+      await this.#driver.kvDeleteRange(
+        this.#actorId,
+        fullPrefix,
+        fullEnd
+      );
+    } else {
+      const entries = await this.#driver.kvListPrefix(
+        this.#actorId,
+        fullPrefix
+      );
+      if (entries.length === 0) {
+        return;
+      }
+      await this.#driver.kvBatchDelete(
+        this.#actorId,
+        entries.map(([key]) => key)
+      );
     }
-    await this.#driver.kvBatchDelete(
-      this.#actorId,
-      entries.map(([key]) => key)
-    );
   }
   async list(prefix) {
     const fullPrefix = concatPrefix(this.#prefix, prefix);
@@ -2281,20 +2541,13 @@ var ActorTracesDriver = class {
     }));
   }
   async listRange(start, end, options) {
-    const fullStart = concatPrefix(this.#prefix, start);
-    const fullEnd = concatPrefix(this.#prefix, end);
-    const entries = await this.#driver.kvListPrefix(
+    const entries = await this.#driver.kvListRange(
       this.#actorId,
-      this.#prefix
+      concatPrefix(this.#prefix, start),
+      concatPrefix(this.#prefix, end),
+      options
     );
-    const filtered = entries.filter(([key]) => {
-      return compareBytes(key, fullStart) >= 0 && compareBytes(key, fullEnd) < 0;
-    }).sort(([keyA], [keyB]) => compareBytes(keyA, keyB));
-    if (options == null ? void 0 : options.reverse) {
-      filtered.reverse();
-    }
-    const limited = (options == null ? void 0 : options.limit) ? filtered.slice(0, options.limit) : filtered;
-    return limited.map(([key, value]) => ({
+    return entries.map(([key, value]) => ({
       key: stripPrefix(this.#prefix, key),
       value
     }));
@@ -2318,11 +2571,12 @@ var CanSleep = /* @__PURE__ */ ((CanSleep2) => {
   CanSleep2[CanSleep2["Yes"] = 0] = "Yes";
   CanSleep2[CanSleep2["NotReady"] = 1] = "NotReady";
   CanSleep2[CanSleep2["NotStarted"] = 2] = "NotStarted";
-  CanSleep2[CanSleep2["ActiveConns"] = 3] = "ActiveConns";
-  CanSleep2[CanSleep2["ActiveDisconnectCallbacks"] = 4] = "ActiveDisconnectCallbacks";
-  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 5] = "ActiveHonoHttpRequests";
-  CanSleep2[CanSleep2["ActiveKeepAwake"] = 6] = "ActiveKeepAwake";
-  CanSleep2[CanSleep2["ActiveRun"] = 7] = "ActiveRun";
+  CanSleep2[CanSleep2["PreventSleep"] = 3] = "PreventSleep";
+  CanSleep2[CanSleep2["ActiveConns"] = 4] = "ActiveConns";
+  CanSleep2[CanSleep2["ActiveDisconnectCallbacks"] = 5] = "ActiveDisconnectCallbacks";
+  CanSleep2[CanSleep2["ActiveHonoHttpRequests"] = 6] = "ActiveHonoHttpRequests";
+  CanSleep2[CanSleep2["ActiveKeepAwake"] = 7] = "ActiveKeepAwake";
+  CanSleep2[CanSleep2["ActiveRun"] = 8] = "ActiveRun";
   return CanSleep2;
 })(CanSleep || {});
 var ActorInstance = class {
@@ -2367,6 +2621,7 @@ var ActorInstance = class {
   #vars;
   #db;
   #sqliteVfs;
+  #metrics = new ActorMetrics();
   // MARK: - Background Tasks
   #backgroundPromises = [];
   #runPromise;
@@ -2375,6 +2630,7 @@ var ActorInstance = class {
   // MARK: - HTTP/WebSocket Tracking
   #activeHonoHttpRequests = 0;
   #activeKeepAwakeCount = 0;
+  #preventSleep = false;
   // MARK: - Deprecated (kept for compatibility)
   #schedule;
   // MARK: - Inspector
@@ -2390,8 +2646,8 @@ var ActorInstance = class {
    */
   overrides = {};
   // MARK: - Constructor
-  constructor(config4) {
-    this.#config = config4;
+  constructor(config) {
+    this.#config = config;
     this.actorContext = new ActorContext(this);
     this.#inspector = new ActorInspector(this);
   }
@@ -2431,6 +2687,9 @@ var ActorInstance = class {
   get inspectorToken() {
     return this.#inspectorToken;
   }
+  get metrics() {
+    return this.#metrics;
+  }
   // MARK: - Tracing
   getCurrentTraceSpan() {
     return this.#traces.getCurrentSpan();
@@ -2482,6 +2741,9 @@ var ActorInstance = class {
   get abortSignal() {
     return this.#abortController.signal;
   }
+  get preventSleep() {
+    return this.#preventSleep;
+  }
   get actions() {
     return Object.keys(this.#config.actions ?? {});
   }
@@ -2590,7 +2852,12 @@ var ActorInstance = class {
         this.#abortController.abort();
       } catch {
       }
-      await this.#waitForRunHandler(this.overrides.runStopTimeout !== void 0 ? Math.min(this.#config.options.runStopTimeout, this.overrides.runStopTimeout) : this.#config.options.runStopTimeout);
+      await this.#waitForRunHandler(
+        this.overrides.runStopTimeout !== void 0 ? Math.min(
+          this.#config.options.runStopTimeout,
+          this.overrides.runStopTimeout
+        ) : this.#config.options.runStopTimeout
+      );
       if (mode === "sleep") {
         await this.#callOnSleep();
       } else if (mode === "destroy") {
@@ -2598,10 +2865,13 @@ var ActorInstance = class {
       } else {
         assertUnreachable(mode);
       }
-      await this.#disconnectConnections();
       await this.#waitBackgroundPromises(
-        this.overrides.waitUntilTimeout !== void 0 ? Math.min(this.#config.options.waitUntilTimeout, this.overrides.waitUntilTimeout) : this.#config.options.waitUntilTimeout
+        this.overrides.waitUntilTimeout !== void 0 ? Math.min(
+          this.#config.options.waitUntilTimeout,
+          this.overrides.waitUntilTimeout
+        ) : this.#config.options.waitUntilTimeout
       );
+      await this.#disconnectConnections();
       this.#rLog.info({ msg: "clearing pending save timeouts" });
       this.stateManager.clearPendingSaveTimeout();
       this.#rLog.info({ msg: "saving state immediately" });
@@ -2698,7 +2968,10 @@ var ActorInstance = class {
     });
   }
   async assertCanSubscribe(ctx, eventName) {
-    const canSubscribe = getEventCanSubscribe(this.#config.events, eventName);
+    const canSubscribe = getEventCanSubscribe(
+      this.#config.events,
+      eventName
+    );
     if (!canSubscribe) {
       return;
     }
@@ -2741,7 +3014,9 @@ var ActorInstance = class {
       throw new ActionNotFound(actionName);
     }
     this.#activeKeepAwakeCount++;
+    this.#metrics.actionCalls++;
     this.resetSleepTimer();
+    const actionStart = performance.now();
     const actionSpan = this.startTraceSpan(`actor.action.${actionName}`, {
       "rivet.action.name": actionName
     });
@@ -2790,6 +3065,7 @@ var ActorInstance = class {
         return output;
       });
     } catch (error) {
+      this.#metrics.actionErrors++;
       const isTimeout = error instanceof DeadlineError;
       const message = isTimeout ? "ActionTimedOut" : stringifyError(error);
       this.#traces.setAttributes(actionSpan, {
@@ -2810,6 +3086,7 @@ var ActorInstance = class {
       });
       throw error;
     } finally {
+      this.#metrics.actionTotalMs += performance.now() - actionStart;
       if (!spanEnded && actionSpan.isActive()) {
         this.#traces.endSpan(actionSpan, {
           status: { code: "OK" }
@@ -2969,6 +3246,15 @@ var ActorInstance = class {
       this.resetSleepTimer();
     }
   }
+  setPreventSleep(prevent) {
+    if (this.#preventSleep === prevent) return;
+    this.#preventSleep = prevent;
+    this.#rLog.debug({
+      msg: "updated prevent sleep state",
+      prevent
+    });
+    this.resetSleepTimer();
+  }
   beginQueueWait() {
     this.assertReady(true);
     this.#activeQueueWaitCount++;
@@ -3004,11 +3290,11 @@ var ActorInstance = class {
       ...attributes ?? {}
     };
   }
-  #patchLoggerForTraces(logger3) {
+  #patchLoggerForTraces(logger) {
     const levels = ["trace", "debug", "info", "warn", "error", "fatal"];
     for (const level of levels) {
-      const original = logger3[level].bind(logger3);
-      logger3[level] = ((...args) => {
+      const original = logger[level].bind(logger);
+      logger[level] = ((...args) => {
         this.#emitLogEvent(level, args);
         return original(...args);
       });
@@ -3195,7 +3481,10 @@ var ActorInstance = class {
             if (result instanceof Promise) {
               await deadline(
                 result,
-                this.overrides.onSleepTimeout !== void 0 ? Math.min(this.#config.options.onSleepTimeout, this.overrides.onSleepTimeout) : this.#config.options.onSleepTimeout
+                this.overrides.onSleepTimeout !== void 0 ? Math.min(
+                  this.#config.options.onSleepTimeout,
+                  this.overrides.onSleepTimeout
+                ) : this.#config.options.onSleepTimeout
               );
             }
           }
@@ -3226,7 +3515,10 @@ var ActorInstance = class {
             if (result instanceof Promise) {
               await deadline(
                 result,
-                this.overrides.onDestroyTimeout !== void 0 ? Math.min(this.#config.options.onDestroyTimeout, this.overrides.onDestroyTimeout) : this.#config.options.onDestroyTimeout
+                this.overrides.onDestroyTimeout !== void 0 ? Math.min(
+                  this.#config.options.onDestroyTimeout,
+                  this.overrides.onDestroyTimeout
+                ) : this.#config.options.onDestroyTimeout
               );
             }
           }
@@ -3266,19 +3558,12 @@ var ActorInstance = class {
           });
           return;
         }
-        this.emitTraceEvent(
-          "actor.crash",
-          { "rivet.actor.reason": "run_exited" },
-          runSpan
-        );
-        this.endTraceSpan(runSpan, {
-          code: "ERROR",
-          message: "run exited unexpectedly"
-        });
-        this.#rLog.warn({
-          msg: "run handler exited unexpectedly, crashing actor to reschedule"
+        if (runSpan.isActive()) {
+          this.endTraceSpan(runSpan, { code: "OK" });
+        }
+        this.#rLog.info({
+          msg: "run handler exited"
         });
-        this.startDestroy();
       }).catch((error) => {
         if (this.#stopCalled) {
           if (runSpan.isActive()) {
@@ -3290,29 +3575,23 @@ var ActorInstance = class {
           });
           return;
         }
-        this.emitTraceEvent(
-          "actor.crash",
-          {
-            "rivet.actor.reason": "run_error",
-            "error.message": stringifyError(error)
-          },
-          runSpan
-        );
         this.endTraceSpan(runSpan, {
           code: "ERROR",
           message: stringifyError(error)
         });
         this.#rLog.error({
-          msg: "run handler threw error, crashing actor to reschedule",
+          msg: "run handler threw error",
           error: stringifyError(error)
         });
-        this.startDestroy();
       }).finally(() => {
         this.#runHandlerActive = false;
         this.resetSleepTimer();
       });
     } else if (runSpan.isActive()) {
       this.endTraceSpan(runSpan, { code: "OK" });
+      this.#rLog.info({
+        msg: "run handler exited"
+      });
       this.#runHandlerActive = false;
       this.resetSleepTimer();
     }
@@ -3345,18 +3624,23 @@ var ActorInstance = class {
     let client;
     try {
       if (!this.#sqliteVfs && this.driver.createSqliteVfs) {
-        this.#sqliteVfs = await this.driver.createSqliteVfs();
+        this.#sqliteVfs = await this.driver.createSqliteVfs(this.#actorId);
       }
       client = await this.#config.db.createClient({
         actorId: this.#actorId,
-        overrideRawDatabaseClient: this.driver.overrideRawDatabaseClient ? () => this.driver.overrideRawDatabaseClient(this.#actorId) : void 0,
-        overrideDrizzleDatabaseClient: this.driver.overrideDrizzleDatabaseClient ? () => this.driver.overrideDrizzleDatabaseClient(this.#actorId) : void 0,
+        overrideRawDatabaseClient: this.driver.overrideRawDatabaseClient ? () => this.driver.overrideRawDatabaseClient(
+          this.#actorId
+        ) : void 0,
+        overrideDrizzleDatabaseClient: this.driver.overrideDrizzleDatabaseClient ? () => this.driver.overrideDrizzleDatabaseClient(
+          this.#actorId
+        ) : void 0,
         kv: {
           batchPut: (entries) => this.driver.kvBatchPut(this.#actorId, entries),
           batchGet: (keys) => this.driver.kvBatchGet(this.#actorId, keys),
           batchDelete: (keys) => this.driver.kvBatchDelete(this.#actorId, keys)
         },
-        sqliteVfs: this.#sqliteVfs
+        sqliteVfs: this.#sqliteVfs,
+        metrics: this.#metrics
       });
       this.#rLog.info({ msg: "database migration starting" });
       await ((_b = (_a = this.#config.db).onMigrate) == null ? void 0 : _b.call(_a, client));
@@ -3391,7 +3675,9 @@ var ActorInstance = class {
         });
         throw error;
       }
-      const wrappedError = new Error(`Database setup failed: ${String(error)}`);
+      const wrappedError = new Error(
+        `Database setup failed: ${String(error)}`
+      );
       this.#rLog.error({
         msg: "database setup failed with non-Error object",
         error: String(error),
@@ -3511,17 +3797,18 @@ var ActorInstance = class {
   #canSleep() {
     if (!this.#ready) return 1 /* NotReady */;
     if (!this.#started) return 1 /* NotReady */;
+    if (this.#preventSleep) return 3 /* PreventSleep */;
     if (this.#activeHonoHttpRequests > 0)
-      return 5 /* ActiveHonoHttpRequests */;
-    if (this.#activeKeepAwakeCount > 0) return 6 /* ActiveKeepAwake */;
+      return 6 /* ActiveHonoHttpRequests */;
+    if (this.#activeKeepAwakeCount > 0) return 7 /* ActiveKeepAwake */;
     if (this.#runHandlerActive && this.#activeQueueWaitCount === 0) {
-      return 7 /* ActiveRun */;
+      return 8 /* ActiveRun */;
     }
     for (const _conn of this.connectionManager.connections.values()) {
-      return 3 /* ActiveConns */;
+      return 4 /* ActiveConns */;
     }
     if (this.connectionManager.pendingDisconnectCount > 0) {
-      return 4 /* ActiveDisconnectCallbacks */;
+      return 5 /* ActiveDisconnectCallbacks */;
     }
     return 0 /* Yes */;
   }
@@ -3541,8 +3828,8 @@ var ActorInstance = class {
 // src/actor/definition.ts
 var ActorDefinition = class {
   #config;
-  constructor(config4) {
-    this.#config = config4;
+  constructor(config) {
+    this.#config = config;
   }
   get config() {
     return this.#config;
@@ -3551,15 +3838,15 @@ var ActorDefinition = class {
     return new ActorInstance(this.#config);
   }
 };
-function lookupInRegistry(config4, name) {
-  const definition = config4.use[name];
+function lookupInRegistry(config, name) {
+  const definition = config.use[name];
   if (!definition) throw new Error(`no actor in registry for name ${name}`);
   return definition;
 }
 
 // src/actor/router.ts
 import { Hono } from "hono";
-function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
+function createActorRouter(config, actorDriver, getUpgradeWebSocket, isTest) {
   const router = new Hono({
     strict: false
   });
@@ -3584,7 +3871,8 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
   router.get("/metadata", async (c) => {
     return c.json({
       runtime: "rivetkit",
-      version: VERSION
+      version: VERSION,
+      type: isDev() ? "local" : "deployed"
     });
   });
   if (isTest) {
@@ -3621,7 +3909,7 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
               c2.req.raw,
               c2.req.path,
               c2.req.header(),
-              config4,
+              config,
               actorDriver,
               c2.env.actorId,
               encoding,
@@ -3641,10 +3929,10 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
       }
     );
   }
-  if (config4.inspector.enabled) {
+  if (config.inspector.enabled) {
     const inspectorAuth = async (c) => {
       var _a;
-      if (isDev() && !config4.inspector.token()) {
+      if (isDev() && !config.inspector.token()) {
         inspectorLogger().warn({
           msg: "RIVET_INSPECTOR_TOKEN is not set, skipping inspector auth in development mode"
         });
@@ -3654,7 +3942,7 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
       if (!userToken) {
         return c.text("Unauthorized", 401);
       }
-      const inspectorToken = config4.inspector.token();
+      const inspectorToken = config.inspector.token();
       if (!inspectorToken) {
         return c.text("Unauthorized", 401);
       }
@@ -3738,6 +4026,33 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
       const result = actor.inspector.getWorkflowHistoryJson();
       return c.json(result);
     });
+    router.get("/inspector/database/schema", async (c) => {
+      const authResponse = await inspectorAuth(c);
+      if (authResponse) return authResponse;
+      const actor = await actorDriver.loadActor(c.env.actorId);
+      const schema = await actor.inspector.getDatabaseSchemaJson();
+      return c.json({ schema });
+    });
+    router.get("/inspector/database/rows", async (c) => {
+      const authResponse = await inspectorAuth(c);
+      if (authResponse) return authResponse;
+      const actor = await actorDriver.loadActor(c.env.actorId);
+      const table = c.req.query("table");
+      if (!table) {
+        return c.json(
+          { error: "Missing required table query parameter" },
+          400
+        );
+      }
+      const limit = parseInt(c.req.query("limit") ?? "100", 10);
+      const offset = parseInt(c.req.query("offset") ?? "0", 10);
+      const rows = await actor.inspector.getDatabaseTableRowsJson(
+        table,
+        limit,
+        offset
+      );
+      return c.json({ rows });
+    });
     router.get("/inspector/summary", async (c) => {
       const authResponse = await inspectorAuth(c);
       if (authResponse) return authResponse;
@@ -3745,13 +4060,11 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
       const isStateEnabled = actor.inspector.isStateEnabled();
       const isDatabaseEnabled = actor.inspector.isDatabaseEnabled();
       const isWorkflowEnabled = actor.inspector.isWorkflowEnabled();
+      const workflowHistory = actor.inspector.getWorkflowHistoryJson().history;
       const state = isStateEnabled ? actor.inspector.getStateJson() : void 0;
       const connections = actor.inspector.getConnectionsJson();
       const rpcs = actor.inspector.getRpcs();
       const queueSize = actor.inspector.getQueueSize();
-      const workflowHistory = actor.inspector.getWorkflowHistory();
-      const bigIntReplacer = (_key, value) => typeof value === "bigint" ? Number(value) : value;
-      const safeWorkflowHistory = workflowHistory ? JSON.parse(JSON.stringify(workflowHistory, bigIntReplacer)) : null;
       return c.json({
         state,
         connections,
@@ -3760,21 +4073,27 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
         isStateEnabled,
         isDatabaseEnabled,
         isWorkflowEnabled,
-        workflowHistory: safeWorkflowHistory
+        workflowHistory
       });
     });
+    router.get("/inspector/metrics", async (c) => {
+      const authResponse = await inspectorAuth(c);
+      if (authResponse) return authResponse;
+      const actor = await actorDriver.loadActor(c.env.actorId);
+      return c.json(actor.metrics.snapshot());
+    });
   }
   router.post("/action/:action", async (c) => {
     const actionName = c.req.param("action");
-    return handleAction(c, config4, actorDriver, actionName, c.env.actorId);
+    return handleAction(c, config, actorDriver, actionName, c.env.actorId);
   });
   router.post("/queue", async (c) => {
-    return handleQueueSend(c, config4, actorDriver, c.env.actorId);
+    return handleQueueSend(c, config, actorDriver, c.env.actorId);
   });
   router.post("/queue/:name", async (c) => {
     return handleQueueSend(
       c,
-      config4,
+      config,
       actorDriver,
       c.env.actorId,
       c.req.param("name")
@@ -3807,2178 +4126,9 @@ function createActorRouter(config4, actorDriver, getUpgradeWebSocket, isTest) {
   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/drivers/file-system/mod.ts
-import { z } from "zod";
-
-// 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);
-  }
-  /** Creates a SQLite VFS instance for creating KV-backed databases */
-  async createSqliteVfs() {
-    return await importSqliteVfs();
-  }
-  startSleep(actorId) {
-    this.#state.sleepActor(actorId);
-  }
-  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
-import invariant3 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_VERSION3 = 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/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 = getRequireFn();
-  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(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 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 ? 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,
-        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 getNodePath().join(this.#stateDir, actorId);
-  }
-  getActorDbPath(actorId) {
-    return getNodePath().join(this.#dbsDir, `${actorId}.db`);
-  }
-  getActorAlarmPath(actorId) {
-    return getNodePath().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 = getNodePath();
-      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 {
-      }
-      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 = getNodeFsSync();
-    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 = getNodePath();
-      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 = 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) {
-    await this.#waitForActorStop(actorId);
-    let entry = this.#upsertEntry(actorId);
-    if (entry.state) {
-      throw new 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 = getInitialActorKvState(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 = getNodeFs();
-      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 = getInitialActorKvState(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;
-    invariant3(
-      this.#persist,
-      "cannot sleep actor with memory driver, must use file system driver"
-    );
-    const actor = this.#upsertEntry(actorId);
-    invariant3(actor, `tried to sleep ${actorId}, does not exist`);
-    if (this.isActorStopping(actorId)) {
-      return;
-    }
-    actor.lifecycleState = 2 /* STARTING_SLEEP */;
-    actor.stopPromise = promiseWithResolvers((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
-            );
-          }
-        });
-      }
-      invariant3(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 = promiseWithResolvers((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 = 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)
-                });
-              }
-            }
-          })()
-        ]);
-      }
-    } 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 {
-        return;
-      }
-    }
-  }
-  async #withActorWrite(actorId, fn) {
-    const entry = this.#actors.get(actorId);
-    invariant3(entry, "actor entry does not exist");
-    const previousWrite = entry.pendingWriteResolver;
-    const currentWrite = promiseWithResolvers((reason) => logger2().warn({ msg: "unhandled kv write promise rejection", reason }));
-    entry.pendingWriteResolver = currentWrite;
-    if (previousWrite) {
-      try {
-        await previousWrite.promise;
-      } catch {
-      }
-    }
-    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 {
-      }
-    }
-  }
-  async setActorAlarm(actorId, timestamp) {
-    const entry = this.#actors.get(actorId);
-    invariant3(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_VERSION3
-        );
-        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_VERSION3
-      );
-      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;
-    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;
-      invariant3(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 = promiseWithResolvers((reason) => logger2().warn({ msg: "unhandled actor start promise rejection", reason }));
-    try {
-      const definition = lookupInRegistry(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 = 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;
-        invariant3(runnerParams, "missing runner params");
-        if (!loaded.actor) {
-          await this.startActor(
-            runnerParams.config,
-            runnerParams.inlineClient,
-            runnerParams.actorDriver,
-            actorId
-          );
-        }
-        invariant3(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) {
-    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 {
-        }
-        throw error;
-      }
-    });
-  }
-  /**
-   * List KV entries with a given prefix for an actor.
-   */
-  async kvListPrefix(actorId, prefix) {
-    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 rows = upperBound ? db.all(
-      "SELECT key, value FROM kv WHERE key >= ? AND key < ? ORDER BY key ASC",
-      [prefix, upperBound]
-    ) : db.all(
-      "SELECT key, value FROM kv WHERE key >= ? ORDER BY key ASC",
-      [prefix]
-    );
-    return rows.map((row) => [
-      ensureUint8Array(row.key, "key"),
-      ensureUint8Array(row.value, "value")
-    ]);
-  }
-};
-
-// src/drivers/file-system/manager.ts
-import invariant4 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 { gatewayId, requestId } = createHibernatableRequestMetadata();
-    const wsHandler = await routeWebSocket(
-      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);
-    invariant4(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const pathOnly = path.split("?")[0];
-    const normalizedPath = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-    const { gatewayId, requestId } = createHibernatableRequestMetadata();
-    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,
-      gatewayId,
-      requestId,
-      true,
-      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
-  };
-}
-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 = z.object({
-  /** Custom path for storage. */
-  path: z.string().optional(),
-  /** Deprecated: file-system driver KV is now always SQLite-backed. */
-  useNativeSqlite: z.boolean().optional()
-});
-function createFileSystemOrMemoryDriver(persist = true, options) {
-  importNodeDependencies();
-  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);
-}
-
 export {
   ActorDefinition,
   lookupInRegistry,
-  createActorRouter,
-  InlineWebSocketAdapter,
-  getStoragePath,
-  ensureDirectoryExists,
-  createFileSystemOrMemoryDriver,
-  createFileSystemDriver,
-  createMemoryDriver
+  createActorRouter
 };
-//# sourceMappingURL=chunk-KTWY3K6Z.js.map
+//# sourceMappingURL=chunk-YGYGANCA.js.map