rivetkit 2.1.5 → 2.1.6-rc.1

package/dist/tsup/{chunk-JPXO2H55.js → chunk-WW27B6DM.js}

@@ -1,7 +1,7 @@
 import {
   importWebSocket,
   logger
-} from "./chunk-2OK7S6QF.js";
+} from "./chunk-I5I6OALK.js";
 import {
   CURRENT_VERSION,
   EncodingSchema,
@@ -36,12 +36,11 @@ import {
   serializeWithEncoding,
   tryParseEndpoint,
   uint8ArrayToBase64
-} from "./chunk-MIX2KB6U.js";
+} from "./chunk-PQWI44WD.js";
 import {
   assertUnreachable as assertUnreachable2
-} from "./chunk-TADUYCHF.js";
+} from "./chunk-C22JYHVT.js";
 import {
-  VERSION,
   assertUnreachable,
   bufferToArrayBuffer,
   combineUrlPath,
@@ -58,46 +57,11 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-EIATSBYZ.js";
+} from "./chunk-VWYO36X4.js";
 import {
   ActorNotFound,
   InvalidRequest
-} from "./chunk-7HTNH26M.js";
-
-// src/devtools-loader/log.ts
-function logger2() {
-  return getLogger("devtools");
-}
-
-// src/devtools-loader/index.ts
-var DEFAULT_DEVTOOLS_URL = (version = VERSION) => `https://releases.rivet.dev/rivet/latest/devtools/mod.js?v=${version}`;
-var scriptId = "rivetkit-devtools-script";
-function injectDevtools(config) {
-  if (!window) {
-    logger2().warn("devtools not available outside browser environment");
-    return;
-  }
-  if (!document.getElementById(scriptId)) {
-    const script = document.createElement("script");
-    script.id = scriptId;
-    script.src = DEFAULT_DEVTOOLS_URL();
-    script.async = true;
-    document.head.appendChild(script);
-  }
-  window.__rivetkit = window.__rivetkit || [];
-  window.__rivetkit.push(config);
-}
-
-// src/remote-manager-driver/mod.ts
-import * as cbor2 from "cbor-x";
-import invariant2 from "invariant";
-
-// src/remote-manager-driver/api-utils.ts
-import { z } from "zod/v4";
-
-// src/client/utils.ts
-import * as cbor from "cbor-x";
-import invariant from "invariant";
+} from "./chunk-AKUJ5OTO.js";
 
 // src/client/errors.ts
 var ActorClientError = class extends Error {
@@ -152,7 +116,102 @@ var ActorSchedulingError = class extends ActorError {
   }
 };
 
+// src/client/actor-conn.ts
+import * as cbor4 from "cbor-x";
+import invariant4 from "invariant";
+import pRetry from "p-retry";
+
+// src/client/actor-query.ts
+async function queryActor(c, query, managerDriver) {
+  logger().debug({ msg: "querying actor", query: JSON.stringify(query) });
+  let actorOutput;
+  if ("getForId" in query) {
+    const output = await managerDriver.getForId({
+      c,
+      name: query.getForId.name,
+      actorId: query.getForId.actorId
+    });
+    if (!output) throw new ActorNotFound(query.getForId.actorId);
+    actorOutput = output;
+  } else if ("getForKey" in query) {
+    const existingActor = await managerDriver.getWithKey({
+      c,
+      name: query.getForKey.name,
+      key: query.getForKey.key
+    });
+    if (!existingActor) {
+      throw new ActorNotFound(
+        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
+      );
+    }
+    actorOutput = existingActor;
+  } else if ("getOrCreateForKey" in query) {
+    const getOrCreateOutput = await managerDriver.getOrCreateWithKey({
+      c,
+      name: query.getOrCreateForKey.name,
+      key: query.getOrCreateForKey.key,
+      input: query.getOrCreateForKey.input,
+      region: query.getOrCreateForKey.region
+    });
+    actorOutput = {
+      actorId: getOrCreateOutput.actorId
+    };
+  } else if ("create" in query) {
+    const createOutput = await managerDriver.createActor({
+      c,
+      name: query.create.name,
+      key: query.create.key,
+      input: query.create.input,
+      region: query.create.region
+    });
+    actorOutput = {
+      actorId: createOutput.actorId
+    };
+  } else {
+    throw new InvalidRequest("Invalid query format");
+  }
+  logger().debug({ msg: "actor query result", actorId: actorOutput.actorId });
+  return { actorId: actorOutput.actorId };
+}
+function getActorNameFromQuery(query) {
+  if ("getForId" in query) return query.getForId.name;
+  if ("getForKey" in query) return query.getForKey.name;
+  if ("getOrCreateForKey" in query) return query.getOrCreateForKey.name;
+  if ("create" in query) return query.create.name;
+  throw new InvalidRequest("Invalid query format");
+}
+async function checkForSchedulingError(group, code, actorId, query, driver) {
+  const name = getActorNameFromQuery(query);
+  try {
+    const actor = await driver.getForId({ name, actorId });
+    if (actor == null ? void 0 : actor.error) {
+      logger().info({
+        msg: "found actor scheduling error",
+        actorId,
+        error: actor.error
+      });
+      return new ActorSchedulingError(group, code, actorId, actor.error);
+    }
+  } catch (err) {
+    logger().warn({
+      msg: "failed to fetch actor details for scheduling error check",
+      actorId,
+      error: stringifyError(err)
+    });
+  }
+  return null;
+}
+
+// src/client/actor-handle.ts
+import * as cbor3 from "cbor-x";
+import invariant3 from "invariant";
+
+// src/client/queue.ts
+import * as cbor2 from "cbor-x";
+
 // src/client/utils.ts
+import * as cbor from "cbor-x";
+import invariant from "invariant";
 function parseWebSocketCloseReason(reason) {
   const [mainPart, rayId] = reason.split("#");
   const [group, code] = mainPart.split(".");
@@ -291,804 +350,664 @@ ${textResponse}`
   }
 }
 
-// src/remote-manager-driver/log.ts
-function logger3() {
-  return getLogger("remote-manager-driver");
-}
-
-// src/remote-manager-driver/api-utils.ts
-var EngineApiError = class extends Error {
-  constructor(group, code, message) {
-    super(message || `Engine API error: ${group}/${code}`);
-    this.group = group;
-    this.code = code;
-    this.name = "EngineApiError";
+// src/client/queue.ts
+function createQueueSender(senderOptions) {
+  async function send(name, body, options) {
+    const wait = (options == null ? void 0 : options.wait) ?? false;
+    const timeout = options == null ? void 0 : options.timeout;
+    const result = await sendHttpRequest({
+      url: `http://actor/queue/${encodeURIComponent(name)}`,
+      method: "POST",
+      headers: {
+        [HEADER_ENCODING]: senderOptions.encoding,
+        ...senderOptions.params !== void 0 ? {
+          [HEADER_CONN_PARAMS]: JSON.stringify(
+            senderOptions.params
+          )
+        } : {}
+      },
+      body: { body, wait, timeout },
+      encoding: senderOptions.encoding,
+      customFetch: senderOptions.customFetch,
+      signal: options == null ? void 0 : options.signal,
+      requestVersion: CURRENT_VERSION,
+      requestVersionedDataHandler: HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+      responseVersion: CURRENT_VERSION,
+      responseVersionedDataHandler: HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+      requestZodSchema: HttpQueueSendRequestSchema,
+      responseZodSchema: HttpQueueSendResponseSchema,
+      requestToJson: (value) => ({
+        ...value,
+        name
+      }),
+      requestToBare: (value) => ({
+        name: value.name ?? name,
+        body: bufferToArrayBuffer(cbor2.encode(value.body)),
+        wait: value.wait ?? false,
+        timeout: value.timeout !== void 0 ? BigInt(value.timeout) : null
+      }),
+      responseFromJson: (json) => {
+        if (json.response === void 0) {
+          return { status: json.status };
+        }
+        return {
+          status: json.status,
+          response: json.response
+        };
+      },
+      responseFromBare: (bare) => {
+        if (bare.response === null || bare.response === void 0) {
+          return { status: bare.status };
+        }
+        return {
+          status: bare.status,
+          response: cbor2.decode(new Uint8Array(bare.response))
+        };
+      }
+    });
+    if (wait) {
+      return result;
+    }
+    return;
   }
-};
-function getEndpoint(config) {
-  return config.endpoint ?? "http://127.0.0.1:6420";
-}
-async function apiCall(config, method, path, body) {
-  const endpoint = getEndpoint(config);
-  const url = combineUrlPath(endpoint, path, {
-    namespace: config.namespace
-  });
-  logger3().debug({ msg: "making api call", method, url });
-  const headers = {
-    ...config.headers
+  return {
+    send
   };
-  if (config.token) {
-    headers.Authorization = `Bearer ${config.token}`;
-  }
-  return await sendHttpRequest({
-    method,
-    url,
-    headers,
-    body,
-    encoding: "json",
-    skipParseResponse: false,
-    requestVersionedDataHandler: void 0,
-    requestVersion: void 0,
-    responseVersionedDataHandler: void 0,
-    responseVersion: void 0,
-    requestZodSchema: z.any(),
-    responseZodSchema: z.any(),
-    // Identity conversions (passthrough for generic API calls)
-    requestToJson: (value) => value,
-    requestToBare: (value) => value,
-    responseFromJson: (value) => value,
-    responseFromBare: (value) => value
-  });
-}
-
-// src/remote-manager-driver/actor-websocket-client.ts
-function buildActorGatewayUrl(endpoint, actorId, token, path = "") {
-  const tokenSegment = token !== void 0 ? `@${encodeURIComponent(token)}` : "";
-  const gatewayPath = `/gateway/${encodeURIComponent(actorId)}${tokenSegment}${path}`;
-  return combineUrlPath(endpoint, gatewayPath);
-}
-async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
-  const WebSocket2 = await importWebSocket();
-  const endpoint = getEndpoint(runConfig);
-  const guardUrl = buildActorGatewayUrl(
-    endpoint,
-    actorId,
-    runConfig.token,
-    path
-  );
-  logger3().debug({
-    msg: "opening websocket to actor via guard",
-    actorId,
-    path,
-    guardUrl
-  });
-  const ws = new WebSocket2(
-    guardUrl,
-    buildWebSocketProtocols(runConfig, encoding, params)
-  );
-  ws.binaryType = "arraybuffer";
-  logger3().debug({ msg: "websocket connection opened", actorId });
-  return ws;
-}
-function buildWebSocketProtocols(runConfig, encoding, params) {
-  const protocols = [];
-  protocols.push(WS_PROTOCOL_STANDARD);
-  protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
-  if (params) {
-    protocols.push(
-      `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
-    );
-  }
-  return protocols;
 }
 
-// src/remote-manager-driver/actor-http-client.ts
-async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
-  const url = new URL(actorRequest.url);
-  const endpoint = getEndpoint(runConfig);
-  const guardUrl = buildActorGatewayUrl(
-    endpoint,
-    actorId,
-    runConfig.token,
-    `${url.pathname}${url.search}`
-  );
-  let bodyToSend = null;
-  const guardHeaders = buildGuardHeadersForHttp(
-    runConfig,
-    actorRequest,
-    actorId
-  );
-  if (actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
-    if (actorRequest.bodyUsed) {
-      throw new Error("Request body has already been consumed");
-    }
-    const reqBody = await actorRequest.arrayBuffer();
-    if (reqBody.byteLength !== 0) {
-      bodyToSend = reqBody;
-      guardHeaders.delete("transfer-encoding");
-      guardHeaders.set("content-length", String(bodyToSend.byteLength));
+// src/client/raw-utils.ts
+import invariant2 from "invariant";
+async function rawHttpFetch(driver, actorQuery, params, input, init) {
+  let path;
+  let mergedInit = init || {};
+  if (typeof input === "string") {
+    path = input;
+  } else if (input instanceof URL) {
+    path = input.pathname + input.search;
+  } else if (input instanceof Request) {
+    const url = new URL(input.url);
+    path = url.pathname + url.search;
+    const requestHeaders = new Headers(input.headers);
+    const initHeaders = new Headers((init == null ? void 0 : init.headers) || {});
+    const mergedHeaders = new Headers(requestHeaders);
+    initHeaders.forEach((value, key) => {
+      mergedHeaders.set(key, value);
+    });
+    mergedInit = {
+      method: input.method,
+      body: input.body,
+      mode: input.mode,
+      credentials: input.credentials,
+      redirect: input.redirect,
+      referrer: input.referrer,
+      referrerPolicy: input.referrerPolicy,
+      integrity: input.integrity,
+      keepalive: input.keepalive,
+      signal: input.signal,
+      ...mergedInit,
+      // init overrides Request properties
+      headers: mergedHeaders
+      // headers must be set after spread to ensure proper merge
+    };
+    if (mergedInit.body) {
+      mergedInit.duplex = "half";
     }
+  } else {
+    throw new TypeError("Invalid input type for fetch");
   }
-  const guardRequest = new Request(guardUrl, {
-    method: actorRequest.method,
-    headers: guardHeaders,
-    body: bodyToSend,
-    signal: actorRequest.signal
-  });
-  return mutableResponse(await fetch(guardRequest));
-}
-function mutableResponse(fetchRes) {
-  return new Response(fetchRes.body, fetchRes);
-}
-function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
-  const headers = new Headers();
-  actorRequest.headers.forEach((value, key) => {
-    headers.set(key, value);
-  });
-  for (const [key, value] of Object.entries(runConfig.headers)) {
-    headers.set(key, value);
-  }
-  if (runConfig.token) {
-    headers.set(HEADER_RIVET_TOKEN, runConfig.token);
-  }
-  return headers;
-}
-
-// src/remote-manager-driver/api-endpoints.ts
-async function getActor(config, _, actorId) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors?actor_ids=${encodeURIComponent(actorId)}`
-  );
-}
-async function getActorByKey(config, name, key) {
-  const serializedKey = serializeActorKey(key);
-  return apiCall(
-    config,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
-  );
-}
-async function listActorsByName(config, name) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors?name=${encodeURIComponent(name)}`
-  );
-}
-async function getOrCreateActor(config, request) {
-  return apiCall(
-    config,
-    "PUT",
-    `/actors`,
-    request
-  );
-}
-async function createActor(config, request) {
-  return apiCall(
-    config,
-    "POST",
-    `/actors`,
-    request
-  );
-}
-async function destroyActor(config, actorId) {
-  return apiCall(
-    config,
-    "DELETE",
-    `/actors/${encodeURIComponent(actorId)}`
-  );
-}
-async function getMetadata(config) {
-  return apiCall(config, "GET", `/metadata`);
-}
-async function getDatacenters(config) {
-  return apiCall(config, "GET", `/datacenters`);
-}
-async function updateRunnerConfig(config, runnerName, request) {
-  return apiCall(
-    config,
-    "PUT",
-    `/runner-configs/${runnerName}`,
-    request
-  );
-}
-async function kvGet(config, actorId, key) {
-  return apiCall(
-    config,
-    "GET",
-    `/actors/${encodeURIComponent(actorId)}/kv/keys/${encodeURIComponent(key)}`
-  );
-}
-
-// src/remote-manager-driver/metadata.ts
-import pRetry from "p-retry";
-var metadataLookupCache = /* @__PURE__ */ new Map();
-async function lookupMetadataCached(config) {
-  const endpoint = getEndpoint(config);
-  const existingPromise = metadataLookupCache.get(endpoint);
-  if (existingPromise) {
-    return existingPromise;
-  }
-  const metadataLookupPromise = pRetry(
-    async () => {
-      logger3().debug({
-        msg: "fetching metadata",
-        endpoint
-      });
-      const metadataData = await getMetadata(config);
-      logger3().debug({
-        msg: "received metadata",
-        endpoint,
-        clientEndpoint: metadataData.clientEndpoint
-      });
-      return metadataData;
-    },
-    {
-      forever: true,
-      minTimeout: 500,
-      maxTimeout: 15e3,
-      onFailedAttempt: (error) => {
-        if (error.attemptNumber > 1) {
-          logger3().warn({
-            msg: "failed to fetch metadata, retrying",
-            endpoint,
-            attempt: error.attemptNumber,
-            error: stringifyError(error)
-          });
-        }
-      }
+  try {
+    const { actorId } = await queryActor(void 0, actorQuery, driver);
+    logger().debug({ msg: "found actor for raw http", actorId });
+    invariant2(actorId, "Missing actor ID");
+    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    const url = new URL(`http://actor/request/${normalizedPath}`);
+    const proxyRequestHeaders = new Headers(mergedInit.headers);
+    if (params) {
+      proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
     }
-  );
-  metadataLookupCache.set(endpoint, metadataLookupPromise);
-  return metadataLookupPromise;
+    const proxyRequest = new Request(url, {
+      ...mergedInit,
+      headers: proxyRequestHeaders
+    });
+    return driver.sendRequest(actorId, proxyRequest);
+  } catch (err) {
+    const { group, code, message, metadata } = deconstructError(
+      err,
+      logger(),
+      {},
+      true
+    );
+    throw new ActorError(group, code, message, metadata);
+  }
 }
-
-// src/remote-manager-driver/ws-proxy.ts
-async function createWebSocketProxy(c, targetUrl, protocols) {
-  const WebSocket2 = await importWebSocket();
-  const state = {};
-  return {
-    onOpen: async (event, clientWs) => {
-      logger3().debug({ msg: "client websocket connected", targetUrl });
-      if (clientWs.readyState !== 1) {
-        logger3().warn({
-          msg: "client websocket not open on connection",
-          targetUrl,
-          readyState: clientWs.readyState
-        });
-        return;
-      }
-      const targetWs = new WebSocket2(targetUrl, protocols);
-      state.targetWs = targetWs;
-      state.connectPromise = new Promise((resolve, reject) => {
-        targetWs.addEventListener("open", () => {
-          logger3().debug({
-            msg: "target websocket connected",
-            targetUrl
-          });
-          if (clientWs.readyState !== 1) {
-            logger3().warn({
-              msg: "client websocket closed before target connected",
-              targetUrl,
-              clientReadyState: clientWs.readyState
-            });
-            targetWs.close(1001, "Client disconnected");
-            reject(new Error("Client disconnected"));
-            return;
-          }
-          resolve();
-        });
-        targetWs.addEventListener("error", (error) => {
-          logger3().warn({
-            msg: "target websocket error during connection",
-            targetUrl
-          });
-          reject(error);
-        });
-      });
-      state.targetWs.addEventListener("message", (event2) => {
-        if (typeof event2.data === "string" || event2.data instanceof ArrayBuffer) {
-          clientWs.send(event2.data);
-        } else if (event2.data instanceof Blob) {
-          event2.data.arrayBuffer().then((buffer) => {
-            clientWs.send(buffer);
-          });
-        }
-      });
-      state.targetWs.addEventListener("close", (event2) => {
-        logger3().debug({
-          msg: "target websocket closed",
-          targetUrl,
-          code: event2.code,
-          reason: event2.reason
-        });
-        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
-      });
-      state.targetWs.addEventListener("error", (error) => {
-        logger3().error({
-          msg: "target websocket error",
-          targetUrl,
-          error: stringifyError(error)
-        });
-        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
-      });
-    },
-    onMessage: async (event, clientWs) => {
-      if (!state.targetWs || !state.connectPromise) {
-        logger3().error({
-          msg: "websocket state not initialized",
-          targetUrl
-        });
-        return;
-      }
-      try {
-        await state.connectPromise;
-        if (state.targetWs.readyState === WebSocket2.OPEN) {
-          state.targetWs.send(event.data);
-        } else {
-          logger3().warn({
-            msg: "target websocket not open",
-            targetUrl,
-            readyState: state.targetWs.readyState
-          });
-        }
-      } catch (error) {
-        logger3().error({
-          msg: "failed to connect to target websocket",
-          targetUrl,
-          error
-        });
-        closeWebSocketIfOpen(
-          clientWs,
-          1011,
-          "Failed to connect to target"
+async function rawWebSocket(driver, actorQuery, params, path, protocols) {
+  const encoding = "bare";
+  const { actorId } = await queryActor(void 0, actorQuery, driver);
+  logger().debug({ msg: "found actor for action", actorId });
+  invariant2(actorId, "Missing actor ID");
+  let pathPortion = "";
+  let queryPortion = "";
+  if (path) {
+    const queryIndex = path.indexOf("?");
+    if (queryIndex !== -1) {
+      pathPortion = path.substring(0, queryIndex);
+      queryPortion = path.substring(queryIndex);
+    } else {
+      pathPortion = path;
+    }
+    if (pathPortion.startsWith("/")) {
+      pathPortion = pathPortion.slice(1);
+    }
+  }
+  const fullPath = `${PATH_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
+  logger().debug({
+    msg: "opening websocket",
+    actorId,
+    encoding,
+    path: fullPath
+  });
+  const ws = await driver.openWebSocket(fullPath, actorId, encoding, params);
+  return ws;
+}
+
+// src/client/actor-handle.ts
+var ActorHandleRaw = class {
+  #client;
+  #driver;
+  #encoding;
+  #actorQuery;
+  #params;
+  #getParams;
+  #queueSender;
+  /**
+   * Do not call this directly.
+   *
+   * Creates an instance of ActorHandleRaw.
+   *
+   * @protected
+   */
+  constructor(client, driver, params, getParams, encoding, actorQuery) {
+    this.#client = client;
+    this.#driver = driver;
+    this.#encoding = encoding;
+    this.#actorQuery = actorQuery;
+    this.#params = params;
+    this.#getParams = getParams;
+    this.#queueSender = createQueueSender({
+      encoding: this.#encoding,
+      params: this.#params,
+      customFetch: async (request) => {
+        const { actorId } = await queryActor(
+          void 0,
+          this.#actorQuery,
+          this.#driver
         );
+        return this.#driver.sendRequest(actorId, request);
       }
-    },
-    onClose: (event, clientWs) => {
-      logger3().debug({
-        msg: "client websocket closed",
-        targetUrl,
-        code: event.code,
-        reason: event.reason,
-        wasClean: event.wasClean
+    });
+  }
+  async #resolveConnectionParams() {
+    if (this.#getParams) {
+      return await this.#getParams();
+    }
+    return this.#params;
+  }
+  send(name, body, options) {
+    return this.#queueSender.send(name, body, options);
+  }
+  /**
+   * Call a raw action. This method sends an HTTP request to invoke the named action.
+   *
+   * @see {@link ActorHandle}
+   * @template Args - The type of arguments to pass to the action function.
+   * @template Response - The type of the response returned by the action function.
+   */
+  async action(opts) {
+    let actorId;
+    try {
+      const result = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
+      );
+      actorId = result.actorId;
+      logger().debug({ msg: "found actor for action", actorId });
+      invariant3(actorId, "Missing actor ID");
+      logger().debug({
+        msg: "handling action",
+        name: opts.name,
+        encoding: this.#encoding
       });
-      if (state.targetWs) {
-        if (state.targetWs.readyState === WebSocket2.OPEN || state.targetWs.readyState === WebSocket2.CONNECTING) {
-          state.targetWs.close(
-            1e3,
-            event.reason || "Client disconnected"
-          );
-        }
-      }
-    },
-    onError: (event, clientWs) => {
-      logger3().error({ msg: "client websocket error", targetUrl, event });
-      if (state.targetWs) {
-        if (state.targetWs.readyState === WebSocket2.OPEN) {
-          state.targetWs.close(1011, "Client WebSocket error");
-        } else if (state.targetWs.readyState === WebSocket2.CONNECTING) {
-          state.targetWs.close();
+      const responseData = await sendHttpRequest({
+        url: `http://actor/action/${encodeURIComponent(opts.name)}`,
+        method: "POST",
+        headers: {
+          [HEADER_ENCODING]: this.#encoding,
+          ...this.#params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
+        },
+        body: opts.args,
+        encoding: this.#encoding,
+        customFetch: this.#driver.sendRequest.bind(
+          this.#driver,
+          actorId
+        ),
+        signal: opts == null ? void 0 : opts.signal,
+        requestVersion: CURRENT_VERSION,
+        requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
+        responseVersion: CURRENT_VERSION,
+        responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,
+        requestZodSchema: HttpActionRequestSchema,
+        responseZodSchema: HttpActionResponseSchema,
+        // JSON Request: args is the raw value
+        requestToJson: (args) => ({
+          args
+        }),
+        // BARE Request: args needs to be CBOR-encoded
+        requestToBare: (args) => ({
+          args: bufferToArrayBuffer(cbor3.encode(args))
+        }),
+        // JSON Response: output is the raw value
+        responseFromJson: (json) => json.output,
+        // BARE Response: output is ArrayBuffer that needs CBOR-decoding
+        responseFromBare: (bare) => cbor3.decode(new Uint8Array(bare.output))
+      });
+      return responseData;
+    } catch (err) {
+      const { group, code, message, metadata } = deconstructError(
+        err,
+        logger(),
+        {},
+        true
+      );
+      if (actorId && isSchedulingError(group, code)) {
+        const schedulingError = await checkForSchedulingError(
+          group,
+          code,
+          actorId,
+          this.#actorQuery,
+          this.#driver
+        );
+        if (schedulingError) {
+          throw schedulingError;
         }
       }
+      throw new ActorError(group, code, message, metadata);
     }
-  };
-}
-function closeWebSocketIfOpen(ws, code, reason) {
-  if (ws.readyState === 1) {
-    ws.close(code, reason);
-  } else if ("close" in ws && ws.readyState === WebSocket.OPEN) {
-    ws.close(code, reason);
   }
-}
-
-// src/remote-manager-driver/mod.ts
-var RemoteManagerDriver = class {
-  #config;
-  #metadataPromise;
-  constructor(runConfig) {
-    if (getNextPhase() === "phase-production-build") {
-      logger3().info(
-        "detected next.js build phase, disabling health check"
+  /**
+   * Establishes a persistent connection to the actor.
+   *
+   * @template AD The actor class that this connection is for.
+   * @returns {ActorConn<AD>} A connection to the actor.
+   */
+  connect() {
+    logger().debug({
+      msg: "establishing connection from handle",
+      query: this.#actorQuery
+    });
+    const conn = new ActorConnRaw(
+      this.#client,
+      this.#driver,
+      this.#params,
+      this.#getParams,
+      this.#encoding,
+      this.#actorQuery
+    );
+    return this.#client[CREATE_ACTOR_CONN_PROXY](
+      conn
+    );
+  }
+  /**
+   * Fetches a resource from this actor via the /request endpoint. This is a
+   * convenience wrapper around the raw HTTP API.
+   */
+  fetch(input, init) {
+    return rawHttpFetch(
+      this.#driver,
+      this.#actorQuery,
+      this.#params,
+      input,
+      init
+    );
+  }
+  /**
+   * Opens a raw WebSocket connection to this actor.
+   */
+  async webSocket(path, protocols) {
+    const params = await this.#resolveConnectionParams();
+    return rawWebSocket(
+      this.#driver,
+      this.#actorQuery,
+      params,
+      path,
+      protocols
+    );
+  }
+  /**
+   * Resolves the actor to get its unique actor ID.
+   */
+  async resolve() {
+    if ("getForKey" in this.#actorQuery) {
+      const name = this.#actorQuery.getForKey.name;
+      const { actorId } = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
       );
-      runConfig.disableMetadataLookup = true;
-    }
-    this.#config = { ...runConfig };
-    if (!runConfig.disableMetadataLookup) {
-      this.#metadataPromise = lookupMetadataCached(this.#config).then(
-        (metadataData) => {
-          if (metadataData.clientEndpoint) {
-            this.#config.endpoint = metadataData.clientEndpoint;
-            if (metadataData.clientNamespace) {
-              this.#config.namespace = metadataData.clientNamespace;
-            }
-            if (metadataData.clientToken) {
-              this.#config.token = metadataData.clientToken;
-            }
-            logger3().info({
-              msg: "overriding client endpoint",
-              endpoint: metadataData.clientEndpoint,
-              namespace: metadataData.clientNamespace,
-              token: metadataData.clientToken
-            });
-          }
-          logger3().info({
-            msg: "connected to rivetkit manager",
-            runtime: metadataData.runtime,
-            version: metadataData.version,
-            runner: metadataData.runner
-          });
-        }
+      this.#actorQuery = { getForId: { actorId, name } };
+      return actorId;
+    } else if ("getOrCreateForKey" in this.#actorQuery) {
+      const name = this.#actorQuery.getOrCreateForKey.name;
+      const { actorId } = await queryActor(
+        void 0,
+        this.#actorQuery,
+        this.#driver
       );
+      this.#actorQuery = { getForId: { actorId, name } };
+      return actorId;
+    } else if ("getForId" in this.#actorQuery) {
+      return this.#actorQuery.getForId.actorId;
+    } else if ("create" in this.#actorQuery) {
+      invariant3(false, "actorQuery cannot be create");
+    } else {
+      assertUnreachable2(this.#actorQuery);
     }
   }
-  async getForId({
-    c,
-    name,
-    actorId
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const response = await getActor(this.#config, name, actorId);
-    const actor = response.actors[0];
-    if (!actor) return void 0;
-    if (actor.name !== name) {
-      logger3().debug({
-        msg: "actor name mismatch from api",
-        actorId,
-        apiName: actor.name,
-        requestedName: name
-      });
-      return void 0;
-    }
-    return apiActorToOutput(actor);
+  /**
+   * Returns the raw URL for routing traffic to the actor.
+   */
+  async getGatewayUrl() {
+    const { actorId } = await queryActor(
+      void 0,
+      this.#actorQuery,
+      this.#driver
+    );
+    return await this.#driver.buildGatewayUrl(actorId);
   }
-  async getWithKey({
-    c,
-    name,
-    key
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "getWithKey: searching for actor", name, key });
-    try {
-      const response = await getActorByKey(this.#config, name, key);
-      const actor = response.actors[0];
-      if (!actor) return void 0;
-      logger3().debug({
-        msg: "getWithKey: found actor via api",
-        actorId: actor.actor_id,
-        name,
-        key
-      });
-      return apiActorToOutput(actor);
-    } catch (error) {
-      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
-        return void 0;
-      }
-      throw error;
-    }
+};
+
+// src/client/client.ts
+var ACTOR_CONNS_SYMBOL = /* @__PURE__ */ Symbol("actorConns");
+var CREATE_ACTOR_CONN_PROXY = /* @__PURE__ */ Symbol("createActorConnProxy");
+var ClientRaw = class {
+  #disposed = false;
+  [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
+  #driver;
+  #encodingKind;
+  /**
+   * Creates an instance of Client.
+   */
+  constructor(driver, encoding) {
+    this.#driver = driver;
+    this.#encodingKind = encoding ?? "bare";
   }
-  async getOrCreateWithKey(input) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const { c, name, key, input: actorInput, region } = input;
-    logger3().info({
-      msg: "getOrCreateWithKey: getting or creating actor via engine api",
-      name,
-      key
-    });
-    const { actor, created } = await getOrCreateActor(this.#config, {
-      datacenter: region,
-      name,
-      key: serializeActorKey(key),
-      runner_name_selector: this.#config.runnerName,
-      input: actorInput ? uint8ArrayToBase64(cbor2.encode(actorInput)) : void 0,
-      crash_policy: "sleep"
-    });
-    logger3().info({
-      msg: "getOrCreateWithKey: actor ready",
-      actorId: actor.actor_id,
+  /**
+   * Gets a stateless handle to a actor by its ID.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string} actorId - The ID of the actor.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getForId(name, actorId, opts) {
+    logger().debug({
+      msg: "get handle to actor with id",
       name,
-      key,
-      created
+      actorId,
+      params: opts == null ? void 0 : opts.params
     });
-    return apiActorToOutput(actor);
+    const actorQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(
+      opts == null ? void 0 : opts.params,
+      opts == null ? void 0 : opts.getParams,
+      actorQuery
+    );
+    return createActorProxy(handle);
   }
-  async createActor({
-    c,
-    name,
-    key,
-    input,
-    region
-  }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().info({ msg: "creating actor via engine api", name, key });
-    const result = await createActor(this.#config, {
-      datacenter: region,
-      name,
-      runner_name_selector: this.#config.runnerName,
-      key: serializeActorKey(key),
-      input: input ? uint8ArrayToBase64(cbor2.encode(input)) : void 0,
-      crash_policy: "sleep"
-    });
-    logger3().info({
-      msg: "actor created",
-      actorId: result.actor.actor_id,
+  /**
+   * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  get(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger().debug({
+      msg: "get handle to actor",
       name,
-      key
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params
     });
-    return apiActorToOutput(result.actor);
-  }
-  async listActors({ c, name }) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "listing actors via engine api", name });
-    const response = await listActorsByName(this.#config, name);
-    return response.actors.map(apiActorToOutput);
-  }
-  async destroyActor(actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().info({ msg: "destroying actor via engine api", actorId });
-    await destroyActor(this.#config, actorId);
-    logger3().info({ msg: "actor destroyed", actorId });
-  }
-  async sendRequest(actorId, actorRequest) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
+    const actorQuery = {
+      getForKey: {
+        name,
+        key: keyArray
+      }
+    };
+    const handle = this.#createHandle(
+      opts == null ? void 0 : opts.params,
+      opts == null ? void 0 : opts.getParams,
+      actorQuery
     );
+    return createActorProxy(handle);
   }
-  async openWebSocket(path, actorId, encoding, params) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await openWebSocketToActor(
-      this.#config,
-      path,
-      actorId,
-      encoding,
-      params
+  /**
+   * Gets a stateless handle to a actor by its key, creating it if necessary.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getOrCreate(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger().debug({
+      msg: "get or create handle to actor",
+      name,
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params,
+      createInRegion: opts == null ? void 0 : opts.createInRegion
+    });
+    const actorQuery = {
+      getOrCreateForKey: {
+        name,
+        key: keyArray,
+        input: opts == null ? void 0 : opts.createWithInput,
+        region: opts == null ? void 0 : opts.createInRegion
+      }
+    };
+    const handle = this.#createHandle(
+      opts == null ? void 0 : opts.params,
+      opts == null ? void 0 : opts.getParams,
+      actorQuery
     );
+    return createActorProxy(handle);
   }
-  async buildGatewayUrl(actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const endpoint = getEndpoint(this.#config);
-    return buildActorGatewayUrl(endpoint, actorId, this.#config.token);
-  }
-  async proxyRequest(_c, actorRequest, actorId) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    return await sendHttpRequestToActor(
-      this.#config,
-      actorId,
-      actorRequest
+  /**
+   * Creates a new actor with the provided key and returns a stateless handle to it.
+   * Resolves the actor ID and returns a handle with getForId query.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+   * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+   */
+  async create(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    const createQuery = {
+      create: {
+        ...opts,
+        // Do these last to override `opts`
+        name,
+        key: keyArray
+      }
+    };
+    logger().debug({
+      msg: "create actor handle",
+      name,
+      key: keyArray,
+      parameters: opts == null ? void 0 : opts.params,
+      create: createQuery.create
+    });
+    const { actorId } = await queryActor(
+      void 0,
+      createQuery,
+      this.#driver
     );
-  }
-  async proxyWebSocket(c, path, actorId, encoding, params) {
-    var _a, _b;
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
-    invariant2(upgradeWebSocket, "missing getUpgradeWebSocket");
-    const endpoint = getEndpoint(this.#config);
-    const guardUrl = combineUrlPath(endpoint, path);
-    const wsGuardUrl = guardUrl.replace("http://", "ws://");
-    logger3().debug({
-      msg: "forwarding websocket to actor via guard",
-      actorId,
-      path,
-      guardUrl
+    logger().debug({
+      msg: "created actor with ID",
+      name,
+      key: keyArray,
+      actorId
     });
-    const protocols = buildWebSocketProtocols(
-      this.#config,
-      encoding,
-      params
+    const getForIdQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(
+      opts == null ? void 0 : opts.params,
+      opts == null ? void 0 : opts.getParams,
+      getForIdQuery
     );
-    const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
-    return await upgradeWebSocket(() => args)(c, noopNext());
+    const proxy = createActorProxy(handle);
+    return proxy;
   }
-  async kvGet(actorId, key) {
-    if (this.#metadataPromise) {
-      await this.#metadataPromise;
-    }
-    logger3().debug({ msg: "getting kv value via engine api", key });
-    const response = await kvGet(
-      this.#config,
-      actorId,
-      new TextDecoder("utf8").decode(key)
+  #createHandle(params, getParams, actorQuery) {
+    return new ActorHandleRaw(
+      this,
+      this.#driver,
+      params,
+      getParams,
+      this.#encodingKind,
+      actorQuery
     );
-    return response.value;
-  }
-  displayInformation() {
-    return { properties: {} };
   }
-  setGetUpgradeWebSocket(getUpgradeWebSocket) {
-    this.#config.getUpgradeWebSocket = getUpgradeWebSocket;
+  [CREATE_ACTOR_CONN_PROXY](conn) {
+    this[ACTOR_CONNS_SYMBOL].add(conn);
+    conn[CONNECT_SYMBOL]();
+    return createActorProxy(conn);
   }
-};
-function apiActorToOutput(actor) {
-  return {
-    actorId: actor.actor_id,
-    name: actor.name,
-    key: deserializeActorKey(actor.key),
-    createTs: actor.create_ts,
-    startTs: actor.start_ts ?? null,
-    connectableTs: actor.connectable_ts ?? null,
-    sleepTs: actor.sleep_ts ?? null,
-    destroyTs: actor.destroy_ts ?? null,
-    error: actor.error ?? void 0
-  };
-}
-
-// src/client/actor-conn.ts
-import * as cbor4 from "cbor-x";
-import invariant3 from "invariant";
-import pRetry2 from "p-retry";
-
-// src/client/actor-query.ts
-async function queryActor(c, query, managerDriver) {
-  logger().debug({ msg: "querying actor", query: JSON.stringify(query) });
-  let actorOutput;
-  if ("getForId" in query) {
-    const output = await managerDriver.getForId({
-      c,
-      name: query.getForId.name,
-      actorId: query.getForId.actorId
-    });
-    if (!output) throw new ActorNotFound(query.getForId.actorId);
-    actorOutput = output;
-  } else if ("getForKey" in query) {
-    const existingActor = await managerDriver.getWithKey({
-      c,
-      name: query.getForKey.name,
-      key: query.getForKey.key
-    });
-    if (!existingActor) {
-      throw new ActorNotFound(
-        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
-      );
+  /**
+   * Disconnects from all actors.
+   *
+   * @returns {Promise<void>} A promise that resolves when all connections are closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      logger().warn({ msg: "client already disconnected" });
+      return;
     }
-    actorOutput = existingActor;
-  } else if ("getOrCreateForKey" in query) {
-    const getOrCreateOutput = await managerDriver.getOrCreateWithKey({
-      c,
-      name: query.getOrCreateForKey.name,
-      key: query.getOrCreateForKey.key,
-      input: query.getOrCreateForKey.input,
-      region: query.getOrCreateForKey.region
-    });
-    actorOutput = {
-      actorId: getOrCreateOutput.actorId
-    };
-  } else if ("create" in query) {
-    const createOutput = await managerDriver.createActor({
-      c,
-      name: query.create.name,
-      key: query.create.key,
-      input: query.create.input,
-      region: query.create.region
-    });
-    actorOutput = {
-      actorId: createOutput.actorId
-    };
-  } else {
-    throw new InvalidRequest("Invalid query format");
-  }
-  logger().debug({ msg: "actor query result", actorId: actorOutput.actorId });
-  return { actorId: actorOutput.actorId };
-}
-function getActorNameFromQuery(query) {
-  if ("getForId" in query) return query.getForId.name;
-  if ("getForKey" in query) return query.getForKey.name;
-  if ("getOrCreateForKey" in query) return query.getOrCreateForKey.name;
-  if ("create" in query) return query.create.name;
-  throw new InvalidRequest("Invalid query format");
-}
-async function checkForSchedulingError(group, code, actorId, query, driver) {
-  const name = getActorNameFromQuery(query);
-  try {
-    const actor = await driver.getForId({ name, actorId });
-    if (actor == null ? void 0 : actor.error) {
-      logger().info({
-        msg: "found actor scheduling error",
-        actorId,
-        error: actor.error
-      });
-      return new ActorSchedulingError(group, code, actorId, actor.error);
+    this.#disposed = true;
+    logger().debug({ msg: "disposing client" });
+    const disposePromises = [];
+    for (const conn of this[ACTOR_CONNS_SYMBOL].values()) {
+      disposePromises.push(conn.dispose());
     }
-  } catch (err) {
-    logger().warn({
-      msg: "failed to fetch actor details for scheduling error check",
-      actorId,
-      error: stringifyError(err)
-    });
+    await Promise.all(disposePromises);
   }
-  return null;
+};
+function createClientWithDriver(driver, config = {}) {
+  const client = new ClientRaw(driver, config.encoding);
+  return new Proxy(client, {
+    get: (target, prop, receiver) => {
+      if (typeof prop === "symbol" || prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (typeof prop === "string") {
+        return {
+          // Handle methods (stateless action)
+          get: (key, opts) => {
+            return target.get(prop, key, opts);
+          },
+          getOrCreate: (key, opts) => {
+            return target.getOrCreate(prop, key, opts);
+          },
+          getForId: (actorId, opts) => {
+            return target.getForId(prop, actorId, opts);
+          },
+          create: async (key, opts = {}) => {
+            return await target.create(prop, key, opts);
+          }
+        };
+      }
+      return void 0;
+    }
+  });
 }
-
-// src/client/queue.ts
-import * as cbor3 from "cbor-x";
-function createQueueSender(senderOptions) {
-  async function send(name, body, options) {
-    const wait = (options == null ? void 0 : options.wait) ?? false;
-    const timeout = options == null ? void 0 : options.timeout;
-    const result = await sendHttpRequest({
-      url: `http://actor/queue/${encodeURIComponent(name)}`,
-      method: "POST",
-      headers: {
-        [HEADER_ENCODING]: senderOptions.encoding,
-        ...senderOptions.params !== void 0 ? {
-          [HEADER_CONN_PARAMS]: JSON.stringify(
-            senderOptions.params
-          )
-        } : {}
-      },
-      body: { body, wait, timeout },
-      encoding: senderOptions.encoding,
-      customFetch: senderOptions.customFetch,
-      signal: options == null ? void 0 : options.signal,
-      requestVersion: CURRENT_VERSION,
-      requestVersionedDataHandler: HTTP_QUEUE_SEND_REQUEST_VERSIONED,
-      responseVersion: CURRENT_VERSION,
-      responseVersionedDataHandler: HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
-      requestZodSchema: HttpQueueSendRequestSchema,
-      responseZodSchema: HttpQueueSendResponseSchema,
-      requestToJson: (value) => ({
-        ...value,
-        name
-      }),
-      requestToBare: (value) => ({
-        name: value.name ?? name,
-        body: bufferToArrayBuffer(cbor3.encode(value.body)),
-        wait: value.wait ?? false,
-        timeout: value.timeout !== void 0 ? BigInt(value.timeout) : null
-      }),
-      responseFromJson: (json) => {
-        if (json.response === void 0) {
-          return { status: json.status };
+function createActorProxy(handle) {
+  const methodCache = /* @__PURE__ */ new Map();
+  return new Proxy(handle, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop === "constructor" || prop in target) {
+        const value = Reflect.get(target, prop, target);
+        if (typeof value === "function") {
+          return value.bind(target);
         }
-        return {
-          status: json.status,
-          response: json.response
-        };
-      },
-      responseFromBare: (bare) => {
-        if (bare.response === null || bare.response === void 0) {
-          return { status: bare.status };
+        return value;
+      }
+      if (typeof prop === "string") {
+        if (prop === "then") return void 0;
+        let method = methodCache.get(prop);
+        if (!method) {
+          method = (...args) => target.action({ name: prop, args });
+          methodCache.set(prop, method);
         }
+        return method;
+      }
+    },
+    // Support for 'in' operator
+    has(target, prop) {
+      if (typeof prop === "string") return true;
+      return Reflect.has(target, prop);
+    },
+    // Support instanceof checks
+    getPrototypeOf(target) {
+      return Reflect.getPrototypeOf(target);
+    },
+    // Prevent property enumeration of non-existent action methods
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    // Support proper property descriptors
+    getOwnPropertyDescriptor(target, prop) {
+      const targetDescriptor = Reflect.getOwnPropertyDescriptor(
+        target,
+        prop
+      );
+      if (targetDescriptor) {
+        return targetDescriptor;
+      }
+      if (typeof prop === "string") {
         return {
-          status: bare.status,
-          response: cbor3.decode(new Uint8Array(bare.response))
+          configurable: true,
+          enumerable: false,
+          writable: false,
+          value: (...args) => target.action({ name: prop, args })
         };
       }
-    });
-    if (wait) {
-      return result;
+      return void 0;
     }
-    return;
-  }
-  return {
-    send
-  };
+  });
 }
 
 // src/client/actor-conn.ts
@@ -1123,6 +1042,7 @@ var ActorConnRaw = class {
   #client;
   #driver;
   #params;
+  #getParams;
   #encoding;
   #actorQuery;
   // TODO: ws message queue
@@ -1133,10 +1053,11 @@ var ActorConnRaw = class {
    *
    * @protected
    */
-  constructor(client, driver, params, encoding, actorQuery) {
+  constructor(client, driver, params, getParams, encoding, actorQuery) {
     this.#client = client;
     this.#driver = driver;
     this.#params = params;
+    this.#getParams = getParams;
     this.#encoding = encoding;
     this.#actorQuery = actorQuery;
     this.#queueSender = createQueueSender({
@@ -1173,7 +1094,12 @@ var ActorConnRaw = class {
     logger().debug({ msg: "action", name: opts.name, args: opts.args });
     const actionId = this.#actionIdCounter;
     this.#actionIdCounter += 1;
-    const { promise, resolve, reject } = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled action promise rejection", reason }));
+    const { promise, resolve, reject } = promiseWithResolvers(
+      (reason) => logger().warn({
+        msg: "unhandled action promise rejection",
+        reason
+      })
+    );
     this.#actionsInFlight.set(actionId, {
       name: opts.name,
       resolve,
@@ -1252,7 +1178,7 @@ var ActorConnRaw = class {
   }
   #connectWithRetry() {
     this.#setConnStatus("connecting");
-    pRetry2(this.#connectAndWait.bind(this), {
+    pRetry(this.#connectAndWait.bind(this), {
       forever: true,
       minTimeout: 250,
       maxTimeout: 3e4,
@@ -1280,13 +1206,46 @@ var ActorConnRaw = class {
     try {
       if (this.#onOpenPromise)
         throw new Error("#onOpenPromise already defined");
-      this.#onOpenPromise = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled open promise rejection", reason }));
+      this.#onOpenPromise = promiseWithResolvers(
+        (reason) => logger().warn({
+          msg: "unhandled open promise rejection",
+          reason
+        })
+      );
       await this.#connectWebSocket();
       await this.#onOpenPromise.promise;
     } finally {
       this.#onOpenPromise = void 0;
     }
   }
+  #clearQueuedMessages() {
+    if (this.#messageQueue.length === 0) return;
+    logger().debug({
+      msg: "clearing queued connection messages",
+      queueLength: this.#messageQueue.length
+    });
+    this.#messageQueue = [];
+  }
+  async #resolveConnectionParams() {
+    if (!this.#getParams) {
+      return this.#params;
+    }
+    try {
+      return await this.#getParams();
+    } catch (err) {
+      const errorMessage = stringifyError(err);
+      const error = new ActorError(
+        "client",
+        "get_params_failed",
+        `Failed to resolve connection params: ${errorMessage}`,
+        { error: errorMessage }
+      );
+      this.#clearQueuedMessages();
+      this.#rejectPendingPromises(error, false);
+      this.#dispatchActorError(error);
+      throw error;
+    }
+  }
   async #connectWebSocket() {
     const { actorId } = await queryActor(
       void 0,
@@ -1294,11 +1253,12 @@ var ActorConnRaw = class {
       this.#driver
     );
     this.#actorId = actorId;
+    const params = await this.#resolveConnectionParams();
     const ws = await this.#driver.openWebSocket(
       PATH_CONNECT,
       actorId,
       this.#encoding,
-      this.#params
+      params
     );
     logger().debug({
       msg: "opened websocket",
@@ -1333,7 +1293,7 @@ var ActorConnRaw = class {
         });
       }
     });
-    ws.addEventListener("error", (_ev) => {
+    ws.addEventListener("error", () => {
       try {
         this.#handleOnError();
       } catch (err) {
@@ -1846,7 +1806,7 @@ var ActorConnRaw = class {
     }
   }
   async #parseMessage(data) {
-    invariant3(this.#websocket, "websocket must be defined");
+    invariant4(this.#websocket, "websocket must be defined");
     const buffer = await inputDataToBuffer(data);
     return deserializeWithEncoding(
       this.#encoding,
@@ -1945,7 +1905,12 @@ var ActorConnRaw = class {
     if (this.#websocket) {
       const ws = this.#websocket;
       if (ws.readyState !== 2 && ws.readyState !== 3) {
-        const { promise, resolve } = promiseWithResolvers((reason) => logger().warn({ msg: "unhandled websocket close promise rejection", reason }));
+        const { promise, resolve } = promiseWithResolvers(
+          (reason) => logger().warn({
+            msg: "unhandled websocket close promise rejection",
+            reason
+          })
+        );
         ws.addEventListener("close", () => resolve(void 0));
         ws.close(1e3, "Disposed");
         await promise;
@@ -1971,669 +1936,743 @@ var ActorConnRaw = class {
   }
 };
 
-// src/client/actor-handle.ts
+// src/client/config.ts
+import z from "zod/v4";
+var DEFAULT_ENDPOINT = "http://localhost:6420";
+var hasWarnedMissingEndpoint = false;
+var ClientConfigSchemaBase = z.object({
+  /**
+   * Endpoint to connect to for Rivet Engine or RivetKit manager API.
+   *
+   * Supports URL auth syntax for namespace and token:
+   * - `https://namespace:token@api.rivet.dev`
+   * - `https://namespace@api.rivet.dev`
+   *
+   * Can also be set via RIVET_ENDPOINT environment variables.
+   *
+   * Defaults to http://localhost:6420.
+   */
+  endpoint: z.string().optional().transform((val) => {
+    const resolved = val ?? getRivetEngine() ?? getRivetEndpoint();
+    if (!resolved && !hasWarnedMissingEndpoint) {
+      hasWarnedMissingEndpoint = true;
+      console.warn(
+        `[rivetkit] No endpoint provided to client. Defaulting to ${DEFAULT_ENDPOINT}. Starting in 2.2.0, an explicit endpoint will be required. Pass an endpoint to createClient() or createRivetKit(), or set the RIVET_ENDPOINT environment variable.`
+      );
+    }
+    return resolved ?? DEFAULT_ENDPOINT;
+  }),
+  /** Token to use to authenticate with the API. */
+  token: z.string().optional().transform((val) => val ?? getRivetToken()),
+  /** Namespace to connect to. */
+  namespace: z.string().optional().transform((val) => val ?? getRivetNamespace()),
+  /** Name of the runner. This is used to group together runners in to different pools. */
+  runnerName: z.string().default(() => getRivetRunner() ?? "default"),
+  encoding: EncodingSchema.default("bare"),
+  headers: z.record(z.string(), z.string()).optional().default(() => ({})),
+  // See RunConfig.getUpgradeWebSocket
+  //
+  // This is required in the client config in order to support
+  // `proxyWebSocket`
+  getUpgradeWebSocket: z.custom().optional(),
+  /** Whether to automatically perform health checks when the client is created. */
+  disableMetadataLookup: z.boolean().optional().default(false),
+  /** Whether to enable RivetKit Devtools integration. */
+  devtools: z.boolean().default(
+    () => {
+      var _a, _b;
+      return typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window.location) == null ? void 0 : _b.hostname) === "localhost");
+    }
+  )
+});
+var ClientConfigSchema = ClientConfigSchemaBase.transform(
+  (config, ctx) => transformClientConfig(config, ctx)
+);
+function transformClientConfig(config, ctx) {
+  const parsedEndpoint = tryParseEndpoint(ctx, {
+    endpoint: config.endpoint,
+    path: ["endpoint"],
+    namespace: config.namespace,
+    token: config.token
+  });
+  return {
+    ...config,
+    endpoint: parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint,
+    namespace: (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config.namespace ?? "default",
+    token: (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config.token
+  };
+}
+function convertRegistryConfigToClientConfig(config) {
+  var _a, _b;
+  return {
+    endpoint: config.endpoint,
+    token: config.token,
+    namespace: config.namespace,
+    runnerName: config.runner.runnerName,
+    headers: config.headers,
+    encoding: "bare",
+    getUpgradeWebSocket: void 0,
+    // We don't need health checks for internal clients
+    disableMetadataLookup: true,
+    devtools: typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window == null ? void 0 : window.location) == null ? void 0 : _b.hostname) === "localhost")
+  };
+}
+
+// src/remote-manager-driver/mod.ts
 import * as cbor5 from "cbor-x";
 import invariant5 from "invariant";
 
-// src/client/raw-utils.ts
-import invariant4 from "invariant";
-async function rawHttpFetch(driver, actorQuery, params, input, init) {
-  let path;
-  let mergedInit = init || {};
-  if (typeof input === "string") {
-    path = input;
-  } else if (input instanceof URL) {
-    path = input.pathname + input.search;
-  } else if (input instanceof Request) {
-    const url = new URL(input.url);
-    path = url.pathname + url.search;
-    const requestHeaders = new Headers(input.headers);
-    const initHeaders = new Headers((init == null ? void 0 : init.headers) || {});
-    const mergedHeaders = new Headers(requestHeaders);
-    initHeaders.forEach((value, key) => {
-      mergedHeaders.set(key, value);
-    });
-    mergedInit = {
-      method: input.method,
-      body: input.body,
-      mode: input.mode,
-      credentials: input.credentials,
-      redirect: input.redirect,
-      referrer: input.referrer,
-      referrerPolicy: input.referrerPolicy,
-      integrity: input.integrity,
-      keepalive: input.keepalive,
-      signal: input.signal,
-      ...mergedInit,
-      // init overrides Request properties
-      headers: mergedHeaders
-      // headers must be set after spread to ensure proper merge
-    };
-    if (mergedInit.body) {
-      mergedInit.duplex = "half";
-    }
-  } else {
-    throw new TypeError("Invalid input type for fetch");
+// src/remote-manager-driver/api-utils.ts
+import { z as z2 } from "zod/v4";
+
+// src/remote-manager-driver/log.ts
+function logger2() {
+  return getLogger("remote-manager-driver");
+}
+
+// src/remote-manager-driver/api-utils.ts
+var EngineApiError = class extends Error {
+  constructor(group, code, message) {
+    super(message || `Engine API error: ${group}/${code}`);
+    this.group = group;
+    this.code = code;
+    this.name = "EngineApiError";
   }
-  try {
-    const { actorId } = await queryActor(void 0, actorQuery, driver);
-    logger().debug({ msg: "found actor for raw http", actorId });
-    invariant4(actorId, "Missing actor ID");
-    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-    const url = new URL(`http://actor/request/${normalizedPath}`);
-    const proxyRequestHeaders = new Headers(mergedInit.headers);
-    if (params) {
-      proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
-    }
-    const proxyRequest = new Request(url, {
-      ...mergedInit,
-      headers: proxyRequestHeaders
-    });
-    return driver.sendRequest(actorId, proxyRequest);
-  } catch (err) {
-    const { group, code, message, metadata } = deconstructError(
-      err,
-      logger(),
-      {},
-      true
+};
+function getEndpoint(config) {
+  return config.endpoint ?? "http://127.0.0.1:6420";
+}
+async function apiCall(config, method, path, body) {
+  const endpoint = getEndpoint(config);
+  const url = combineUrlPath(endpoint, path, {
+    namespace: config.namespace
+  });
+  logger2().debug({ msg: "making api call", method, url });
+  const headers = {
+    ...config.headers
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  return await sendHttpRequest({
+    method,
+    url,
+    headers,
+    body,
+    encoding: "json",
+    skipParseResponse: false,
+    requestVersionedDataHandler: void 0,
+    requestVersion: void 0,
+    responseVersionedDataHandler: void 0,
+    responseVersion: void 0,
+    requestZodSchema: z2.any(),
+    responseZodSchema: z2.any(),
+    // Identity conversions (passthrough for generic API calls)
+    requestToJson: (value) => value,
+    requestToBare: (value) => value,
+    responseFromJson: (value) => value,
+    responseFromBare: (value) => value
+  });
+}
+
+// src/remote-manager-driver/actor-websocket-client.ts
+function buildActorGatewayUrl(endpoint, actorId, token, path = "") {
+  const tokenSegment = token !== void 0 ? `@${encodeURIComponent(token)}` : "";
+  const gatewayPath = `/gateway/${encodeURIComponent(actorId)}${tokenSegment}${path}`;
+  return combineUrlPath(endpoint, gatewayPath);
+}
+async function openWebSocketToActor(runConfig, path, actorId, encoding, params) {
+  const WebSocket2 = await importWebSocket();
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = buildActorGatewayUrl(
+    endpoint,
+    actorId,
+    runConfig.token,
+    path
+  );
+  logger2().debug({
+    msg: "opening websocket to actor via guard",
+    actorId,
+    path,
+    guardUrl
+  });
+  const ws = new WebSocket2(
+    guardUrl,
+    buildWebSocketProtocols(runConfig, encoding, params)
+  );
+  ws.binaryType = "arraybuffer";
+  logger2().debug({ msg: "websocket connection opened", actorId });
+  return ws;
+}
+function buildWebSocketProtocols(runConfig, encoding, params) {
+  const protocols = [];
+  protocols.push(WS_PROTOCOL_STANDARD);
+  protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+  if (params) {
+    protocols.push(
+      `${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`
     );
-    throw new ActorError(group, code, message, metadata);
   }
+  return protocols;
 }
-async function rawWebSocket(driver, actorQuery, params, path, protocols) {
-  const encoding = "bare";
-  const { actorId } = await queryActor(void 0, actorQuery, driver);
-  logger().debug({ msg: "found actor for action", actorId });
-  invariant4(actorId, "Missing actor ID");
-  let pathPortion = "";
-  let queryPortion = "";
-  if (path) {
-    const queryIndex = path.indexOf("?");
-    if (queryIndex !== -1) {
-      pathPortion = path.substring(0, queryIndex);
-      queryPortion = path.substring(queryIndex);
-    } else {
-      pathPortion = path;
+
+// src/remote-manager-driver/actor-http-client.ts
+async function sendHttpRequestToActor(runConfig, actorId, actorRequest) {
+  const url = new URL(actorRequest.url);
+  const endpoint = getEndpoint(runConfig);
+  const guardUrl = buildActorGatewayUrl(
+    endpoint,
+    actorId,
+    runConfig.token,
+    `${url.pathname}${url.search}`
+  );
+  let bodyToSend = null;
+  const guardHeaders = buildGuardHeadersForHttp(
+    runConfig,
+    actorRequest,
+    actorId
+  );
+  if (actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
+    if (actorRequest.bodyUsed) {
+      throw new Error("Request body has already been consumed");
     }
-    if (pathPortion.startsWith("/")) {
-      pathPortion = pathPortion.slice(1);
+    const reqBody = await actorRequest.arrayBuffer();
+    if (reqBody.byteLength !== 0) {
+      bodyToSend = reqBody;
+      guardHeaders.delete("transfer-encoding");
+      guardHeaders.set("content-length", String(bodyToSend.byteLength));
     }
   }
-  const fullPath = `${PATH_WEBSOCKET_PREFIX}${pathPortion}${queryPortion}`;
-  logger().debug({
-    msg: "opening websocket",
-    actorId,
-    encoding,
-    path: fullPath
+  const guardRequest = new Request(guardUrl, {
+    method: actorRequest.method,
+    headers: guardHeaders,
+    body: bodyToSend,
+    signal: actorRequest.signal
   });
-  const ws = await driver.openWebSocket(fullPath, actorId, encoding, params);
-  return ws;
+  return mutableResponse(await fetch(guardRequest));
 }
-
-// src/client/actor-handle.ts
-var ActorHandleRaw = class {
-  #client;
-  #driver;
-  #encoding;
-  #actorQuery;
-  #params;
-  #queueSender;
-  /**
-   * Do not call this directly.
-   *
-   * Creates an instance of ActorHandleRaw.
-   *
-   * @protected
-   */
-  constructor(client, driver, params, encoding, actorQuery) {
-    this.#client = client;
-    this.#driver = driver;
-    this.#encoding = encoding;
-    this.#actorQuery = actorQuery;
-    this.#params = params;
-    this.#queueSender = createQueueSender({
-      encoding: this.#encoding,
-      params: this.#params,
-      customFetch: async (request) => {
-        const { actorId } = await queryActor(
-          void 0,
-          this.#actorQuery,
-          this.#driver
-        );
-        return this.#driver.sendRequest(actorId, request);
-      }
-    });
+function mutableResponse(fetchRes) {
+  return new Response(fetchRes.body, fetchRes);
+}
+function buildGuardHeadersForHttp(runConfig, actorRequest, actorId) {
+  const headers = new Headers();
+  actorRequest.headers.forEach((value, key) => {
+    headers.set(key, value);
+  });
+  for (const [key, value] of Object.entries(runConfig.headers)) {
+    headers.set(key, value);
   }
-  send(name, body, options) {
-    return this.#queueSender.send(name, body, options);
+  if (runConfig.token) {
+    headers.set(HEADER_RIVET_TOKEN, runConfig.token);
   }
-  /**
-   * Call a raw action. This method sends an HTTP request to invoke the named action.
-   *
-   * @see {@link ActorHandle}
-   * @template Args - The type of arguments to pass to the action function.
-   * @template Response - The type of the response returned by the action function.
-   */
-  async action(opts) {
-    let actorId;
-    try {
-      const result = await queryActor(
-        void 0,
-        this.#actorQuery,
-        this.#driver
-      );
-      actorId = result.actorId;
-      logger().debug({ msg: "found actor for action", actorId });
-      invariant5(actorId, "Missing actor ID");
-      logger().debug({
-        msg: "handling action",
-        name: opts.name,
-        encoding: this.#encoding
+  return headers;
+}
+
+// src/remote-manager-driver/api-endpoints.ts
+async function getActor(config, _, actorId) {
+  return apiCall(
+    config,
+    "GET",
+    `/actors?actor_ids=${encodeURIComponent(actorId)}`
+  );
+}
+async function getActorByKey(config, name, key) {
+  const serializedKey = serializeActorKey(key);
+  return apiCall(
+    config,
+    "GET",
+    `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
+  );
+}
+async function listActorsByName(config, name) {
+  return apiCall(
+    config,
+    "GET",
+    `/actors?name=${encodeURIComponent(name)}`
+  );
+}
+async function getOrCreateActor(config, request) {
+  return apiCall(
+    config,
+    "PUT",
+    `/actors`,
+    request
+  );
+}
+async function createActor(config, request) {
+  return apiCall(
+    config,
+    "POST",
+    `/actors`,
+    request
+  );
+}
+async function destroyActor(config, actorId) {
+  return apiCall(
+    config,
+    "DELETE",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+async function getMetadata(config) {
+  return apiCall(config, "GET", `/metadata`);
+}
+async function getDatacenters(config) {
+  return apiCall(config, "GET", `/datacenters`);
+}
+async function updateRunnerConfig(config, runnerName, request) {
+  return apiCall(
+    config,
+    "PUT",
+    `/runner-configs/${runnerName}`,
+    request
+  );
+}
+async function kvGet(config, actorId, key) {
+  return apiCall(
+    config,
+    "GET",
+    `/actors/${encodeURIComponent(actorId)}/kv/keys/${encodeURIComponent(key)}`
+  );
+}
+
+// src/remote-manager-driver/metadata.ts
+import pRetry2 from "p-retry";
+var metadataLookupCache = /* @__PURE__ */ new Map();
+async function lookupMetadataCached(config) {
+  const endpoint = getEndpoint(config);
+  const existingPromise = metadataLookupCache.get(endpoint);
+  if (existingPromise) {
+    return existingPromise;
+  }
+  const metadataLookupPromise = pRetry2(
+    async () => {
+      logger2().debug({
+        msg: "fetching metadata",
+        endpoint
+      });
+      const metadataData = await getMetadata(config);
+      logger2().debug({
+        msg: "received metadata",
+        endpoint,
+        clientEndpoint: metadataData.clientEndpoint
+      });
+      return metadataData;
+    },
+    {
+      forever: true,
+      minTimeout: 500,
+      maxTimeout: 15e3,
+      onFailedAttempt: (error) => {
+        if (error.attemptNumber > 1) {
+          logger2().warn({
+            msg: "failed to fetch metadata, retrying",
+            endpoint,
+            attempt: error.attemptNumber,
+            error: stringifyError(error)
+          });
+        }
+      }
+    }
+  );
+  metadataLookupCache.set(endpoint, metadataLookupPromise);
+  return metadataLookupPromise;
+}
+
+// src/remote-manager-driver/ws-proxy.ts
+async function createWebSocketProxy(c, targetUrl, protocols) {
+  const WebSocket2 = await importWebSocket();
+  const state = {};
+  return {
+    onOpen: async (event, clientWs) => {
+      logger2().debug({ msg: "client websocket connected", targetUrl });
+      if (clientWs.readyState !== 1) {
+        logger2().warn({
+          msg: "client websocket not open on connection",
+          targetUrl,
+          readyState: clientWs.readyState
+        });
+        return;
+      }
+      const targetWs = new WebSocket2(targetUrl, protocols);
+      state.targetWs = targetWs;
+      state.connectPromise = new Promise((resolve, reject) => {
+        targetWs.addEventListener("open", () => {
+          logger2().debug({
+            msg: "target websocket connected",
+            targetUrl
+          });
+          if (clientWs.readyState !== 1) {
+            logger2().warn({
+              msg: "client websocket closed before target connected",
+              targetUrl,
+              clientReadyState: clientWs.readyState
+            });
+            targetWs.close(1001, "Client disconnected");
+            reject(new Error("Client disconnected"));
+            return;
+          }
+          resolve();
+        });
+        targetWs.addEventListener("error", (error) => {
+          logger2().warn({
+            msg: "target websocket error during connection",
+            targetUrl
+          });
+          reject(error);
+        });
       });
-      const responseData = await sendHttpRequest({
-        url: `http://actor/action/${encodeURIComponent(opts.name)}`,
-        method: "POST",
-        headers: {
-          [HEADER_ENCODING]: this.#encoding,
-          ...this.#params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) } : {}
-        },
-        body: opts.args,
-        encoding: this.#encoding,
-        customFetch: this.#driver.sendRequest.bind(
-          this.#driver,
-          actorId
-        ),
-        signal: opts == null ? void 0 : opts.signal,
-        requestVersion: CURRENT_VERSION,
-        requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
-        responseVersion: CURRENT_VERSION,
-        responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,
-        requestZodSchema: HttpActionRequestSchema,
-        responseZodSchema: HttpActionResponseSchema,
-        // JSON Request: args is the raw value
-        requestToJson: (args) => ({
-          args
-        }),
-        // BARE Request: args needs to be CBOR-encoded
-        requestToBare: (args) => ({
-          args: bufferToArrayBuffer(cbor5.encode(args))
-        }),
-        // JSON Response: output is the raw value
-        responseFromJson: (json) => json.output,
-        // BARE Response: output is ArrayBuffer that needs CBOR-decoding
-        responseFromBare: (bare) => cbor5.decode(new Uint8Array(bare.output))
+      state.targetWs.addEventListener("message", (event2) => {
+        if (typeof event2.data === "string" || event2.data instanceof ArrayBuffer) {
+          clientWs.send(event2.data);
+        } else if (event2.data instanceof Blob) {
+          event2.data.arrayBuffer().then((buffer) => {
+            clientWs.send(buffer);
+          });
+        }
       });
-      return responseData;
-    } catch (err) {
-      const { group, code, message, metadata } = deconstructError(
-        err,
-        logger(),
-        {},
-        true
-      );
-      if (actorId && isSchedulingError(group, code)) {
-        const schedulingError = await checkForSchedulingError(
-          group,
-          code,
-          actorId,
-          this.#actorQuery,
-          this.#driver
+      state.targetWs.addEventListener("close", (event2) => {
+        logger2().debug({
+          msg: "target websocket closed",
+          targetUrl,
+          code: event2.code,
+          reason: event2.reason
+        });
+        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
+      });
+      state.targetWs.addEventListener("error", (error) => {
+        logger2().error({
+          msg: "target websocket error",
+          targetUrl,
+          error: stringifyError(error)
+        });
+        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
+      });
+    },
+    onMessage: async (event, clientWs) => {
+      if (!state.targetWs || !state.connectPromise) {
+        logger2().error({
+          msg: "websocket state not initialized",
+          targetUrl
+        });
+        return;
+      }
+      try {
+        await state.connectPromise;
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.send(event.data);
+        } else {
+          logger2().warn({
+            msg: "target websocket not open",
+            targetUrl,
+            readyState: state.targetWs.readyState
+          });
+        }
+      } catch (error) {
+        logger2().error({
+          msg: "failed to connect to target websocket",
+          targetUrl,
+          error
+        });
+        closeWebSocketIfOpen(
+          clientWs,
+          1011,
+          "Failed to connect to target"
         );
-        if (schedulingError) {
-          throw schedulingError;
+      }
+    },
+    onClose: (event, clientWs) => {
+      logger2().debug({
+        msg: "client websocket closed",
+        targetUrl,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN || state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close(
+            1e3,
+            event.reason || "Client disconnected"
+          );
+        }
+      }
+    },
+    onError: (event, clientWs) => {
+      logger2().error({ msg: "client websocket error", targetUrl, event });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.close(1011, "Client WebSocket error");
+        } else if (state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close();
         }
       }
-      throw new ActorError(group, code, message, metadata);
     }
+  };
+}
+function closeWebSocketIfOpen(ws, code, reason) {
+  if (ws.readyState === 1) {
+    ws.close(code, reason);
+  } else if ("close" in ws && ws.readyState === WebSocket.OPEN) {
+    ws.close(code, reason);
   }
-  /**
-   * Establishes a persistent connection to the actor.
-   *
-   * @template AD The actor class that this connection is for.
-   * @returns {ActorConn<AD>} A connection to the actor.
-   */
-  connect() {
-    logger().debug({
-      msg: "establishing connection from handle",
-      query: this.#actorQuery
-    });
-    const conn = new ActorConnRaw(
-      this.#client,
-      this.#driver,
-      this.#params,
-      this.#encoding,
-      this.#actorQuery
-    );
-    return this.#client[CREATE_ACTOR_CONN_PROXY](
-      conn
-    );
-  }
-  /**
-   * Fetches a resource from this actor via the /request endpoint. This is a
-   * convenience wrapper around the raw HTTP API.
-   */
-  fetch(input, init) {
-    return rawHttpFetch(
-      this.#driver,
-      this.#actorQuery,
-      this.#params,
-      input,
-      init
-    );
-  }
-  /**
-   * Opens a raw WebSocket connection to this actor.
-   */
-  webSocket(path, protocols) {
-    return rawWebSocket(
-      this.#driver,
-      this.#actorQuery,
-      this.#params,
-      path,
-      protocols
-    );
-  }
-  /**
-   * Resolves the actor to get its unique actor ID.
-   */
-  async resolve() {
-    if ("getForKey" in this.#actorQuery) {
-      const name = this.#actorQuery.getForKey.name;
-      const { actorId } = await queryActor(
-        void 0,
-        this.#actorQuery,
-        this.#driver
+}
+
+// src/remote-manager-driver/mod.ts
+var RemoteManagerDriver = class {
+  #config;
+  #metadataPromise;
+  constructor(runConfig) {
+    if (getNextPhase() === "phase-production-build") {
+      logger2().info(
+        "detected next.js build phase, disabling health check"
       );
-      this.#actorQuery = { getForId: { actorId, name } };
-      return actorId;
-    } else if ("getOrCreateForKey" in this.#actorQuery) {
-      const name = this.#actorQuery.getOrCreateForKey.name;
-      const { actorId } = await queryActor(
-        void 0,
-        this.#actorQuery,
-        this.#driver
+      runConfig.disableMetadataLookup = true;
+    }
+    this.#config = { ...runConfig };
+    if (!runConfig.disableMetadataLookup) {
+      this.#metadataPromise = lookupMetadataCached(this.#config).then(
+        (metadataData) => {
+          if (metadataData.clientEndpoint) {
+            this.#config.endpoint = metadataData.clientEndpoint;
+            if (metadataData.clientNamespace) {
+              this.#config.namespace = metadataData.clientNamespace;
+            }
+            if (metadataData.clientToken) {
+              this.#config.token = metadataData.clientToken;
+            }
+            logger2().info({
+              msg: "overriding client endpoint",
+              endpoint: metadataData.clientEndpoint,
+              namespace: metadataData.clientNamespace,
+              token: metadataData.clientToken
+            });
+          }
+          logger2().info({
+            msg: "connected to rivetkit manager",
+            runtime: metadataData.runtime,
+            version: metadataData.version,
+            runner: metadataData.runner
+          });
+        }
       );
-      this.#actorQuery = { getForId: { actorId, name } };
-      return actorId;
-    } else if ("getForId" in this.#actorQuery) {
-      return this.#actorQuery.getForId.actorId;
-    } else if ("create" in this.#actorQuery) {
-      invariant5(false, "actorQuery cannot be create");
-    } else {
-      assertUnreachable2(this.#actorQuery);
     }
   }
-  /**
-   * Returns the raw URL for routing traffic to the actor.
-   */
-  async getGatewayUrl() {
-    const { actorId } = await queryActor(
-      void 0,
-      this.#actorQuery,
-      this.#driver
-    );
-    return await this.#driver.buildGatewayUrl(actorId);
-  }
-};
-
-// src/client/client.ts
-var ACTOR_CONNS_SYMBOL = /* @__PURE__ */ Symbol("actorConns");
-var CREATE_ACTOR_CONN_PROXY = /* @__PURE__ */ Symbol("createActorConnProxy");
-var ClientRaw = class {
-  #disposed = false;
-  [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
-  #driver;
-  #encodingKind;
-  /**
-   * Creates an instance of Client.
-   */
-  constructor(driver, encoding) {
-    this.#driver = driver;
-    this.#encodingKind = encoding ?? "bare";
+  async getForId({
+    c,
+    name,
+    actorId
+  }) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    const response = await getActor(this.#config, name, actorId);
+    const actor = response.actors[0];
+    if (!actor) return void 0;
+    if (actor.name !== name) {
+      logger2().debug({
+        msg: "actor name mismatch from api",
+        actorId,
+        apiName: actor.name,
+        requestedName: name
+      });
+      return void 0;
+    }
+    return apiActorToOutput(actor);
   }
-  /**
-   * Gets a stateless handle to a actor by its ID.
-   *
-   * @template AD The actor class that this handle is for.
-   * @param {string} name - The name of the actor.
-   * @param {string} actorId - The ID of the actor.
-   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-   * @returns {ActorHandle<AD>} - A handle to the actor.
-   */
-  getForId(name, actorId, opts) {
-    logger().debug({
-      msg: "get handle to actor with id",
-      name,
-      actorId,
-      params: opts == null ? void 0 : opts.params
-    });
-    const actorQuery = {
-      getForId: {
+  async getWithKey({
+    c,
+    name,
+    key
+  }) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    logger2().debug({ msg: "getWithKey: searching for actor", name, key });
+    try {
+      const response = await getActorByKey(this.#config, name, key);
+      const actor = response.actors[0];
+      if (!actor) return void 0;
+      logger2().debug({
+        msg: "getWithKey: found actor via api",
+        actorId: actor.actor_id,
         name,
-        actorId
+        key
+      });
+      return apiActorToOutput(actor);
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
       }
-    };
-    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
-    return createActorProxy(handle);
+      throw error;
+    }
   }
-  /**
-   * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
-   *
-   * @template AD The actor class that this handle is for.
-   * @param {string} name - The name of the actor.
-   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
-   * @returns {ActorHandle<AD>} - A handle to the actor.
-   */
-  get(name, key, opts) {
-    const keyArray = typeof key === "string" ? [key] : key || [];
-    logger().debug({
-      msg: "get handle to actor",
+  async getOrCreateWithKey(input) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    const { c, name, key, input: actorInput, region } = input;
+    logger2().info({
+      msg: "getOrCreateWithKey: getting or creating actor via engine api",
       name,
-      key: keyArray,
-      parameters: opts == null ? void 0 : opts.params
+      key
     });
-    const actorQuery = {
-      getForKey: {
-        name,
-        key: keyArray
-      }
-    };
-    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
-    return createActorProxy(handle);
-  }
-  /**
-   * Gets a stateless handle to a actor by its key, creating it if necessary.
-   *
-   * @template AD The actor class that this handle is for.
-   * @param {string} name - The name of the actor.
-   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
-   * @param {GetOptions} [opts] - Options for getting the actor.
-   * @returns {ActorHandle<AD>} - A handle to the actor.
-   */
-  getOrCreate(name, key, opts) {
-    const keyArray = typeof key === "string" ? [key] : key || [];
-    logger().debug({
-      msg: "get or create handle to actor",
+    const { actor, created } = await getOrCreateActor(this.#config, {
+      datacenter: region,
       name,
-      key: keyArray,
-      parameters: opts == null ? void 0 : opts.params,
-      createInRegion: opts == null ? void 0 : opts.createInRegion
+      key: serializeActorKey(key),
+      runner_name_selector: this.#config.runnerName,
+      input: actorInput ? uint8ArrayToBase64(cbor5.encode(actorInput)) : void 0,
+      crash_policy: "sleep"
     });
-    const actorQuery = {
-      getOrCreateForKey: {
-        name,
-        key: keyArray,
-        input: opts == null ? void 0 : opts.createWithInput,
-        region: opts == null ? void 0 : opts.createInRegion
-      }
-    };
-    const handle = this.#createHandle(opts == null ? void 0 : opts.params, actorQuery);
-    return createActorProxy(handle);
+    logger2().info({
+      msg: "getOrCreateWithKey: actor ready",
+      actorId: actor.actor_id,
+      name,
+      key,
+      created
+    });
+    return apiActorToOutput(actor);
   }
-  /**
-   * Creates a new actor with the provided key and returns a stateless handle to it.
-   * Resolves the actor ID and returns a handle with getForId query.
-   *
-   * @template AD The actor class that this handle is for.
-   * @param {string} name - The name of the actor.
-   * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
-   * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
-   * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
-   */
-  async create(name, key, opts) {
-    const keyArray = typeof key === "string" ? [key] : key || [];
-    const createQuery = {
-      create: {
-        ...opts,
-        // Do these last to override `opts`
-        name,
-        key: keyArray
-      }
-    };
-    logger().debug({
-      msg: "create actor handle",
+  async createActor({
+    c,
+    name,
+    key,
+    input,
+    region
+  }) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    logger2().info({ msg: "creating actor via engine api", name, key });
+    const result = await createActor(this.#config, {
+      datacenter: region,
       name,
-      key: keyArray,
-      parameters: opts == null ? void 0 : opts.params,
-      create: createQuery.create
+      runner_name_selector: this.#config.runnerName,
+      key: serializeActorKey(key),
+      input: input ? uint8ArrayToBase64(cbor5.encode(input)) : void 0,
+      crash_policy: "sleep"
     });
-    const { actorId } = await queryActor(
-      void 0,
-      createQuery,
-      this.#driver
-    );
-    logger().debug({
-      msg: "created actor with ID",
+    logger2().info({
+      msg: "actor created",
+      actorId: result.actor.actor_id,
       name,
-      key: keyArray,
-      actorId
+      key
     });
-    const getForIdQuery = {
-      getForId: {
-        name,
-        actorId
-      }
-    };
-    const handle = this.#createHandle(opts == null ? void 0 : opts.params, getForIdQuery);
-    const proxy = createActorProxy(handle);
-    return proxy;
+    return apiActorToOutput(result.actor);
+  }
+  async listActors({ c, name }) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    logger2().debug({ msg: "listing actors via engine api", name });
+    const response = await listActorsByName(this.#config, name);
+    return response.actors.map(apiActorToOutput);
+  }
+  async destroyActor(actorId) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    logger2().info({ msg: "destroying actor via engine api", actorId });
+    await destroyActor(this.#config, actorId);
+    logger2().info({ msg: "actor destroyed", actorId });
   }
-  #createHandle(params, actorQuery) {
-    return new ActorHandleRaw(
-      this,
-      this.#driver,
-      params,
-      this.#encodingKind,
-      actorQuery
+  async sendRequest(actorId, actorRequest) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
+    }
+    return await sendHttpRequestToActor(
+      this.#config,
+      actorId,
+      actorRequest
     );
   }
-  [CREATE_ACTOR_CONN_PROXY](conn) {
-    this[ACTOR_CONNS_SYMBOL].add(conn);
-    conn[CONNECT_SYMBOL]();
-    return createActorProxy(conn);
-  }
-  /**
-   * Disconnects from all actors.
-   *
-   * @returns {Promise<void>} A promise that resolves when all connections are closed.
-   */
-  async dispose() {
-    if (this.#disposed) {
-      logger().warn({ msg: "client already disconnected" });
-      return;
+  async openWebSocket(path, actorId, encoding, params) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
     }
-    this.#disposed = true;
-    logger().debug({ msg: "disposing client" });
-    const disposePromises = [];
-    for (const conn of this[ACTOR_CONNS_SYMBOL].values()) {
-      disposePromises.push(conn.dispose());
+    return await openWebSocketToActor(
+      this.#config,
+      path,
+      actorId,
+      encoding,
+      params
+    );
+  }
+  async buildGatewayUrl(actorId) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
     }
-    await Promise.all(disposePromises);
+    const endpoint = getEndpoint(this.#config);
+    return buildActorGatewayUrl(endpoint, actorId, this.#config.token);
   }
-};
-function createClientWithDriver(driver, config = {}) {
-  const client = new ClientRaw(driver, config.encoding);
-  return new Proxy(client, {
-    get: (target, prop, receiver) => {
-      if (typeof prop === "symbol" || prop in target) {
-        const value = Reflect.get(target, prop, receiver);
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-      if (typeof prop === "string") {
-        return {
-          // Handle methods (stateless action)
-          get: (key, opts) => {
-            return target.get(prop, key, opts);
-          },
-          getOrCreate: (key, opts) => {
-            return target.getOrCreate(prop, key, opts);
-          },
-          getForId: (actorId, opts) => {
-            return target.getForId(prop, actorId, opts);
-          },
-          create: async (key, opts = {}) => {
-            return await target.create(prop, key, opts);
-          }
-        };
-      }
-      return void 0;
+  async proxyRequest(_c, actorRequest, actorId) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
     }
-  });
-}
-function createActorProxy(handle) {
-  const methodCache = /* @__PURE__ */ new Map();
-  return new Proxy(handle, {
-    get(target, prop, receiver) {
-      if (typeof prop === "symbol") {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop === "constructor" || prop in target) {
-        const value = Reflect.get(target, prop, target);
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-      if (typeof prop === "string") {
-        if (prop === "then") return void 0;
-        let method = methodCache.get(prop);
-        if (!method) {
-          method = (...args) => target.action({ name: prop, args });
-          methodCache.set(prop, method);
-        }
-        return method;
-      }
-    },
-    // Support for 'in' operator
-    has(target, prop) {
-      if (typeof prop === "string") return true;
-      return Reflect.has(target, prop);
-    },
-    // Support instanceof checks
-    getPrototypeOf(target) {
-      return Reflect.getPrototypeOf(target);
-    },
-    // Prevent property enumeration of non-existent action methods
-    ownKeys(target) {
-      return Reflect.ownKeys(target);
-    },
-    // Support proper property descriptors
-    getOwnPropertyDescriptor(target, prop) {
-      const targetDescriptor = Reflect.getOwnPropertyDescriptor(
-        target,
-        prop
-      );
-      if (targetDescriptor) {
-        return targetDescriptor;
-      }
-      if (typeof prop === "string") {
-        return {
-          configurable: true,
-          enumerable: false,
-          writable: false,
-          value: (...args) => target.action({ name: prop, args })
-        };
-      }
-      return void 0;
+    return await sendHttpRequestToActor(
+      this.#config,
+      actorId,
+      actorRequest
+    );
+  }
+  async proxyWebSocket(c, path, actorId, encoding, params) {
+    var _a, _b;
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
     }
-  });
-}
-
-// src/client/config.ts
-import z2 from "zod/v4";
-function getDefaultEndpoint() {
-  var _a;
-  if (typeof window !== "undefined" && ((_a = window.location) == null ? void 0 : _a.origin)) {
-    return `${window.location.origin}/api/rivet`;
+    const upgradeWebSocket = (_b = (_a = this.#config).getUpgradeWebSocket) == null ? void 0 : _b.call(_a);
+    invariant5(upgradeWebSocket, "missing getUpgradeWebSocket");
+    const endpoint = getEndpoint(this.#config);
+    const guardUrl = combineUrlPath(endpoint, path);
+    const wsGuardUrl = guardUrl.replace("http://", "ws://");
+    logger2().debug({
+      msg: "forwarding websocket to actor via guard",
+      actorId,
+      path,
+      guardUrl
+    });
+    const protocols = buildWebSocketProtocols(
+      this.#config,
+      encoding,
+      params
+    );
+    const args = await createWebSocketProxy(c, wsGuardUrl, protocols);
+    return await upgradeWebSocket(() => args)(c, noopNext());
   }
-  return "http://127.0.0.1:6420";
-}
-var ClientConfigSchemaBase = z2.object({
-  /**
-   * Endpoint to connect to for Rivet Engine or RivetKit manager API.
-   *
-   * Supports URL auth syntax for namespace and token:
-   * - `https://namespace:token@api.rivet.dev`
-   * - `https://namespace@api.rivet.dev`
-   *
-   * Can also be set via RIVET_ENDPOINT environment variables.
-   *
-   * Defaults to current origin + /api/rivet in browser, or 127.0.0.1:6420 server-side.
-   */
-  endpoint: z2.string().optional().transform(
-    (val) => val ?? getRivetEngine() ?? getRivetEndpoint() ?? getDefaultEndpoint()
-  ),
-  /** Token to use to authenticate with the API. */
-  token: z2.string().optional().transform((val) => val ?? getRivetToken()),
-  /** Namespace to connect to. */
-  namespace: z2.string().optional().transform((val) => val ?? getRivetNamespace()),
-  /** Name of the runner. This is used to group together runners in to different pools. */
-  runnerName: z2.string().default(() => getRivetRunner() ?? "default"),
-  encoding: EncodingSchema.default("bare"),
-  headers: z2.record(z2.string(), z2.string()).optional().default(() => ({})),
-  // See RunConfig.getUpgradeWebSocket
-  //
-  // This is required in the client config in order to support
-  // `proxyWebSocket`
-  getUpgradeWebSocket: z2.custom().optional(),
-  /** Whether to automatically perform health checks when the client is created. */
-  disableMetadataLookup: z2.boolean().optional().default(false),
-  /** Whether to enable RivetKit Devtools integration. */
-  devtools: z2.boolean().default(
-    () => {
-      var _a, _b;
-      return typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window.location) == null ? void 0 : _b.hostname) === "localhost");
+  async kvGet(actorId, key) {
+    if (this.#metadataPromise) {
+      await this.#metadataPromise;
     }
-  )
-});
-var ClientConfigSchema = ClientConfigSchemaBase.transform(
-  (config, ctx) => transformClientConfig(config, ctx)
-);
-function transformClientConfig(config, ctx) {
-  const parsedEndpoint = tryParseEndpoint(ctx, {
-    endpoint: config.endpoint,
-    path: ["endpoint"],
-    namespace: config.namespace,
-    token: config.token
-  });
-  return {
-    ...config,
-    endpoint: parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint,
-    namespace: (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config.namespace ?? "default",
-    token: (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config.token
-  };
-}
-function convertRegistryConfigToClientConfig(config) {
-  var _a, _b;
+    logger2().debug({ msg: "getting kv value via engine api", key });
+    const response = await kvGet(
+      this.#config,
+      actorId,
+      new TextDecoder("utf8").decode(key)
+    );
+    return response.value;
+  }
+  displayInformation() {
+    return { properties: {} };
+  }
+  setGetUpgradeWebSocket(getUpgradeWebSocket) {
+    this.#config.getUpgradeWebSocket = getUpgradeWebSocket;
+  }
+};
+function apiActorToOutput(actor) {
   return {
-    endpoint: config.endpoint,
-    token: config.token,
-    namespace: config.namespace,
-    runnerName: config.runner.runnerName,
-    headers: config.headers,
-    encoding: "bare",
-    getUpgradeWebSocket: void 0,
-    // We don't need health checks for internal clients
-    disableMetadataLookup: true,
-    devtools: typeof window !== "undefined" && (((_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname) === "127.0.0.1" || ((_b = window == null ? void 0 : window.location) == null ? void 0 : _b.hostname) === "localhost")
+    actorId: actor.actor_id,
+    name: actor.name,
+    key: deserializeActorKey(actor.key),
+    createTs: actor.create_ts,
+    startTs: actor.start_ts ?? null,
+    connectableTs: actor.connectable_ts ?? null,
+    sleepTs: actor.sleep_ts ?? null,
+    destroyTs: actor.destroy_ts ?? null,
+    error: actor.error ?? void 0
   };
 }
 
-// src/client/mod.ts
-function createClient(endpointOrConfig) {
-  const configInput = endpointOrConfig === void 0 ? {} : typeof endpointOrConfig === "string" ? { endpoint: endpointOrConfig } : endpointOrConfig;
-  const config = ClientConfigSchema.parse(configInput);
-  const driver = new RemoteManagerDriver(config);
-  if (config.devtools) {
-    injectDevtools(config);
-  }
-  return createClientWithDriver(driver, config);
-}
-
 export {
   ActorClientError,
   InternalError,
@@ -2644,14 +2683,11 @@ export {
   ActorConnRaw,
   ActorHandleRaw,
   createClientWithDriver,
-  ClientConfigSchemaBase,
   ClientConfigSchema,
-  transformClientConfig,
   convertRegistryConfigToClientConfig,
   getEndpoint,
   getDatacenters,
   updateRunnerConfig,
-  RemoteManagerDriver,
-  createClient
+  RemoteManagerDriver
 };
-//# sourceMappingURL=chunk-JPXO2H55.js.map
+//# sourceMappingURL=chunk-WW27B6DM.js.map