@rivetkit/core/dist/chunk-ZCUB7MR5.cjs

"use strict";Object.defineProperty(exports, "__esModule", {value: true});

var _chunkQAYICQKZcjs = require('./chunk-QAYICQKZ.cjs');







var _chunkDSGTB57Jcjs = require('./chunk-DSGTB57J.cjs');







var _chunkOBXZ7YJ7cjs = require('./chunk-OBXZ7YJ7.cjs');


var _chunkON577KNDcjs = require('./chunk-ON577KND.cjs');



var _chunkHIB3AS73cjs = require('./chunk-HIB3AS73.cjs');

// src/client/http-client-driver.ts
function createHttpClientDriver(managerEndpoint) {
  const dynamicImports = (async () => {
    const [WebSocket, EventSource] = await Promise.all([
      _chunkQAYICQKZcjs.importWebSocket.call(void 0, ),
      _chunkDSGTB57Jcjs.importEventSource.call(void 0, )
    ]);
    return {
      WebSocket,
      EventSource
    };
  })();
  const driver = {
    action: async (_c, actorQuery, encoding, params, name, args, opts) => {
      _chunkON577KNDcjs.logger.call(void 0, ).debug("actor handle action", {
        name,
        args,
        query: actorQuery
      });
      const responseData = await _chunkDSGTB57Jcjs.sendHttpRequest.call(void 0, 
        {
          url: `${managerEndpoint}/registry/actors/actions/${encodeURIComponent(name)}`,
          method: "POST",
          headers: {
            [_chunkOBXZ7YJ7cjs.HEADER_ENCODING]: encoding,
            [_chunkOBXZ7YJ7cjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
            ...params !== void 0 ? { [_chunkOBXZ7YJ7cjs.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) => {
      _chunkON577KNDcjs.logger.call(void 0, ).debug("resolving actor ID", { query: actorQuery });
      try {
        const result = await _chunkDSGTB57Jcjs.sendHttpRequest.call(void 0, {
          url: `${managerEndpoint}/registry/actors/resolve`,
          method: "POST",
          headers: {
            [_chunkOBXZ7YJ7cjs.HEADER_ENCODING]: encodingKind,
            [_chunkOBXZ7YJ7cjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
            ...params !== void 0 ? { [_chunkOBXZ7YJ7cjs.HEADER_CONN_PARAMS]: JSON.stringify(params) } : {}
          },
          body: {},
          encoding: encodingKind
        });
        _chunkON577KNDcjs.logger.call(void 0, ).debug("resolved actor ID", { actorId: result.i });
        return result.i;
      } catch (error) {
        _chunkON577KNDcjs.logger.call(void 0, ).error("failed to resolve actor ID", { error });
        if (error instanceof _chunkDSGTB57Jcjs.ActorError) {
          throw error;
        } else {
          throw new (0, _chunkDSGTB57Jcjs.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");
      _chunkON577KNDcjs.logger.call(void 0, ).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 {
        _chunkHIB3AS73cjs.assertUnreachable.call(void 0, encodingKind);
      }
      return ws;
    },
    connectSse: async (_c, actorQuery, encodingKind, params) => {
      const { EventSource } = await dynamicImports;
      const url = `${managerEndpoint}/registry/actors/connect/sse`;
      _chunkON577KNDcjs.logger.call(void 0, ).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": _chunkHIB3AS73cjs.httpUserAgent.call(void 0, ),
              [_chunkOBXZ7YJ7cjs.HEADER_ENCODING]: encodingKind,
              [_chunkOBXZ7YJ7cjs.HEADER_ACTOR_QUERY]: JSON.stringify(actorQuery),
              ...params !== void 0 ? { [_chunkOBXZ7YJ7cjs.HEADER_CONN_PARAMS]: JSON.stringify(params) } : {}
            },
            credentials: "include"
          });
        }
      });
      return eventSource;
    },
    sendHttpMessage: async (_c, actorId, encoding, connectionId, connectionToken, message) => {
      const messageSerialized = _chunkDSGTB57Jcjs.serializeWithEncoding.call(void 0, encoding, message);
      const res = await fetch(`${managerEndpoint}/registry/actors/message`, {
        method: "POST",
        headers: {
          "User-Agent": _chunkHIB3AS73cjs.httpUserAgent.call(void 0, ),
          [_chunkOBXZ7YJ7cjs.HEADER_ENCODING]: encoding,
          [_chunkOBXZ7YJ7cjs.HEADER_ACTOR_ID]: actorId,
          [_chunkOBXZ7YJ7cjs.HEADER_CONN_ID]: connectionId,
          [_chunkOBXZ7YJ7cjs.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}`;
      _chunkON577KNDcjs.logger.call(void 0, ).debug("rewriting http url", {
        from: path,
        to: url
      });
      const headers = new Headers(init.headers);
      headers.set("User-Agent", _chunkHIB3AS73cjs.httpUserAgent.call(void 0, ));
      headers.set(_chunkOBXZ7YJ7cjs.HEADER_ACTOR_QUERY, JSON.stringify(actorQuery));
      headers.set(_chunkOBXZ7YJ7cjs.HEADER_ENCODING, encoding);
      if (params !== void 0) {
        headers.set(_chunkOBXZ7YJ7cjs.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}`;
      _chunkON577KNDcjs.logger.call(void 0, ).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);
        }
      }
      _chunkON577KNDcjs.logger.call(void 0, ).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 _chunkDSGTB57Jcjs.createClientWithDriver.call(void 0, driver, opts);
}



exports.createClient = createClient;
//# sourceMappingURL=chunk-ZCUB7MR5.cjs.map