@rivetkit/cloudflare-workers 2.0.2 → 2.0.4-rc.1

package/dist/mod.js

@@ -1,266 +1,132 @@
-// src/handler.ts
-import { env as env2 } from "cloudflare:workers";
-import { Hono } from "hono";
-
 // src/actor-handler-do.ts
-import { DurableObject, env } from "cloudflare:workers";
-import {
-  createActorRouter,
-  createClientWithDriver,
-  createInlineClientDriver
-} from "@rivetkit/core";
-import { serializeEmptyPersistData } from "@rivetkit/core/driver-helpers";
+import { DurableObject, env as env2 } from "cloudflare:workers";
 import invariant2 from "invariant";
+import { createActorRouter, createClientWithDriver as createClientWithDriver2 } from "rivetkit";
+import { getInitialActorKvState } from "rivetkit/driver-helpers";
 
 // src/actor-driver.ts
-import {
-  createGenericConnDrivers,
-  GenericConnGlobalState,
-  lookupInRegistry
-} from "@rivetkit/core";
 import invariant from "invariant";
-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);
-  }
-};
-var ActorHandler = class {
-  actor;
-  actorPromise = Promise.withResolvers();
-  genericConnGlobalState = new GenericConnGlobalState();
-};
-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;
-  }
-  #getDOCtx(actorId) {
-    return this.#globalState.getDOState(actorId).ctx;
+import { lookupInRegistry } from "rivetkit";
+import { promiseWithResolvers } from "rivetkit/utils";
+
+// src/log.ts
+import { getLogger } from "rivetkit/log";
+function logger() {
+  return getLogger("driver-cloudflare-workers");
+}
+
+// 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`);
-    }
-    const definition = lookupInRegistry(this.#registryConfig, name);
-    handler.actor = definition.instantiate();
-    const connDrivers = createGenericConnDrivers(
-      handler.genericConnGlobalState
-    );
-    await handler.actor.start(
-      connDrivers,
-      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;
-  }
-  getGenericConnGlobalState(actorId) {
-    const handler = this.#actors.get(actorId);
-    if (!handler) {
-      throw new Error(`Actor ${actorId} not loaded`);
+  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]);
     }
-    return handler.genericConnGlobalState;
   }
-  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);
-  }
-  async setAlarm(actor, timestamp) {
-    await this.#getDOCtx(actor.id).storage.setAlarm(timestamp);
+  return entries;
+}
+function toUint8Array(value) {
+  var _a;
+  if (value instanceof Uint8Array) {
+    return value;
   }
-  async getDatabase(actorId) {
-    return this.#getDOCtx(actorId).storage.sql;
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
   }
-};
-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/core/log";
-var LOGGER_NAME = "driver-cloudflare-workers";
-function logger() {
-  return getLogger(LOGGER_NAME);
+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 = Promise.withResolvers();
-          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("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(
-        createInlineClientDriver(managerDriver)
-      );
-      const actorDriver = runConfig.driver.actor(
-        registry.config,
-        runConfig,
-        managerDriver,
-        inlineClient
-      );
-      const actorRouter = createActorRouter(runConfig, actorDriver);
-      this.#actor = {
-        actorRouter
-      };
-      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("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() {
-      await this.#loadActor();
-      const actorId = this.ctx.id.toString();
-      invariant2(runConfig.driver, "runConfig.driver");
-      const managerDriver = runConfig.driver.manager(
-        registry.config,
-        runConfig
-      );
-      const inlineClient = createClientWithDriver(
-        createInlineClientDriver(managerDriver)
-      );
-      const actorDriver = runConfig.driver.actor(
-        registry.config,
-        runConfig,
-        managerDriver,
-        inlineClient
-      );
-      const actor = await actorDriver.loadActor(actorId);
-      await actor.onAlarm();
-    }
-  };
-}
+
+// src/handler.ts
+import { env } from "cloudflare:workers";
+import { createClientWithDriver } from "rivetkit";
+import { buildManagerRouter } from "rivetkit/driver-helpers";
 
 // src/config.ts
-import { RunConfigSchema } from "@rivetkit/core/driver-helpers";
-import { z } from "zod";
-var ConfigSchema = RunConfigSchema.removeDefault().omit({ driver: true, getUpgradeWebSocket: true }).extend({
-  app: z.custom().optional()
-}).default({});
+import { z } from "zod/v4";
+var ConfigSchemaBase = z.object({
+  /** Path that the Rivet manager API will be mounted. */
+  managerPath: z.string().optional().default("/api/rivet"),
+  /** Runner key for authentication. */
+  runnerKey: z.string().optional(),
+  /** Disable the welcome message. */
+  noWelcome: z.boolean().optional().default(false),
+  fetch: z.custom().optional()
+});
+var ConfigSchema = ConfigSchemaBase.default(
+  () => ConfigSchemaBase.parse({})
+);
 
 // src/manager-driver.ts
 import {
-  HEADER_AUTH_DATA,
-  HEADER_CONN_PARAMS,
-  HEADER_ENCODING,
-  HEADER_EXPOSE_INTERNAL_ERROR
-} from "@rivetkit/core/driver-helpers";
-import { ActorAlreadyExists, InternalError } from "@rivetkit/core/errors";
+  WS_PROTOCOL_ACTOR,
+  WS_PROTOCOL_CONN_PARAMS,
+  WS_PROTOCOL_ENCODING,
+  WS_PROTOCOL_STANDARD,
+  WS_PROTOCOL_TARGET
+} from "rivetkit/driver-helpers";
+import {
+  ActorDuplicateKey,
+  ActorNotFound,
+  InternalError
+} from "rivetkit/errors";
+import { assertUnreachable } from "rivetkit/utils";
+
+// 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}`);
+  }
+  const [doId, generationStr] = parts;
+  const generation = parseInt(generationStr, 10);
+  if (Number.isNaN(generation)) {
+    throw new Error(`Invalid generation number in actor ID: ${actorId}`);
+  }
+  return [doId, generation];
+}
 
 // src/util.ts
 var EMPTY_KEY = "(none)";
@@ -289,16 +155,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",
@@ -310,45 +166,61 @@ var STANDARD_WEBSOCKET_HEADERS = [
 var CloudflareActorsManagerDriver = class {
   async sendRequest(actorId, actorRequest) {
     const env3 = getCloudflareAmbientEnv();
-    logger().debug("sending request to durable object", {
+    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) {
     const env3 = getCloudflareAmbientEnv();
-    logger().debug("opening websocket to durable object", { actorId, path });
-    const id = env3.ACTOR_DO.idFromString(actorId);
+    const [doId] = parseActorId(actorId);
+    logger().debug({
+      msg: "opening websocket to durable object",
+      actorId,
+      doId,
+      path
+    });
+    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}${encodeURIComponent(actorId)}`);
+    protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+    if (params) {
+      protocols.push(
+        `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+      );
+    }
     const headers = {
       Upgrade: "websocket",
       Connection: "Upgrade",
-      [HEADER_EXPOSE_INTERNAL_ERROR]: "true",
-      [HEADER_ENCODING]: encoding
+      "sec-websocket-protocol": protocols.join(", ")
     };
-    if (params) {
-      headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
-    }
-    headers["sec-websocket-protocol"] = "rivetkit";
-    const url = `http://actor${path}`;
-    logger().debug("rewriting websocket url", {
-      from: path,
-      to: url
-    });
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = `http://actor${normalizedPath}`;
+    logger().debug({ msg: "rewriting websocket url", from: path, to: url });
     const response = await stub.fetch(url, {
       headers
     });
     const webSocket = response.webSocket;
     if (!webSocket) {
       throw new InternalError(
-        "missing websocket connection in response from DO"
+        `missing websocket connection in response from DO
+
+Status: ${response.status}
+Response: ${await response.text()}`
       );
     }
-    logger().debug("durable object websocket connection open", {
+    logger().debug({
+      msg: "durable object websocket connection open",
       actorId
     });
     webSocket.accept();
@@ -360,18 +232,26 @@ var CloudflareActorsManagerDriver = class {
     }, 0);
     return webSocket;
   }
+  async buildGatewayUrl(actorId) {
+    return `http://actor/gateway/${encodeURIComponent(actorId)}`;
+  }
   async proxyRequest(c, actorRequest, actorId) {
-    logger().debug("forwarding request to durable object", {
+    const env3 = getCloudflareAmbientEnv();
+    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 stub = c.env.ACTOR_DO.get(id);
+    const id = env3.ACTOR_DO.idFromString(doId);
+    const stub = env3.ACTOR_DO.get(id);
     return await stub.fetch(actorRequest);
   }
-  async proxyWebSocket(c, path, actorId, encoding, params, authData) {
-    logger().debug("forwarding websocket to durable object", {
+  async proxyWebSocket(c, path, actorId, encoding, params) {
+    logger().debug({
+      msg: "forwarding websocket to durable object",
       actorId,
       path
     });
@@ -383,44 +263,72 @@ var CloudflareActorsManagerDriver = class {
     }
     const newUrl = new URL(`http://actor${path}`);
     const actorRequest = new Request(newUrl, c.req.raw);
-    logger().debug("rewriting websocket url", {
+    logger().debug({
+      msg: "rewriting websocket url",
       from: c.req.url,
       to: actorRequest.url
     });
     const headerKeys = [];
-    actorRequest.headers.forEach((v, k) => headerKeys.push(k));
+    actorRequest.headers.forEach((v, k) => {
+      headerKeys.push(k);
+    });
     for (const k of headerKeys) {
       if (!STANDARD_WEBSOCKET_HEADERS.includes(k)) {
         actorRequest.headers.delete(k);
       }
     }
-    actorRequest.headers.set(HEADER_EXPOSE_INTERNAL_ERROR, "true");
-    actorRequest.headers.set(HEADER_ENCODING, encoding);
+    const protocols = [];
+    protocols.push(WS_PROTOCOL_STANDARD);
+    protocols.push(`${WS_PROTOCOL_TARGET}actor`);
+    protocols.push(`${WS_PROTOCOL_ACTOR}${encodeURIComponent(actorId)}`);
+    protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
     if (params) {
-      actorRequest.headers.set(HEADER_CONN_PARAMS, JSON.stringify(params));
-    }
-    if (authData) {
-      actorRequest.headers.set(HEADER_AUTH_DATA, JSON.stringify(authData));
+      protocols.push(
+        `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
+      );
     }
-    const id = c.env.ACTOR_DO.idFromString(actorId);
-    const stub = c.env.ACTOR_DO.get(id);
+    actorRequest.headers.set(
+      "sec-websocket-protocol",
+      protocols.join(", ")
+    );
+    const env3 = getCloudflareAmbientEnv();
+    const [doId] = parseActorId(actorId);
+    const id = env3.ACTOR_DO.idFromString(doId);
+    const stub = env3.ACTOR_DO.get(id);
     return await stub.fetch(actorRequest);
   }
   async getForId({
     c,
+    name,
     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({
@@ -429,33 +337,68 @@ var CloudflareActorsManagerDriver = class {
     key
   }) {
     const env3 = getCloudflareAmbientEnv();
-    logger().debug("getWithKey: searching for actor", { name, key });
+    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) {
-      logger().debug("getWithKey: no actor found with matching name and key", {
+    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("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({
@@ -465,50 +408,62 @@ var CloudflareActorsManagerDriver = class {
     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
-    };
+    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);
+      }
+      throw new InternalError(
+        `Unknown error creating actor: ${JSON.stringify(result.error)}`
+      );
+    } else {
+      assertUnreachable(result);
+    }
   }
-  // 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"
+  async listActors({ c, name }) {
+    logger().warn({
+      msg: "listActors not fully implemented for Cloudflare Workers",
+      name
     });
-    if (!actorData) {
-      return void 0;
-    }
+    return [];
+  }
+  displayInformation() {
     return {
-      actorId,
-      name: actorData.name,
-      key: actorData.key
+      properties: {
+        Driver: "Cloudflare Workers"
+      }
     };
   }
+  setGetUpgradeWebSocket() {
+  }
+  async kvGet(actorId, key) {
+    const env3 = getCloudflareAmbientEnv();
+    const [doId] = parseActorId(actorId);
+    const id = env3.ACTOR_DO.idFromString(doId);
+    const stub = env3.ACTOR_DO.get(id);
+    const value = await stub.managerKvGet(key);
+    return value !== null ? new TextDecoder().decode(value) : null;
+  }
 };
 
 // src/websocket.ts
 import { defineWebSocketHelper, WSContext } from "hono/ws";
+import { WS_PROTOCOL_STANDARD as WS_PROTOCOL_STANDARD2 } from "rivetkit/driver-helpers";
 var upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
   var _a, _b;
   const upgradeHeader = c.req.header("Upgrade");
@@ -559,60 +514,532 @@ var upgradeWebSocket = defineWebSocketHelper(async (c, events) => {
   }
   (_a = server.accept) == null ? void 0 : _a.call(server);
   (_b = events.onOpen) == null ? void 0 : _b.call(events, new Event("open"), wsContext);
+  const headers = {};
+  const protocols = c.req.header("Sec-WebSocket-Protocol");
+  if (typeof protocols === "string" && protocols.split(",").map((x) => x.trim()).includes(WS_PROTOCOL_STANDARD2)) {
+    headers["Sec-WebSocket-Protocol"] = WS_PROTOCOL_STANDARD2;
+  }
   return new Response(null, {
     status: 101,
-    headers: {
-      // HACK: Required in order for Cloudflare to not error with "Network connection lost"
-      //
-      // This bug undocumented. Cannot easily reproduce outside of RivetKit.
-      "Sec-WebSocket-Protocol": "rivetkit"
-    },
+    headers,
     webSocket: client
   });
 });
 
 // src/handler.ts
 function getCloudflareAmbientEnv() {
-  return env2;
-}
-function createServerHandler(registry, inputConfig) {
-  const { createHandler } = createServer(registry, inputConfig);
-  return createHandler();
+  return env;
 }
-function createServer(registry, inputConfig) {
+function createInlineClient(registry, inputConfig) {
+  inputConfig = { ...inputConfig, runnerKey: "" };
   const config = ConfigSchema.parse(inputConfig);
-  const runConfig = {
-    ...config,
-    // The worker acts as a server and doesn't run actors
-    role: "server",
-    driver: {
-      name: "cloudflare-workers",
-      manager: () => new CloudflareActorsManagerDriver(),
-      // HACK: We can't build the actor driver until we're inside the Durable Object
-      actor: void 0
-    },
-    getUpgradeWebSocket: () => upgradeWebSocket
+  const ActorHandler = createActorDurableObject(
+    registry,
+    () => upgradeWebSocket
+  );
+  registry.config.noWelcome = true;
+  registry.config.inspector = {
+    enabled: false,
+    token: () => ""
+  };
+  registry.config.managerBasePath = "/";
+  const parsedConfig = registry.parseConfig();
+  const managerDriver = new CloudflareActorsManagerDriver();
+  const { router } = buildManagerRouter(
+    parsedConfig,
+    managerDriver,
+    () => upgradeWebSocket
+  );
+  const client = createClientWithDriver(managerDriver);
+  return { client, fetch: router.fetch.bind(router), config, ActorHandler };
+}
+function createHandler(registry, inputConfig) {
+  const { client, fetch, config, ActorHandler } = createInlineClient(
+    registry,
+    inputConfig
+  );
+  const handler = {
+    fetch: async (request, cfEnv, ctx) => {
+      const url = new URL(request.url);
+      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 fetch(modifiedRequest, env3, ctx);
+      }
+      if (config.fetch) {
+        return config.fetch(request, env3, ctx);
+      } else {
+        return new Response(
+          "This is a RivetKit server.\n\nLearn more at https://rivet.dev\n",
+          { status: 200 }
+        );
+      }
+    }
+  };
+  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;
+  #managerDriver;
+  #inlineClient;
+  #globalState;
+  constructor(registryConfig, managerDriver, inlineClient, globalState) {
+    this.#registryConfig = registryConfig;
+    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((reason) => logger().warn({ msg: "unhandled actor promise rejection", reason }));
+      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 (config, managerDriver, inlineClient) => {
+    return new CloudflareActorsActorDriver(
+      config,
+      managerDriver,
+      inlineClient,
+      globalState
+    );
   };
-  const ActorHandler2 = createActorDurableObject(registry, runConfig);
-  const serverOutput = registry.createServer(runConfig);
-  return {
-    client: serverOutput.client,
-    createHandler: (hono) => {
-      const app = hono ?? new Hono();
-      if (!hono) {
-        app.route("/registry", serverOutput.hono);
+}
+
+// src/actor-handler-do.ts
+function createActorDurableObject(registry, getUpgradeWebSocket) {
+  const globalState = new CloudflareDurableObjectGlobalState();
+  const parsedConfig = registry.parseConfig();
+  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, _b;
+      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;
       }
-      const handler = {
-        fetch: (request, env3, ctx) => {
-          return app.fetch(request, env3, ctx);
+      if (!this.#state.initialized) throw new Error("Not initialized");
+      const actorId = this.ctx.id.toString();
+      globalState.setDOState(actorId, { ctx: this.ctx, env: env2 });
+      const managerDriver = new CloudflareActorsManagerDriver();
+      const inlineClient = createClientWithDriver2(managerDriver);
+      const actorDriverBuilder = createCloudflareActorsActorDriverBuilder(globalState);
+      const actorDriver = actorDriverBuilder(
+        parsedConfig,
+        managerDriver,
+        inlineClient
+      );
+      const actorRouter = createActorRouter(
+        parsedConfig,
+        actorDriver,
+        getUpgradeWebSocket,
+        ((_b = registry.config.test) == null ? void 0 : _b.enabled) ?? 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 ManagerDriver.kvGet to read from KV. */
+    async managerKvGet(key) {
+      return kvGet(this.ctx.storage.sql, key);
+    }
+    /** 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
       };
-      return { handler, ActorHandler: ActorHandler2 };
+      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 {
-  createServer,
-  createServerHandler
+  createActorDurableObject,
+  createHandler,
+  createInlineClient
 };
 //# sourceMappingURL=mod.js.map