@rivetkit/core/dist/chunk-MDIBCJIZ.js

import {
  importWebSocket
} from "./chunk-P5IOL2NY.js";
import {
  ActorError,
  InternalError,
  createClientWithDriver,
  importEventSource,
  sendHttpRequest,
  serializeWithEncoding
} from "./chunk-KFDEBHI5.js";
import {
  HEADER_ACTOR_ID,
  HEADER_ACTOR_QUERY,
  HEADER_CONN_ID,
  HEADER_CONN_PARAMS,
  HEADER_CONN_TOKEN,
  HEADER_ENCODING
} from "./chunk-IVHL2KCJ.js";
import {
  logger
} from "./chunk-EKNB2QDI.js";
import {
  assertUnreachable,
  httpUserAgent
} from "./chunk-WDSX6QCH.js";

// src/client/http-client-driver.ts
function createHttpClientDriver(managerEndpoint) {
  const dynamicImports = (async () => {
    const [WebSocket, EventSource] = await Promise.all([
      importWebSocket(),
      importEventSource()
    ]);
    return {
      WebSocket,
      EventSource
    };
  })();
  const driver = {
    action: async (_c, actorQuery, encoding, params, name, args, opts) => {
      logger().debug("actor handle action", {
        name,
        args,
        query: actorQuery
      });
      const responseData = await sendHttpRequest(
        {
          url: `${managerEndpoint}/registry/actors/actions/${encodeURIComponent(name)}`,
          method: "POST",
          headers: {
            [HEADER_ENCODING]: encoding,
            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
            ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {}
          },
          body: { a: args },
          encoding,
          signal: opts == null ? void 0 : opts.signal
        }
      );
      return responseData.o;
    },
    resolveActorId: async (_c, actorQuery, encodingKind, params) => {
      logger().debug("resolving actor ID", { query: actorQuery });
      try {
        const result = await sendHttpRequest({
          url: `${managerEndpoint}/registry/actors/resolve`,
          method: "POST",
          headers: {
            [HEADER_ENCODING]: encodingKind,
            [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
            ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {}
          },
          body: {},
          encoding: encodingKind
        });
        logger().debug("resolved actor ID", { actorId: result.i });
        return result.i;
      } catch (error) {
        logger().error("failed to resolve actor ID", { error });
        if (error instanceof ActorError) {
          throw error;
        } else {
          throw new InternalError(
            `Failed to resolve actor ID: ${String(error)}`
          );
        }
      }
    },
    connectWebSocket: async (_c, actorQuery, encodingKind, params) => {
      const { WebSocket } = await dynamicImports;
      const endpoint = managerEndpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
      const url = `${endpoint}/registry/actors/connect/websocket`;
      const protocol = [
        `query.${encodeURIComponent(JSON.stringify(actorQuery))}`,
        `encoding.${encodingKind}`
      ];
      if (params)
        protocol.push(
          `conn_params.${encodeURIComponent(JSON.stringify(params))}`
        );
      protocol.push("rivetkit");
      logger().debug("connecting to websocket", { url });
      const ws = new WebSocket(url, protocol);
      if (encodingKind === "cbor") {
        ws.binaryType = "arraybuffer";
      } else if (encodingKind === "json") {
        try {
          ws.binaryType = "blob";
        } catch (error) {
        }
      } else {
        assertUnreachable(encodingKind);
      }
      return ws;
    },
    connectSse: async (_c, actorQuery, encodingKind, params) => {
      const { EventSource } = await dynamicImports;
      const url = `${managerEndpoint}/registry/actors/connect/sse`;
      logger().debug("connecting to sse", { url });
      const eventSource = new EventSource(url, {
        fetch: (input, init) => {
          return fetch(input, {
            ...init,
            headers: {
              ...init == null ? void 0 : init.headers,
              "User-Agent": httpUserAgent(),
              [HEADER_ENCODING]: encodingKind,
              [HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
              ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {}
            },
            credentials: "include"
          });
        }
      });
      return eventSource;
    },
    sendHttpMessage: async (_c, actorId, encoding, connectionId, connectionToken, message) => {
      const messageSerialized = serializeWithEncoding(encoding, message);
      const res = await fetch(`${managerEndpoint}/registry/actors/message`, {
        method: "POST",
        headers: {
          "User-Agent": httpUserAgent(),
          [HEADER_ENCODING]: encoding,
          [HEADER_ACTOR_ID]: actorId,
          [HEADER_CONN_ID]: connectionId,
          [HEADER_CONN_TOKEN]: connectionToken
        },
        body: messageSerialized,
        credentials: "include"
      });
      return res;
    },
    rawHttpRequest: async (_c, actorQuery, encoding, params, path, init) => {
      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
      const url = `${managerEndpoint}/registry/actors/raw/http/${normalizedPath}`;
      logger().debug("rewriting http url", {
        from: path,
        to: url
      });
      const headers = new Headers(init.headers);
      headers.set("User-Agent", httpUserAgent());
      headers.set(HEADER_ACTOR_QUERY, JSON.stringify(actorQuery));
      headers.set(HEADER_ENCODING, encoding);
      if (params !== void 0) {
        headers.set(HEADER_CONN_PARAMS, JSON.stringify(params));
      }
      return await fetch(url, {
        ...init,
        headers
      });
    },
    rawWebSocket: async (_c, actorQuery, encoding, params, path, protocols) => {
      const { WebSocket } = await dynamicImports;
      const wsEndpoint = managerEndpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
      const url = `${wsEndpoint}/registry/actors/raw/websocket/${normalizedPath}`;
      logger().debug("rewriting websocket url", {
        from: path,
        to: url
      });
      const protocolList = [];
      protocolList.push(
        `query.${encodeURIComponent(JSON.stringify(actorQuery))}`
      );
      protocolList.push(`encoding.${encoding}`);
      if (params) {
        protocolList.push(
          `conn_params.${encodeURIComponent(JSON.stringify(params))}`
        );
      }
      protocolList.push("rivetkit");
      if (protocols) {
        if (Array.isArray(protocols)) {
          protocolList.push(...protocols);
        } else {
          protocolList.push(protocols);
        }
      }
      logger().debug("opening raw websocket", { url });
      return new WebSocket(url, protocolList);
    }
  };
  return driver;
}

// src/client/mod.ts
function createClient(endpoint, opts) {
  const driver = createHttpClientDriver(endpoint);
  return createClientWithDriver(driver, opts);
}

export {
  createClient
};
//# sourceMappingURL=chunk-MDIBCJIZ.js.map