rivetkit/dist/tsup/chunk-MLQIYKAZ.js

Lightweight libraries for building stateful actors on edge platforms

import {
  getLogger
} from "./chunk-7E5K3375.js";
import {
  assertUnreachable
} from "./chunk-HI55LHM3.js";
import {
  Unreachable
} from "./chunk-YPZFLUO6.js";

// src/actor/log.ts
function loggerWithoutContext() {
  return getLogger("actor-runtime");
}

// src/actor/utils.ts
function assertUnreachable2(x) {
  loggerWithoutContext().error({
    msg: "unreachable",
    value: `${x}`,
    stack: new Error().stack
  });
  throw new Unreachable(x);
}
var DeadlineError = class extends Error {
  constructor() {
    super("Promise did not complete before deadline.");
  }
};
function deadline(promise, timeout) {
  const controller = new AbortController();
  const signal = controller.signal;
  const timeoutId = setTimeout(() => controller.abort(), timeout);
  return Promise.race([
    promise,
    new Promise((_, reject) => {
      signal.addEventListener("abort", () => reject(new DeadlineError()));
    })
  ]).finally(() => {
    clearTimeout(timeoutId);
  });
}
function generateSecureToken(length = 32) {
  const array = new Uint8Array(length);
  crypto.getRandomValues(array);
  return btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function generateRandomString(length = 32) {
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  let result = "";
  for (let i = 0; i < length; i++) {
    const randomIndex = Math.floor(Math.random() * characters.length);
    result += characters[randomIndex];
  }
  return result;
}

// src/common/actor-router-consts.ts
var PATH_CONNECT_WEBSOCKET = "/connect/websocket";
var PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
var HEADER_ACTOR_QUERY = "x-rivet-query";
var HEADER_ENCODING = "x-rivet-encoding";
var HEADER_CONN_PARAMS = "x-rivet-conn-params";
var HEADER_ACTOR_ID = "x-rivet-actor";
var HEADER_CONN_ID = "x-rivet-conn";
var HEADER_CONN_TOKEN = "x-rivet-conn-token";
var HEADER_RIVET_TOKEN = "x-rivet-token";
var HEADER_RIVET_TARGET = "x-rivet-target";
var HEADER_RIVET_ACTOR = "x-rivet-actor";
var WS_PROTOCOL_STANDARD = "rivet";
var WS_PROTOCOL_TARGET = "rivet_target.";
var WS_PROTOCOL_ACTOR = "rivet_actor.";
var WS_PROTOCOL_ENCODING = "rivet_encoding.";
var WS_PROTOCOL_CONN_PARAMS = "rivet_conn_params.";
var WS_PROTOCOL_CONN_ID = "rivet_conn.";
var WS_PROTOCOL_CONN_TOKEN = "rivet_conn_token.";
var WS_PROTOCOL_TOKEN = "rivet_token.";
var WS_PROTOCOL_TRANSPORT = "test_transport.";
var WS_PROTOCOL_PATH = "test_path.";
var ALLOWED_PUBLIC_HEADERS = [
  "Content-Type",
  "User-Agent",
  HEADER_ACTOR_QUERY,
  HEADER_ENCODING,
  HEADER_CONN_PARAMS,
  HEADER_ACTOR_ID,
  HEADER_CONN_ID,
  HEADER_CONN_TOKEN,
  HEADER_RIVET_TARGET,
  HEADER_RIVET_ACTOR,
  HEADER_RIVET_TOKEN
];

// src/serde.ts
import * as cbor from "cbor-x";
import invariant from "invariant";

// src/actor/protocol/serde.ts
import { z } from "zod";
var EncodingSchema = z.enum(["json", "cbor", "bare"]);
var CachedSerializer = class {
  #data;
  #cache = /* @__PURE__ */ new Map();
  #versionedDataHandler;
  constructor(data, versionedDataHandler) {
    this.#data = data;
    this.#versionedDataHandler = versionedDataHandler;
  }
  get rawData() {
    return this.#data;
  }
  serialize(encoding) {
    const cached = this.#cache.get(encoding);
    if (cached) {
      return cached;
    } else {
      const serialized = serializeWithEncoding(
        encoding,
        this.#data,
        this.#versionedDataHandler
      );
      this.#cache.set(encoding, serialized);
      return serialized;
    }
  }
};
function base64EncodeUint8Array(uint8Array) {
  let binary = "";
  const len = uint8Array.byteLength;
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(uint8Array[i]);
  }
  return btoa(binary);
}
function base64EncodeArrayBuffer(arrayBuffer) {
  const uint8Array = new Uint8Array(arrayBuffer);
  return base64EncodeUint8Array(uint8Array);
}
function encodeDataToString(message) {
  if (typeof message === "string") {
    return message;
  } else if (message instanceof ArrayBuffer) {
    return base64EncodeArrayBuffer(message);
  } else if (message instanceof Uint8Array) {
    return base64EncodeUint8Array(message);
  } else {
    assertUnreachable2(message);
  }
}
function base64DecodeToUint8Array(base64) {
  if (typeof Buffer !== "undefined") {
    return new Uint8Array(Buffer.from(base64, "base64"));
  }
  const binary = atob(base64);
  const len = binary.length;
  const bytes = new Uint8Array(len);
  for (let i = 0; i < len; i++) {
    bytes[i] = binary.charCodeAt(i);
  }
  return bytes;
}
function base64DecodeToArrayBuffer(base64) {
  return base64DecodeToUint8Array(base64).buffer;
}
function jsonStringifyCompat(input) {
  return JSON.stringify(input, (_key, value) => {
    if (typeof value === "bigint") {
      return ["$BigInt", value.toString()];
    } else if (value instanceof ArrayBuffer) {
      return ["$ArrayBuffer", base64EncodeArrayBuffer(value)];
    } else if (value instanceof Uint8Array) {
      return ["$Uint8Array", base64EncodeUint8Array(value)];
    }
    if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0].startsWith("$")) {
      return ["$" + value[0], value[1]];
    }
    return value;
  });
}
function jsonParseCompat(input) {
  return JSON.parse(input, (_key, value) => {
    if (Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && value[0].startsWith("$")) {
      if (value[0] === "$BigInt") {
        return BigInt(value[1]);
      } else if (value[0] === "$ArrayBuffer") {
        return base64DecodeToArrayBuffer(value[1]);
      } else if (value[0] === "$Uint8Array") {
        return base64DecodeToUint8Array(value[1]);
      }
      if (value[0].startsWith("$$")) {
        return [value[0].substring(1), value[1]];
      }
      throw new Error(
        `Unknown JSON encoding type: ${value[0]}. This may indicate corrupted data or a version mismatch.`
      );
    }
    return value;
  });
}

// src/serde.ts
function uint8ArrayToBase64(uint8Array) {
  if (typeof Buffer !== "undefined") {
    return Buffer.from(uint8Array).toString("base64");
  }
  let binary = "";
  const len = uint8Array.byteLength;
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(uint8Array[i]);
  }
  return btoa(binary);
}
function encodingIsBinary(encoding) {
  if (encoding === "json") {
    return false;
  } else if (encoding === "cbor" || encoding === "bare") {
    return true;
  } else {
    assertUnreachable(encoding);
  }
}
function contentTypeForEncoding(encoding) {
  if (encoding === "json") {
    return "application/json";
  } else if (encoding === "cbor" || encoding === "bare") {
    return "application/octet-stream";
  } else {
    assertUnreachable(encoding);
  }
}
function serializeWithEncoding(encoding, value, versionedDataHandler) {
  if (encoding === "json") {
    return jsonStringifyCompat(value);
  } else if (encoding === "cbor") {
    return cbor.encode(value);
  } else if (encoding === "bare") {
    if (!versionedDataHandler) {
      throw new Error("VersionedDataHandler is required for 'bare' encoding");
    }
    return versionedDataHandler.serializeWithEmbeddedVersion(value);
  } else {
    assertUnreachable(encoding);
  }
}
function deserializeWithEncoding(encoding, buffer, versionedDataHandler) {
  if (encoding === "json") {
    if (typeof buffer === "string") {
      return jsonParseCompat(buffer);
    } else {
      const decoder = new TextDecoder("utf-8");
      const jsonString = decoder.decode(buffer);
      return jsonParseCompat(jsonString);
    }
  } else if (encoding === "cbor") {
    invariant(
      typeof buffer !== "string",
      "buffer cannot be string for cbor encoding"
    );
    return cbor.decode(buffer);
  } else if (encoding === "bare") {
    invariant(
      typeof buffer !== "string",
      "buffer cannot be string for bare encoding"
    );
    if (!versionedDataHandler) {
      throw new Error("VersionedDataHandler is required for 'bare' encoding");
    }
    return versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
  } else {
    assertUnreachable(encoding);
  }
}

export {
  uint8ArrayToBase64,
  encodingIsBinary,
  contentTypeForEncoding,
  serializeWithEncoding,
  deserializeWithEncoding,
  loggerWithoutContext,
  assertUnreachable2 as assertUnreachable,
  DeadlineError,
  deadline,
  generateSecureToken,
  generateRandomString,
  EncodingSchema,
  CachedSerializer,
  encodeDataToString,
  jsonStringifyCompat,
  PATH_CONNECT_WEBSOCKET,
  PATH_RAW_WEBSOCKET_PREFIX,
  HEADER_ACTOR_QUERY,
  HEADER_ENCODING,
  HEADER_CONN_PARAMS,
  HEADER_ACTOR_ID,
  HEADER_CONN_ID,
  HEADER_CONN_TOKEN,
  HEADER_RIVET_TOKEN,
  HEADER_RIVET_TARGET,
  HEADER_RIVET_ACTOR,
  WS_PROTOCOL_STANDARD,
  WS_PROTOCOL_TARGET,
  WS_PROTOCOL_ACTOR,
  WS_PROTOCOL_ENCODING,
  WS_PROTOCOL_CONN_PARAMS,
  WS_PROTOCOL_CONN_ID,
  WS_PROTOCOL_CONN_TOKEN,
  WS_PROTOCOL_TOKEN,
  WS_PROTOCOL_TRANSPORT,
  WS_PROTOCOL_PATH,
  ALLOWED_PUBLIC_HEADERS
};
//# sourceMappingURL=chunk-MLQIYKAZ.js.map