@rivetkit/cloudflare-workers 2.0.24-rc.1 → 2.0.24

package/dist/mod.js

@@ -1,235 +1,94 @@
-// src/handler.ts
-import { env as env2 } from "cloudflare:workers";
-
 // src/actor-handler-do.ts
-import { DurableObject, env } from "cloudflare:workers";
+import { DurableObject, env as env2 } from "cloudflare:workers";
 import invariant2 from "invariant";
 import { createActorRouter, createClientWithDriver } from "rivetkit";
-import {
-  serializeEmptyPersistData
-} from "rivetkit/driver-helpers";
-import { promiseWithResolvers as promiseWithResolvers2 } from "rivetkit/utils";
+import { getInitialActorKvState } from "rivetkit/driver-helpers";
 
 // src/actor-driver.ts
 import invariant from "invariant";
 import { lookupInRegistry } from "rivetkit";
 import { promiseWithResolvers } from "rivetkit/utils";
-var CloudflareDurableObjectGlobalState = class {
-  // Single map for all actor state
-  #dos = /* @__PURE__ */ new Map();
-  getDOState(actorId) {
-    const state = this.#dos.get(actorId);
-    invariant(
-      state !== void 0,
-      "durable object state not in global state"
-    );
-    return state;
-  }
-  setDOState(actorId, state) {
-    this.#dos.set(actorId, state);
+
+// src/actor-id.ts
+function buildActorId(doId, generation) {
+  return `${doId}:${generation}`;
+}
+function parseActorId(actorId) {
+  const parts = actorId.split(":");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid actor ID format: ${actorId}`);
   }
-};
-var ActorHandler = class {
-  actor;
-  actorPromise = promiseWithResolvers();
-};
-var CloudflareActorsActorDriver = class {
-  #registryConfig;
-  #runConfig;
-  #managerDriver;
-  #inlineClient;
-  #globalState;
-  #actors = /* @__PURE__ */ new Map();
-  constructor(registryConfig, runConfig, managerDriver, inlineClient, globalState) {
-    this.#registryConfig = registryConfig;
-    this.#runConfig = runConfig;
-    this.#managerDriver = managerDriver;
-    this.#inlineClient = inlineClient;
-    this.#globalState = globalState;
+  const [doId, generationStr] = parts;
+  const generation = parseInt(generationStr, 10);
+  if (Number.isNaN(generation)) {
+    throw new Error(`Invalid generation number in actor ID: ${actorId}`);
   }
-  #getDOCtx(actorId) {
-    return this.#globalState.getDOState(actorId).ctx;
+  return [doId, generation];
+}
+
+// src/actor-kv.ts
+function kvGet(sql, key) {
+  const cursor = sql.exec(
+    "SELECT value FROM _rivetkit_kv_storage WHERE key = ?",
+    key
+  );
+  const result = cursor.raw().next();
+  if (!result.done && result.value) {
+    return toUint8Array(result.value[0]);
   }
-  async loadActor(actorId) {
-    var _a;
-    let handler = this.#actors.get(actorId);
-    if (handler) {
-      if (handler.actorPromise) await handler.actorPromise.promise;
-      if (!handler.actor) throw new Error("Actor should be loaded");
-      return handler.actor;
-    }
-    handler = new ActorHandler();
-    this.#actors.set(actorId, handler);
-    const doState = this.#globalState.getDOState(actorId);
-    const storage = doState.ctx.storage;
-    const [name, key] = await Promise.all([
-      storage.get(KEYS.NAME),
-      storage.get(KEYS.KEY)
-    ]);
-    if (!name) {
-      throw new Error(
-        `Actor ${actorId} is not initialized - missing name`
-      );
-    }
-    if (!key) {
-      throw new Error(
-        `Actor ${actorId} is not initialized - missing key`
-      );
+  return null;
+}
+function kvPut(sql, key, value) {
+  sql.exec(
+    "INSERT OR REPLACE INTO _rivetkit_kv_storage (key, value) VALUES (?, ?)",
+    key,
+    value
+  );
+}
+function kvDelete(sql, key) {
+  sql.exec("DELETE FROM _rivetkit_kv_storage WHERE key = ?", key);
+}
+function kvListPrefix(sql, prefix) {
+  const cursor = sql.exec("SELECT key, value FROM _rivetkit_kv_storage");
+  const entries = [];
+  for (const row of cursor.raw()) {
+    const key = toUint8Array(row[0]);
+    const value = toUint8Array(row[1]);
+    if (hasPrefix(key, prefix)) {
+      entries.push([key, value]);
     }
-    const definition = lookupInRegistry(this.#registryConfig, name);
-    handler.actor = definition.instantiate();
-    await handler.actor.start(
-      this,
-      this.#inlineClient,
-      actorId,
-      name,
-      key,
-      "unknown"
-      // TODO: Support regions in Cloudflare
-    );
-    (_a = handler.actorPromise) == null ? void 0 : _a.resolve();
-    handler.actorPromise = void 0;
-    return handler.actor;
-  }
-  getContext(actorId) {
-    const state = this.#globalState.getDOState(actorId);
-    return { state: state.ctx };
   }
-  async readPersistedData(actorId) {
-    return await this.#getDOCtx(actorId).storage.get(KEYS.PERSIST_DATA);
-  }
-  async writePersistedData(actorId, data) {
-    await this.#getDOCtx(actorId).storage.put(KEYS.PERSIST_DATA, data);
+  return entries;
+}
+function toUint8Array(value) {
+  var _a;
+  if (value instanceof Uint8Array) {
+    return value;
   }
-  async setAlarm(actor, timestamp) {
-    await this.#getDOCtx(actor.id).storage.setAlarm(timestamp);
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
   }
-  async getDatabase(actorId) {
-    return this.#getDOCtx(actorId).storage.sql;
-  }
-};
-function createCloudflareActorsActorDriverBuilder(globalState) {
-  return (registryConfig, runConfig, managerDriver, inlineClient) => {
-    return new CloudflareActorsActorDriver(
-      registryConfig,
-      runConfig,
-      managerDriver,
-      inlineClient,
-      globalState
-    );
-  };
+  throw new Error(
+    `Unexpected SQL value type: ${typeof value} (${(_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name})`
+  );
 }
-
-// src/log.ts
-import { getLogger } from "rivetkit/log";
-function logger() {
-  return getLogger("driver-cloudflare-workers");
+function hasPrefix(arr, prefix) {
+  if (prefix.length > arr.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (arr[i] !== prefix[i]) return false;
+  }
+  return true;
 }
 
-// src/actor-handler-do.ts
-var KEYS = {
-  NAME: "rivetkit:name",
-  KEY: "rivetkit:key",
-  PERSIST_DATA: "rivetkit:data"
+// src/global-kv.ts
+var GLOBAL_KV_KEYS = {
+  actorMetadata: (actorId) => {
+    return `actor:${actorId}:metadata`;
+  }
 };
-function createActorDurableObject(registry, rootRunConfig) {
-  const globalState = new CloudflareDurableObjectGlobalState();
-  const runConfig = Object.assign({}, rootRunConfig, { role: "runner" });
-  return class ActorHandler extends DurableObject {
-    #initialized;
-    #initializedPromise;
-    #actor;
-    async #loadActor() {
-      if (!this.#initialized) {
-        if (this.#initializedPromise) {
-          await this.#initializedPromise.promise;
-        } else {
-          this.#initializedPromise = promiseWithResolvers2();
-          const res = await this.ctx.storage.get([
-            KEYS.NAME,
-            KEYS.KEY,
-            KEYS.PERSIST_DATA
-          ]);
-          if (res.get(KEYS.PERSIST_DATA)) {
-            const name = res.get(KEYS.NAME);
-            if (!name) throw new Error("missing actor name");
-            const key = res.get(KEYS.KEY);
-            if (!key) throw new Error("missing actor key");
-            logger().debug({
-              msg: "already initialized",
-              name,
-              key
-            });
-            this.#initialized = { name, key };
-            this.#initializedPromise.resolve();
-          } else {
-            logger().debug("waiting to initialize");
-          }
-        }
-      }
-      if (this.#actor) {
-        return this.#actor;
-      }
-      if (!this.#initialized) throw new Error("Not initialized");
-      const actorId = this.ctx.id.toString();
-      globalState.setDOState(actorId, { ctx: this.ctx, env });
-      invariant2(runConfig.driver, "runConfig.driver");
-      runConfig.driver.actor = createCloudflareActorsActorDriverBuilder(globalState);
-      const managerDriver = runConfig.driver.manager(
-        registry.config,
-        runConfig
-      );
-      const inlineClient = createClientWithDriver(
-        managerDriver,
-        runConfig
-      );
-      const actorDriver = runConfig.driver.actor(
-        registry.config,
-        runConfig,
-        managerDriver,
-        inlineClient
-      );
-      const actorRouter = createActorRouter(
-        runConfig,
-        actorDriver,
-        false
-      );
-      this.#actor = {
-        actorRouter,
-        actorDriver
-      };
-      await actorDriver.loadActor(actorId);
-      return this.#actor;
-    }
-    /** RPC called by the service that creates the DO to initialize it. */
-    async initialize(req) {
-      await this.ctx.storage.put({
-        [KEYS.NAME]: req.name,
-        [KEYS.KEY]: req.key,
-        [KEYS.PERSIST_DATA]: serializeEmptyPersistData(req.input)
-      });
-      this.#initialized = {
-        name: req.name,
-        key: req.key
-      };
-      logger().debug({ msg: "initialized actor", key: req.key });
-      await this.#loadActor();
-    }
-    async fetch(request) {
-      const { actorRouter } = await this.#loadActor();
-      const actorId = this.ctx.id.toString();
-      return await actorRouter.fetch(request, {
-        actorId
-      });
-    }
-    async alarm() {
-      const { actorDriver } = await this.#loadActor();
-      const actorId = this.ctx.id.toString();
-      const actor = await actorDriver.loadActor(actorId);
-      await actor._onAlarm();
-    }
-  };
-}
+
+// src/handler.ts
+import { env } from "cloudflare:workers";
 
 // src/config.ts
 import { RunConfigSchema } from "rivetkit/driver-helpers";
@@ -244,14 +103,23 @@ var ConfigSchema = RunConfigSchema.removeDefault().omit({ driver: true, getUpgra
 import {
   generateRandomString,
   WS_PROTOCOL_ACTOR,
-  WS_PROTOCOL_CONN_ID,
   WS_PROTOCOL_CONN_PARAMS,
-  WS_PROTOCOL_CONN_TOKEN,
   WS_PROTOCOL_ENCODING,
   WS_PROTOCOL_STANDARD,
   WS_PROTOCOL_TARGET
 } from "rivetkit/driver-helpers";
-import { ActorAlreadyExists, InternalError } from "rivetkit/errors";
+import {
+  ActorDuplicateKey,
+  ActorNotFound,
+  InternalError
+} from "rivetkit/errors";
+import { assertUnreachable } from "rivetkit/utils";
+
+// src/log.ts
+import { getLogger } from "rivetkit/log";
+function logger() {
+  return getLogger("driver-cloudflare-workers");
+}
 
 // src/util.ts
 var EMPTY_KEY = "(none)";
@@ -280,16 +148,6 @@ function serializeKey(key) {
 }
 
 // src/manager-driver.ts
-var KEYS2 = {
-  ACTOR: {
-    // Combined key for actor metadata (name and key)
-    metadata: (actorId) => `actor:${actorId}:metadata`,
-    // Key index function for actor lookup
-    keyIndex: (name, key = []) => {
-      return `actor_key:${serializeKey(key)}`;
-    }
-  }
-};
 var STANDARD_WEBSOCKET_HEADERS = [
   "connection",
   "upgrade",
@@ -301,41 +159,39 @@ var STANDARD_WEBSOCKET_HEADERS = [
 var CloudflareActorsManagerDriver = class {
   async sendRequest(actorId, actorRequest) {
     const env3 = getCloudflareAmbientEnv();
+    const [doId] = parseActorId(actorId);
     logger().debug({
       msg: "sending request to durable object",
       actorId,
+      doId,
       method: actorRequest.method,
       url: actorRequest.url
     });
-    const id = env3.ACTOR_DO.idFromString(actorId);
+    const id = env3.ACTOR_DO.idFromString(doId);
     const stub = env3.ACTOR_DO.get(id);
     return await stub.fetch(actorRequest);
   }
-  async openWebSocket(path, actorId, encoding, params, connId, connToken) {
+  async openWebSocket(path, actorId, encoding, params) {
     const env3 = getCloudflareAmbientEnv();
+    const [doId] = parseActorId(actorId);
     logger().debug({
       msg: "opening websocket to durable object",
       actorId,
+      doId,
       path
     });
-    const id = env3.ACTOR_DO.idFromString(actorId);
+    const id = env3.ACTOR_DO.idFromString(doId);
     const stub = env3.ACTOR_DO.get(id);
     const protocols = [];
     protocols.push(WS_PROTOCOL_STANDARD);
     protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-    protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+    protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
     protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
     if (params) {
       protocols.push(
         `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
       );
     }
-    if (connId) {
-      protocols.push(`${WS_PROTOCOL_CONN_ID}${connId}`);
-    }
-    if (connToken) {
-      protocols.push(`${WS_PROTOCOL_CONN_TOKEN}${connToken}`);
-    }
     const headers = {
       Upgrade: "websocket",
       Connection: "Upgrade",
@@ -370,13 +226,15 @@ Response: ${await response.text()}`
     return webSocket;
   }
   async proxyRequest(c, actorRequest, actorId) {
+    const [doId] = parseActorId(actorId);
     logger().debug({
       msg: "forwarding request to durable object",
       actorId,
+      doId,
       method: actorRequest.method,
       url: actorRequest.url
     });
-    const id = c.env.ACTOR_DO.idFromString(actorId);
+    const id = c.env.ACTOR_DO.idFromString(doId);
     const stub = c.env.ACTOR_DO.get(id);
     return await stub.fetch(actorRequest);
   }
@@ -411,7 +269,7 @@ Response: ${await response.text()}`
     const protocols = [];
     protocols.push(WS_PROTOCOL_STANDARD);
     protocols.push(`${WS_PROTOCOL_TARGET}actor`);
-    protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+    protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
     protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
     if (params) {
       protocols.push(
@@ -422,7 +280,8 @@ Response: ${await response.text()}`
       "sec-websocket-protocol",
       protocols.join(", ")
     );
-    const id = c.env.ACTOR_DO.idFromString(actorId);
+    const [doId] = parseActorId(actorId);
+    const id = c.env.ACTOR_DO.idFromString(doId);
     const stub = c.env.ACTOR_DO.get(id);
     return await stub.fetch(actorRequest);
   }
@@ -431,19 +290,32 @@ Response: ${await response.text()}`
     actorId
   }) {
     const env3 = getCloudflareAmbientEnv();
-    const actorData = await env3.ACTOR_KV.get(
-      KEYS2.ACTOR.metadata(actorId),
-      {
-        type: "json"
-      }
-    );
-    if (!actorData) {
+    const [doId, expectedGeneration] = parseActorId(actorId);
+    const id = env3.ACTOR_DO.idFromString(doId);
+    const stub = env3.ACTOR_DO.get(id);
+    const result = await stub.getMetadata();
+    if (!result) {
+      logger().debug({
+        msg: "getForId: actor not found",
+        actorId
+      });
       return void 0;
     }
+    if (result.actorId !== actorId) {
+      logger().debug({
+        msg: "getForId: generation mismatch",
+        requestedActorId: actorId,
+        actualActorId: result.actorId
+      });
+      return void 0;
+    }
+    if (result.destroying) {
+      throw new ActorNotFound(actorId);
+    }
     return {
-      actorId,
-      name: actorData.name,
-      key: actorData.key
+      actorId: result.actorId,
+      name: result.name,
+      key: result.key
     };
   }
   async getWithKey({
@@ -454,33 +326,66 @@ Response: ${await response.text()}`
     const env3 = getCloudflareAmbientEnv();
     logger().debug({ msg: "getWithKey: searching for actor", name, key });
     const nameKeyString = serializeNameAndKey(name, key);
-    const actorId = env3.ACTOR_DO.idFromName(nameKeyString).toString();
-    const actorData = await env3.ACTOR_KV.get(KEYS2.ACTOR.metadata(actorId), {
-      type: "json"
-    });
-    if (!actorData) {
+    const doId = env3.ACTOR_DO.idFromName(nameKeyString).toString();
+    const id = env3.ACTOR_DO.idFromString(doId);
+    const stub = env3.ACTOR_DO.get(id);
+    const result = await stub.getMetadata();
+    if (result) {
+      logger().debug({
+        msg: "getWithKey: found actor with matching name and key",
+        actorId: result.actorId,
+        name: result.name,
+        key: result.key
+      });
+      return {
+        actorId: result.actorId,
+        name: result.name,
+        key: result.key
+      };
+    } else {
       logger().debug({
         msg: "getWithKey: no actor found with matching name and key",
         name,
         key,
-        actorId
+        doId
       });
       return void 0;
     }
-    logger().debug({
-      msg: "getWithKey: found actor with matching name and key",
-      actorId,
+  }
+  async getOrCreateWithKey({
+    c,
+    name,
+    key,
+    input
+  }) {
+    const env3 = getCloudflareAmbientEnv();
+    const nameKeyString = serializeNameAndKey(name, key);
+    const doId = env3.ACTOR_DO.idFromName(nameKeyString);
+    const actor = env3.ACTOR_DO.get(doId);
+    const result = await actor.create({
       name,
-      key
+      key,
+      input,
+      allowExisting: true
     });
-    return this.#buildActorOutput(c, actorId);
-  }
-  async getOrCreateWithKey(input) {
-    const getOutput = await this.getWithKey(input);
-    if (getOutput) {
-      return getOutput;
+    if ("success" in result) {
+      const { actorId, created } = result.success;
+      logger().debug({
+        msg: "getOrCreateWithKey result",
+        actorId,
+        name,
+        key,
+        created
+      });
+      return {
+        actorId,
+        name,
+        key
+      };
+    } else if ("error" in result) {
+      throw new Error(`Error: ${JSON.stringify(result.error)}`);
     } else {
-      return await this.createActor(input);
+      assertUnreachable(result);
     }
   }
   async createActor({
@@ -490,48 +395,39 @@ Response: ${await response.text()}`
     input
   }) {
     const env3 = getCloudflareAmbientEnv();
-    const existingActor = await this.getWithKey({ c, name, key });
-    if (existingActor) {
-      throw new ActorAlreadyExists(name, key);
-    }
     const nameKeyString = serializeNameAndKey(name, key);
     const doId = env3.ACTOR_DO.idFromName(nameKeyString);
-    const actorId = doId.toString();
     const actor = env3.ACTOR_DO.get(doId);
-    await actor.initialize({
+    const result = await actor.create({
       name,
       key,
-      input
+      input,
+      allowExisting: false
     });
-    const actorData = { name, key };
-    await env3.ACTOR_KV.put(
-      KEYS2.ACTOR.metadata(actorId),
-      JSON.stringify(actorData)
-    );
-    await env3.ACTOR_KV.put(KEYS2.ACTOR.keyIndex(name, key), actorId);
-    return {
-      actorId,
-      name,
-      key
-    };
-  }
-  // Helper method to build actor output from an ID
-  async #buildActorOutput(c, actorId) {
-    const env3 = getCloudflareAmbientEnv();
-    const actorData = await env3.ACTOR_KV.get(
-      KEYS2.ACTOR.metadata(actorId),
-      {
-        type: "json"
+    if ("success" in result) {
+      const { actorId } = result.success;
+      return {
+        actorId,
+        name,
+        key
+      };
+    } else if ("error" in result) {
+      if (result.error.actorAlreadyExists) {
+        throw new ActorDuplicateKey(name, key);
       }
-    );
-    if (!actorData) {
-      return void 0;
+      throw new InternalError(
+        `Unknown error creating actor: ${JSON.stringify(result.error)}`
+      );
+    } else {
+      assertUnreachable(result);
     }
-    return {
-      actorId,
-      name: actorData.name,
-      key: actorData.key
-    };
+  }
+  async listActors({ c, name }) {
+    logger().warn({
+      msg: "listActors not fully implemented for Cloudflare Workers",
+      name
+    });
+    return [];
   }
   displayInformation() {
     return {
@@ -611,9 +507,9 @@ var upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
 
 // src/handler.ts
 function getCloudflareAmbientEnv() {
-  return env2;
+  return env;
 }
-function createHandler(registry, inputConfig) {
+function createInlineClient(registry, inputConfig) {
   inputConfig = { ...inputConfig, runnerKey: "" };
   const config = ConfigSchema.parse(inputConfig);
   const runConfig = {
@@ -626,19 +522,26 @@ function createHandler(registry, inputConfig) {
     },
     getUpgradeWebSocket: () => upgradeWebSocket
   };
-  const ActorHandler2 = createActorDurableObject(registry, runConfig);
-  const serverOutput = registry.start(runConfig);
+  const ActorHandler = createActorDurableObject(registry, runConfig);
+  const { client, fetch } = registry.start(runConfig);
+  return { client, fetch, config, ActorHandler };
+}
+function createHandler(registry, inputConfig) {
+  const { client, fetch, config, ActorHandler } = createInlineClient(
+    registry,
+    inputConfig
+  );
   const handler = {
-    fetch: (request, cfEnv, ctx) => {
+    fetch: async (request, cfEnv, ctx) => {
       const url = new URL(request.url);
-      const env3 = Object.assign({ RIVET: serverOutput.client }, cfEnv);
+      const env3 = Object.assign({ RIVET: client }, cfEnv);
       if (url.pathname.startsWith(config.managerPath)) {
         const strippedPath = url.pathname.substring(
           config.managerPath.length
         );
         url.pathname = strippedPath;
         const modifiedRequest = new Request(url.toString(), request);
-        return serverOutput.fetch(modifiedRequest, env3, ctx);
+        return fetch(modifiedRequest, env3, ctx);
       }
       if (config.fetch) {
         return config.fetch(request, env3, ctx);
@@ -650,9 +553,472 @@ function createHandler(registry, inputConfig) {
       }
     }
   };
-  return { handler, ActorHandler: ActorHandler2 };
+  return { handler, ActorHandler };
+}
+
+// src/actor-driver.ts
+var CloudflareDurableObjectGlobalState = class {
+  // Map of actor ID -> DO state
+  #dos = /* @__PURE__ */ new Map();
+  // WeakMap of DO state -> ActorGlobalState for proper GC
+  #actors = /* @__PURE__ */ new WeakMap();
+  getDOState(doId) {
+    const state = this.#dos.get(doId);
+    invariant(
+      state !== void 0,
+      "durable object state not in global state"
+    );
+    return state;
+  }
+  setDOState(doId, state) {
+    this.#dos.set(doId, state);
+  }
+  getActorState(ctx) {
+    return this.#actors.get(ctx);
+  }
+  setActorState(ctx, actorState) {
+    this.#actors.set(ctx, actorState);
+  }
+};
+var ActorGlobalState = class {
+  // Initialization state
+  initialized;
+  // Loaded actor state
+  actor;
+  actorInstance;
+  actorPromise;
+  /**
+   * Indicates if `startDestroy` has been called.
+   *
+   * This is stored in memory instead of SQLite since the destroy may be cancelled.
+   *
+   * See the corresponding `destroyed` property in SQLite metadata.
+   */
+  destroying = false;
+  reset() {
+    this.initialized = void 0;
+    this.actor = void 0;
+    this.actorInstance = void 0;
+    this.actorPromise = void 0;
+    this.destroying = false;
+  }
+};
+var CloudflareActorsActorDriver = class {
+  #registryConfig;
+  #runConfig;
+  #managerDriver;
+  #inlineClient;
+  #globalState;
+  constructor(registryConfig, runConfig, managerDriver, inlineClient, globalState) {
+    this.#registryConfig = registryConfig;
+    this.#runConfig = runConfig;
+    this.#managerDriver = managerDriver;
+    this.#inlineClient = inlineClient;
+    this.#globalState = globalState;
+  }
+  #getDOCtx(actorId) {
+    const [doId] = parseActorId(actorId);
+    return this.#globalState.getDOState(doId).ctx;
+  }
+  async loadActor(actorId) {
+    var _a;
+    const [doId, expectedGeneration] = parseActorId(actorId);
+    const doState = this.#globalState.getDOState(doId);
+    let actorState = this.#globalState.getActorState(doState.ctx);
+    if (actorState == null ? void 0 : actorState.actorInstance) {
+      return actorState.actorInstance;
+    }
+    if (!actorState) {
+      actorState = new ActorGlobalState();
+      actorState.actorPromise = promiseWithResolvers();
+      this.#globalState.setActorState(doState.ctx, actorState);
+    } else if (actorState.actorPromise) {
+      await actorState.actorPromise.promise;
+      if (!actorState.actorInstance) {
+        throw new Error(
+          `Actor ${actorId} failed to load in concurrent request`
+        );
+      }
+      return actorState.actorInstance;
+    }
+    const sql = doState.ctx.storage.sql;
+    const cursor = sql.exec(
+      "SELECT name, key, destroyed, generation FROM _rivetkit_metadata LIMIT 1"
+    );
+    const result = cursor.raw().next();
+    if (result.done || !result.value) {
+      throw new Error(
+        `Actor ${actorId} is not initialized - missing metadata`
+      );
+    }
+    const name = result.value[0];
+    const key = JSON.parse(result.value[1]);
+    const destroyed = result.value[2];
+    const generation = result.value[3];
+    if (destroyed) {
+      throw new Error(`Actor ${actorId} is destroyed`);
+    }
+    if (generation !== expectedGeneration) {
+      throw new Error(
+        `Actor ${actorId} generation mismatch - expected ${expectedGeneration}, got ${generation}`
+      );
+    }
+    const definition = lookupInRegistry(this.#registryConfig, name);
+    actorState.actorInstance = definition.instantiate();
+    await actorState.actorInstance.start(
+      this,
+      this.#inlineClient,
+      actorId,
+      name,
+      key,
+      "unknown"
+      // TODO: Support regions in Cloudflare
+    );
+    (_a = actorState.actorPromise) == null ? void 0 : _a.resolve();
+    actorState.actorPromise = void 0;
+    return actorState.actorInstance;
+  }
+  getContext(actorId) {
+    const [doId] = parseActorId(actorId);
+    const state = this.#globalState.getDOState(doId);
+    return { state: state.ctx };
+  }
+  async setAlarm(actor, timestamp) {
+    await this.#getDOCtx(actor.id).storage.setAlarm(timestamp);
+  }
+  async getDatabase(actorId) {
+    return this.#getDOCtx(actorId).storage.sql;
+  }
+  // Batch KV operations
+  async kvBatchPut(actorId, entries) {
+    const sql = this.#getDOCtx(actorId).storage.sql;
+    for (const [key, value] of entries) {
+      kvPut(sql, key, value);
+    }
+  }
+  async kvBatchGet(actorId, keys) {
+    const sql = this.#getDOCtx(actorId).storage.sql;
+    const results = [];
+    for (const key of keys) {
+      results.push(kvGet(sql, key));
+    }
+    return results;
+  }
+  async kvBatchDelete(actorId, keys) {
+    const sql = this.#getDOCtx(actorId).storage.sql;
+    for (const key of keys) {
+      kvDelete(sql, key);
+    }
+  }
+  async kvListPrefix(actorId, prefix) {
+    const sql = this.#getDOCtx(actorId).storage.sql;
+    return kvListPrefix(sql, prefix);
+  }
+  startDestroy(actorId) {
+    const [doId, generation] = parseActorId(actorId);
+    const doState = this.#globalState.getDOState(doId);
+    const actorState = this.#globalState.getActorState(doState.ctx);
+    if (!(actorState == null ? void 0 : actorState.actorInstance)) {
+      return;
+    }
+    if (actorState.destroying) {
+      return;
+    }
+    actorState.destroying = true;
+    this.#callOnStopAsync(actorId, doId, actorState.actorInstance);
+  }
+  async #callOnStopAsync(actorId, doId, actor) {
+    await actor.onStop("destroy");
+    const doState = this.#globalState.getDOState(doId);
+    const sql = doState.ctx.storage.sql;
+    sql.exec("UPDATE _rivetkit_metadata SET destroyed = 1 WHERE 1=1");
+    sql.exec("DELETE FROM _rivetkit_kv_storage");
+    await doState.ctx.storage.deleteAlarm();
+    const env3 = getCloudflareAmbientEnv();
+    doState.ctx.waitUntil(
+      env3.ACTOR_KV.delete(GLOBAL_KV_KEYS.actorMetadata(actorId))
+    );
+    const actorHandle = this.#globalState.getActorState(doState.ctx);
+    actorHandle == null ? void 0 : actorHandle.reset();
+  }
+};
+function createCloudflareActorsActorDriverBuilder(globalState) {
+  return (registryConfig, runConfig, managerDriver, inlineClient) => {
+    return new CloudflareActorsActorDriver(
+      registryConfig,
+      runConfig,
+      managerDriver,
+      inlineClient,
+      globalState
+    );
+  };
+}
+
+// src/actor-handler-do.ts
+function createActorDurableObject(registry, rootRunConfig) {
+  const globalState = new CloudflareDurableObjectGlobalState();
+  const runConfig = Object.assign({}, rootRunConfig, { role: "runner" });
+  return class ActorHandler extends DurableObject {
+    /**
+     * This holds a strong reference to ActorGlobalState.
+     * CloudflareDurableObjectGlobalState holds a weak reference so we can
+     * access it elsewhere.
+     **/
+    #state;
+    constructor(...args) {
+      super(...args);
+      this.ctx.storage.sql.exec(`
+				CREATE TABLE IF NOT EXISTS _rivetkit_kv_storage(
+					key BLOB PRIMARY KEY,
+					value BLOB
+				);
+			`);
+      this.ctx.storage.sql.exec(`
+				CREATE TABLE IF NOT EXISTS _rivetkit_metadata(
+					id INTEGER PRIMARY KEY CHECK (id = 1),
+					name TEXT NOT NULL,
+					key TEXT NOT NULL,
+					destroyed INTEGER DEFAULT 0,
+					generation INTEGER DEFAULT 0
+				);
+			`);
+      const state = globalState.getActorState(this.ctx);
+      if (state) {
+        this.#state = state;
+      } else {
+        this.#state = new ActorGlobalState();
+        globalState.setActorState(this.ctx, this.#state);
+      }
+    }
+    async #loadActor() {
+      var _a;
+      invariant2(this.#state, "State should be initialized");
+      if (!this.#state.initialized) {
+        const cursor = this.ctx.storage.sql.exec(
+          "SELECT name, key, destroyed, generation FROM _rivetkit_metadata WHERE id = 1"
+        );
+        const result = cursor.raw().next();
+        if (!result.done && result.value) {
+          const name = result.value[0];
+          const key = JSON.parse(
+            result.value[1]
+          );
+          const destroyed = result.value[2];
+          const generation = result.value[3];
+          if (!destroyed) {
+            logger().debug({
+              msg: "already initialized",
+              name,
+              key,
+              generation
+            });
+            this.#state.initialized = { name, key, generation };
+          } else {
+            logger().debug("actor is destroyed, cannot load");
+            throw new Error("Actor is destroyed");
+          }
+        } else {
+          logger().debug("not initialized");
+          throw new Error("Actor is not initialized");
+        }
+      }
+      if (this.#state.actor) {
+        invariant2(
+          !this.#state.initialized || this.#state.actor.generation === this.#state.initialized.generation,
+          `Stale actor cached: actor generation ${this.#state.actor.generation} != initialized generation ${(_a = this.#state.initialized) == null ? void 0 : _a.generation}. This should not happen.`
+        );
+        return this.#state.actor;
+      }
+      if (!this.#state.initialized) throw new Error("Not initialized");
+      const actorId = this.ctx.id.toString();
+      globalState.setDOState(actorId, { ctx: this.ctx, env: env2 });
+      invariant2(runConfig.driver, "runConfig.driver");
+      runConfig.driver.actor = createCloudflareActorsActorDriverBuilder(globalState);
+      const managerDriver = runConfig.driver.manager(
+        registry.config,
+        runConfig
+      );
+      const inlineClient = createClientWithDriver(
+        managerDriver,
+        runConfig
+      );
+      const actorDriver = runConfig.driver.actor(
+        registry.config,
+        runConfig,
+        managerDriver,
+        inlineClient
+      );
+      const actorRouter = createActorRouter(
+        runConfig,
+        actorDriver,
+        false
+      );
+      this.#state.actor = {
+        actorRouter,
+        actorDriver,
+        generation: this.#state.initialized.generation
+      };
+      const actorIdWithGen = buildActorId(
+        actorId,
+        this.#state.initialized.generation
+      );
+      await actorDriver.loadActor(actorIdWithGen);
+      return this.#state.actor;
+    }
+    /** RPC called to get actor metadata without creating it */
+    async getMetadata() {
+      var _a;
+      const cursor = this.ctx.storage.sql.exec(
+        "SELECT name, key, destroyed, generation FROM _rivetkit_metadata WHERE id = 1"
+      );
+      const result = cursor.raw().next();
+      if (!result.done && result.value) {
+        const name = result.value[0];
+        const key = JSON.parse(result.value[1]);
+        const destroyed = result.value[2];
+        const generation = result.value[3];
+        if (destroyed) {
+          logger().debug({
+            msg: "getMetadata: actor is destroyed",
+            name,
+            key,
+            generation
+          });
+          return void 0;
+        }
+        const doId = this.ctx.id.toString();
+        const actorId = buildActorId(doId, generation);
+        const destroying = ((_a = globalState.getActorState(this.ctx)) == null ? void 0 : _a.destroying) ?? false;
+        logger().debug({
+          msg: "getMetadata: found actor metadata",
+          actorId,
+          name,
+          key,
+          generation,
+          destroying
+        });
+        return { actorId, name, key, destroying };
+      }
+      logger().debug({
+        msg: "getMetadata: no metadata found"
+      });
+      return void 0;
+    }
+    /** RPC called by the manager to create a DO. Can optionally allow existing actors. */
+    async create(req) {
+      const checkCursor = this.ctx.storage.sql.exec(
+        "SELECT destroyed, generation FROM _rivetkit_metadata WHERE id = 1"
+      );
+      const checkResult = checkCursor.raw().next();
+      let created = false;
+      let generation = 0;
+      if (!checkResult.done && checkResult.value) {
+        const destroyed = checkResult.value[0];
+        generation = checkResult.value[1];
+        if (!destroyed) {
+          if (!req.allowExisting) {
+            logger().debug({
+              msg: "create failed: actor already exists",
+              name: req.name,
+              key: req.key,
+              generation
+            });
+            return { error: { actorAlreadyExists: true } };
+          }
+          logger().debug({
+            msg: "actor already exists",
+            key: req.key,
+            generation
+          });
+          const doId2 = this.ctx.id.toString();
+          const actorId2 = buildActorId(doId2, generation);
+          return { success: { actorId: actorId2, created: false } };
+        }
+        generation = generation + 1;
+        created = true;
+        if (this.#state) {
+          this.#state.actor = void 0;
+        }
+        logger().debug({
+          msg: "resurrecting destroyed actor",
+          key: req.key,
+          oldGeneration: generation - 1,
+          newGeneration: generation
+        });
+      } else {
+        generation = 0;
+        created = true;
+        logger().debug({
+          msg: "creating new actor",
+          key: req.key,
+          generation
+        });
+      }
+      this.ctx.storage.sql.exec(
+        `INSERT INTO _rivetkit_metadata (id, name, key, destroyed, generation)
+				VALUES (1, ?, ?, 0, ?)
+				ON CONFLICT(id) DO UPDATE SET
+					name = excluded.name,
+					key = excluded.key,
+					destroyed = 0,
+					generation = excluded.generation`,
+        req.name,
+        JSON.stringify(req.key),
+        generation
+      );
+      this.#state.initialized = {
+        name: req.name,
+        key: req.key,
+        generation
+      };
+      const doId = this.ctx.id.toString();
+      const actorId = buildActorId(doId, generation);
+      if (created) {
+        initializeActorKvStorage(this.ctx.storage.sql, req.input);
+        const env3 = getCloudflareAmbientEnv();
+        const actorData = { name: req.name, key: req.key, generation };
+        this.ctx.waitUntil(
+          env3.ACTOR_KV.put(
+            GLOBAL_KV_KEYS.actorMetadata(actorId),
+            JSON.stringify(actorData)
+          )
+        );
+      }
+      await this.#loadActor();
+      logger().debug({
+        msg: created ? "actor created/resurrected" : "returning existing actor",
+        actorId,
+        created,
+        generation
+      });
+      return { success: { actorId, created } };
+    }
+    async fetch(request) {
+      const { actorRouter, generation } = await this.#loadActor();
+      const doId = this.ctx.id.toString();
+      const actorId = buildActorId(doId, generation);
+      return await actorRouter.fetch(request, {
+        actorId
+      });
+    }
+    async alarm() {
+      const { actorDriver, generation } = await this.#loadActor();
+      const doId = this.ctx.id.toString();
+      const actorId = buildActorId(doId, generation);
+      const actor = await actorDriver.loadActor(actorId);
+      await actor.onAlarm();
+    }
+  };
+}
+function initializeActorKvStorage(sql, input) {
+  const initialKvState = getInitialActorKvState(input);
+  for (const [key, value] of initialKvState) {
+    kvPut(sql, key, value);
+  }
 }
 export {
-  createHandler
+  createActorDurableObject,
+  createHandler,
+  createInlineClient
 };
 //# sourceMappingURL=mod.js.map