@parsrun/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1987 @@
+// src/runtime.ts
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    return "bun";
+  }
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    return "deno";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.caches !== "undefined" && typeof globalThis.process === "undefined") {
+    return "cloudflare";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.EdgeRuntime !== "undefined") {
+    return "edge";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  return "unknown";
+}
+var runtime = detectRuntime();
+var runtimeInfo = {
+  runtime,
+  isNode: runtime === "node",
+  isDeno: runtime === "deno",
+  isBun: runtime === "bun",
+  isCloudflare: runtime === "cloudflare",
+  isEdge: runtime === "cloudflare" || runtime === "edge" || runtime === "deno",
+  isBrowser: runtime === "browser",
+  isServer: runtime !== "browser",
+  supportsWebCrypto: typeof globalThis.crypto?.subtle !== "undefined",
+  supportsStreams: typeof globalThis.ReadableStream !== "undefined"
+};
+function isNode() {
+  return runtime === "node";
+}
+function isDeno() {
+  return runtime === "deno";
+}
+function isBun() {
+  return runtime === "bun";
+}
+function isCloudflare() {
+  return runtime === "cloudflare";
+}
+function isEdge() {
+  return runtimeInfo.isEdge;
+}
+function isBrowser() {
+  return runtime === "browser";
+}
+function isServer() {
+  return runtimeInfo.isServer;
+}
+function getRuntimeVersion() {
+  switch (runtime) {
+    case "node":
+      return `Node.js ${process.versions.node}`;
+    case "bun":
+      return `Bun ${globalThis.Bun.version}`;
+    case "deno":
+      return `Deno ${globalThis.Deno.version.deno}`;
+    case "cloudflare":
+      return "Cloudflare Workers";
+    case "edge":
+      return "Edge Runtime";
+    case "browser":
+      return typeof navigator !== "undefined" ? navigator.userAgent : "Browser";
+    default:
+      return "Unknown";
+  }
+}
+
+// src/env.ts
+var edgeEnvStore = {};
+function setEdgeEnv(env) {
+  edgeEnvStore = { ...edgeEnvStore, ...env };
+}
+function clearEdgeEnv() {
+  edgeEnvStore = {};
+}
+function getEnv(key, defaultValue) {
+  if (runtime === "cloudflare" || runtime === "edge") {
+    return edgeEnvStore[key] ?? defaultValue;
+  }
+  if (runtime === "deno") {
+    try {
+      return globalThis.Deno.env.get(key) ?? defaultValue;
+    } catch {
+      return defaultValue;
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key] ?? defaultValue;
+  }
+  if (runtime === "browser" && typeof globalThis.__ENV__ !== "undefined") {
+    return globalThis.__ENV__[key] ?? defaultValue;
+  }
+  return defaultValue;
+}
+function requireEnv(key) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    throw new Error(`Required environment variable "${key}" is not set`);
+  }
+  return value;
+}
+function getEnvNumber(key, defaultValue) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function getEnvFloat(key, defaultValue) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function getEnvBoolean(key, defaultValue = false) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  return value === "true" || value === "1" || value === "yes";
+}
+function getEnvArray(key, defaultValue = []) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function getEnvJson(key, defaultValue) {
+  const value = getEnv(key);
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return defaultValue;
+  }
+}
+function isDevelopment() {
+  const env = getEnv("NODE_ENV");
+  return env === "development" || env === void 0;
+}
+function isProduction() {
+  return getEnv("NODE_ENV") === "production";
+}
+function isTest() {
+  return getEnv("NODE_ENV") === "test";
+}
+function getEnvMode() {
+  const env = getEnv("NODE_ENV");
+  if (env === "production") return "production";
+  if (env === "test") return "test";
+  return "development";
+}
+function createEnvConfig(schema) {
+  const result = {};
+  for (const [key, config] of Object.entries(schema)) {
+    const envConfig = config;
+    let value;
+    switch (envConfig.type) {
+      case "number":
+        value = getEnvNumber(key, envConfig.default);
+        break;
+      case "boolean":
+        value = getEnvBoolean(key, envConfig.default);
+        break;
+      case "array":
+        value = getEnvArray(key, envConfig.default);
+        break;
+      case "json":
+        value = getEnvJson(key, envConfig.default);
+        break;
+      default:
+        value = getEnv(key, envConfig.default);
+    }
+    if (envConfig.required && (value === void 0 || value === "")) {
+      throw new Error(`Required environment variable "${key}" is not set`);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/transports/console.ts
+var ConsoleTransport = class {
+  name = "console";
+  pretty;
+  colors;
+  constructor(options = {}) {
+    this.pretty = options.pretty ?? isDevelopment();
+    this.colors = options.colors ?? (runtime === "node" || runtime === "bun");
+  }
+  log(entry) {
+    if (this.pretty) {
+      this.logPretty(entry);
+    } else {
+      this.logJson(entry);
+    }
+  }
+  logJson(entry) {
+    const { level, message, timestamp, context, error } = entry;
+    const output = {
+      level,
+      time: timestamp,
+      msg: message
+    };
+    if (context && Object.keys(context).length > 0) {
+      Object.assign(output, context);
+    }
+    if (error) {
+      output["err"] = error;
+    }
+    console.log(JSON.stringify(output));
+  }
+  logPretty(entry) {
+    const { level, message, timestamp, context, error } = entry;
+    const levelColors = {
+      TRACE: "\x1B[90m",
+      // Gray
+      DEBUG: "\x1B[36m",
+      // Cyan
+      INFO: "\x1B[32m",
+      // Green
+      WARN: "\x1B[33m",
+      // Yellow
+      ERROR: "\x1B[31m",
+      // Red
+      FATAL: "\x1B[35m",
+      // Magenta
+      SILENT: ""
+    };
+    const reset = "\x1B[0m";
+    const color = this.colors ? levelColors[level] : "";
+    const resetCode = this.colors ? reset : "";
+    const timePart = timestamp.split("T")[1];
+    const time = timePart ? timePart.slice(0, 8) : timestamp;
+    let output = `${color}[${time}] ${level.padEnd(5)}${resetCode} ${message}`;
+    if (context && Object.keys(context).length > 0) {
+      output += ` ${JSON.stringify(context)}`;
+    }
+    if (level === "ERROR" || level === "FATAL") {
+      console.error(output);
+      if (error?.stack) {
+        console.error(error.stack);
+      }
+    } else if (level === "WARN") {
+      console.warn(output);
+    } else if (level === "DEBUG" || level === "TRACE") {
+      console.debug(output);
+    } else {
+      console.log(output);
+    }
+  }
+};
+
+// src/logger.ts
+var LogLevel = {
+  TRACE: 10,
+  DEBUG: 20,
+  INFO: 30,
+  WARN: 40,
+  ERROR: 50,
+  FATAL: 60,
+  SILENT: 100
+};
+function redactFields(obj, fields) {
+  const result = { ...obj };
+  for (const field of fields) {
+    if (field in result) {
+      result[field] = "[REDACTED]";
+    }
+    const parts = field.split(".");
+    if (parts.length > 1) {
+      let current = result;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (part && current && typeof current === "object" && part in current) {
+          const val = current[part];
+          if (val && typeof val === "object") {
+            current = val;
+          } else {
+            current = void 0;
+            break;
+          }
+        } else {
+          current = void 0;
+          break;
+        }
+      }
+      const lastPart = parts[parts.length - 1];
+      if (lastPart && current && typeof current === "object" && lastPart in current) {
+        current[lastPart] = "[REDACTED]";
+      }
+    }
+  }
+  return result;
+}
+var DEFAULT_REDACT_FIELDS = [
+  "password",
+  "secret",
+  "token",
+  "accessToken",
+  "refreshToken",
+  "apiKey",
+  "authorization",
+  "cookie",
+  "creditCard",
+  "ssn"
+];
+var Logger = class _Logger {
+  level;
+  name;
+  context;
+  transports;
+  redactFields;
+  timestampFn;
+  constructor(config = {}) {
+    const levelName = config.level ?? getEnv("LOG_LEVEL") ?? "INFO";
+    this.level = LogLevel[levelName] ?? LogLevel.INFO;
+    this.name = config.name;
+    this.context = config.context ?? {};
+    this.transports = config.transports ?? [
+      new ConsoleTransport(
+        config.pretty !== void 0 ? { pretty: config.pretty } : {}
+      )
+    ];
+    this.redactFields = [...DEFAULT_REDACT_FIELDS, ...config.redact ?? []];
+    if (config.timestamp === false) {
+      this.timestampFn = () => "";
+    } else if (typeof config.timestamp === "function") {
+      this.timestampFn = config.timestamp;
+    } else {
+      this.timestampFn = () => (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    const levelEntry = Object.entries(LogLevel).find(([_, v]) => v === this.level);
+    const levelName = levelEntry ? levelEntry[0] : "INFO";
+    const child = new _Logger({
+      level: levelName,
+      name: this.name,
+      context: { ...this.context, ...context },
+      transports: this.transports,
+      redact: this.redactFields
+    });
+    return child;
+  }
+  /**
+   * Log a message
+   */
+  log(level, message, context, error) {
+    const levelValue = LogLevel[level];
+    if (levelValue < this.level) return;
+    let finalContext = { ...this.context };
+    if (this.name) {
+      finalContext["module"] = this.name;
+    }
+    if (context) {
+      finalContext = { ...finalContext, ...context };
+    }
+    finalContext = redactFields(finalContext, this.redactFields);
+    const entry = {
+      level,
+      levelValue,
+      message,
+      timestamp: this.timestampFn(),
+      context: Object.keys(finalContext).length > 0 ? finalContext : void 0,
+      error: error ? {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      } : void 0
+    };
+    for (const transport of this.transports) {
+      transport.log(entry);
+    }
+  }
+  trace(message, context) {
+    this.log("TRACE", message, context);
+  }
+  debug(message, context) {
+    this.log("DEBUG", message, context);
+  }
+  info(message, context) {
+    this.log("INFO", message, context);
+  }
+  warn(message, context) {
+    this.log("WARN", message, context);
+  }
+  error(message, error, context) {
+    const err2 = error instanceof Error ? error : void 0;
+    const ctx = error instanceof Error ? context : error;
+    this.log("ERROR", message, ctx, err2);
+  }
+  fatal(message, error, context) {
+    const err2 = error instanceof Error ? error : void 0;
+    const ctx = error instanceof Error ? context : error;
+    this.log("FATAL", message, ctx, err2);
+  }
+};
+function createLogger(config) {
+  return new Logger(config);
+}
+var logger = createLogger();
+function logError(log, error, message, context) {
+  if (error instanceof Error) {
+    log.error(message, error, context);
+  } else {
+    log.error(message, { error: String(error), ...context });
+  }
+}
+async function measureTime(log, operation, fn) {
+  const start = Date.now();
+  try {
+    const result = await fn();
+    const duration = Date.now() - start;
+    log.info(`${operation} completed`, { operation, durationMs: duration });
+    return result;
+  } catch (error) {
+    const duration = Date.now() - start;
+    logError(log, error, `${operation} failed`, { operation, durationMs: duration });
+    throw error;
+  }
+}
+function createRequestLogger(baseLogger, request) {
+  const pathname = request.url ? new URL(request.url).pathname : void 0;
+  return baseLogger.child({
+    requestId: request.requestId,
+    method: request.method,
+    path: pathname,
+    userId: request.userId,
+    tenantId: request.tenantId
+  });
+}
+
+// src/decimal.ts
+var PRECISION = 20;
+var Decimal = class _Decimal {
+  value;
+  constructor(value) {
+    if (value instanceof _Decimal) {
+      this.value = value.value;
+    } else if (typeof value === "number") {
+      this.value = this.normalizeNumber(value);
+    } else {
+      this.value = this.normalizeString(value);
+    }
+  }
+  normalizeNumber(n) {
+    if (!isFinite(n)) {
+      throw new Error(`Invalid number: ${n}`);
+    }
+    return n.toFixed(PRECISION).replace(/\.?0+$/, "") || "0";
+  }
+  normalizeString(s) {
+    const trimmed = s.trim();
+    if (!/^-?\d*\.?\d+$/.test(trimmed)) {
+      throw new Error(`Invalid decimal string: ${s}`);
+    }
+    return trimmed.replace(/^(-?)0+(?=\d)/, "$1").replace(/\.?0+$/, "") || "0";
+  }
+  /**
+   * Add two decimals
+   */
+  add(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    return new _Decimal(a + b);
+  }
+  /**
+   * Subtract
+   */
+  sub(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    return new _Decimal(a - b);
+  }
+  /**
+   * Multiply
+   */
+  mul(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    return new _Decimal(a * b);
+  }
+  /**
+   * Divide
+   */
+  div(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    if (b === 0) {
+      throw new Error("Division by zero");
+    }
+    return new _Decimal(a / b);
+  }
+  /**
+   * Modulo
+   */
+  mod(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    return new _Decimal(a % b);
+  }
+  /**
+   * Power
+   */
+  pow(exp) {
+    const a = parseFloat(this.value);
+    return new _Decimal(Math.pow(a, exp));
+  }
+  /**
+   * Square root
+   */
+  sqrt() {
+    const a = parseFloat(this.value);
+    if (a < 0) {
+      throw new Error("Square root of negative number");
+    }
+    return new _Decimal(Math.sqrt(a));
+  }
+  /**
+   * Absolute value
+   */
+  abs() {
+    const a = parseFloat(this.value);
+    return new _Decimal(Math.abs(a));
+  }
+  /**
+   * Negate
+   */
+  neg() {
+    const a = parseFloat(this.value);
+    return new _Decimal(-a);
+  }
+  /**
+   * Round to decimal places
+   */
+  round(decimals = 0) {
+    const a = parseFloat(this.value);
+    const factor = Math.pow(10, decimals);
+    return new _Decimal(Math.round(a * factor) / factor);
+  }
+  /**
+   * Floor to decimal places
+   */
+  floor(decimals = 0) {
+    const a = parseFloat(this.value);
+    const factor = Math.pow(10, decimals);
+    return new _Decimal(Math.floor(a * factor) / factor);
+  }
+  /**
+   * Ceiling to decimal places
+   */
+  ceil(decimals = 0) {
+    const a = parseFloat(this.value);
+    const factor = Math.pow(10, decimals);
+    return new _Decimal(Math.ceil(a * factor) / factor);
+  }
+  /**
+   * Compare: returns -1, 0, or 1
+   */
+  cmp(other) {
+    const a = parseFloat(this.value);
+    const b = parseFloat(other instanceof _Decimal ? other.value : String(other));
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  /**
+   * Equality check
+   */
+  eq(other) {
+    return this.cmp(other) === 0;
+  }
+  /**
+   * Greater than
+   */
+  gt(other) {
+    return this.cmp(other) === 1;
+  }
+  /**
+   * Greater than or equal
+   */
+  gte(other) {
+    return this.cmp(other) >= 0;
+  }
+  /**
+   * Less than
+   */
+  lt(other) {
+    return this.cmp(other) === -1;
+  }
+  /**
+   * Less than or equal
+   */
+  lte(other) {
+    return this.cmp(other) <= 0;
+  }
+  /**
+   * Check if zero
+   */
+  isZero() {
+    return parseFloat(this.value) === 0;
+  }
+  /**
+   * Check if positive
+   */
+  isPositive() {
+    return parseFloat(this.value) > 0;
+  }
+  /**
+   * Check if negative
+   */
+  isNegative() {
+    return parseFloat(this.value) < 0;
+  }
+  /**
+   * Convert to number
+   */
+  toNumber() {
+    return parseFloat(this.value);
+  }
+  /**
+   * Convert to string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Format with fixed decimal places
+   */
+  toFixed(decimals = 2) {
+    return parseFloat(this.value).toFixed(decimals);
+  }
+  /**
+   * Convert to JSON (string representation)
+   */
+  toJSON() {
+    return this.value;
+  }
+  /**
+   * Static: Create from value
+   */
+  static from(value) {
+    return new _Decimal(value);
+  }
+  /**
+   * Static: Sum array of values
+   */
+  static sum(values) {
+    return values.reduce(
+      (acc, val) => acc.add(val),
+      new _Decimal(0)
+    );
+  }
+  /**
+   * Static: Average of array
+   */
+  static avg(values) {
+    if (values.length === 0) return new _Decimal(0);
+    return _Decimal.sum(values).div(values.length);
+  }
+  /**
+   * Static: Min of array
+   */
+  static min(...values) {
+    if (values.length === 0) throw new Error("No values provided");
+    return values.reduce((min, val) => {
+      const d = new _Decimal(val);
+      return d.lt(min) ? d : min;
+    }, new _Decimal(values[0]));
+  }
+  /**
+   * Static: Max of array
+   */
+  static max(...values) {
+    if (values.length === 0) throw new Error("No values provided");
+    return values.reduce((max, val) => {
+      const d = new _Decimal(val);
+      return d.gt(max) ? d : max;
+    }, new _Decimal(values[0]));
+  }
+};
+var DecimalUtils = {
+  /**
+   * Convert number to database decimal string
+   */
+  toDecimalString(value) {
+    if (value === null || value === void 0) return null;
+    return new Decimal(value).toString();
+  },
+  /**
+   * Convert database decimal string to number
+   */
+  fromDecimalString(value) {
+    if (!value) return 0;
+    return new Decimal(value).toNumber();
+  },
+  /**
+   * Perform precise decimal multiplication
+   */
+  multiply(a, b) {
+    return new Decimal(a).mul(b).toString();
+  },
+  /**
+   * Perform precise decimal addition
+   */
+  add(a, b) {
+    return new Decimal(a).add(b).toString();
+  },
+  /**
+   * Perform precise decimal subtraction
+   */
+  subtract(a, b) {
+    return new Decimal(a).sub(b).toString();
+  },
+  /**
+   * Perform precise decimal division
+   */
+  divide(a, b) {
+    return new Decimal(a).div(b).toString();
+  },
+  /**
+   * Format decimal for display
+   */
+  format(value, decimalPlaces = 2) {
+    return new Decimal(value).toFixed(decimalPlaces);
+  },
+  /**
+   * Format as currency
+   */
+  formatCurrency(value, options = {}) {
+    const { currency = "USD", locale = "en-US", decimals = 2 } = options;
+    const num = new Decimal(value).toNumber();
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(num);
+  },
+  /**
+   * Convert object with decimal fields for database insert/update
+   */
+  prepareForDatabase(data, decimalFields) {
+    const result = { ...data };
+    for (const field of decimalFields) {
+      if (field in result && result[field] !== void 0 && result[field] !== null) {
+        const value = result[field];
+        if (typeof value === "number") {
+          result[field] = DecimalUtils.toDecimalString(value);
+        }
+      }
+    }
+    return result;
+  },
+  /**
+   * Convert object with decimal fields from database
+   */
+  parseFromDatabase(data, decimalFields) {
+    const result = { ...data };
+    for (const field of decimalFields) {
+      if (field in result && result[field] !== void 0 && result[field] !== null) {
+        const value = result[field];
+        if (typeof value === "string") {
+          result[field] = DecimalUtils.fromDecimalString(value);
+        }
+      }
+    }
+    return result;
+  }
+};
+function decimal(value) {
+  return new Decimal(value);
+}
+
+// src/types.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+
+// src/errors.ts
+var ParsError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(message, code, statusCode = 500, details) {
+    super(message);
+    this.name = "ParsError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details ?? void 0;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      details: this.details
+    };
+  }
+};
+var AuthError = class extends ParsError {
+  constructor(message, code = "AUTH_ERROR", statusCode = 401, details) {
+    super(message, code, statusCode, details);
+    this.name = "AuthError";
+  }
+};
+var UnauthorizedError = class extends AuthError {
+  constructor(message = "Unauthorized", details) {
+    super(message, "UNAUTHORIZED", 401, details);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends AuthError {
+  constructor(message = "Forbidden", details) {
+    super(message, "FORBIDDEN", 403, details);
+    this.name = "ForbiddenError";
+  }
+};
+var InvalidCredentialsError = class extends AuthError {
+  constructor(message = "Invalid credentials", details) {
+    super(message, "INVALID_CREDENTIALS", 401, details);
+    this.name = "InvalidCredentialsError";
+  }
+};
+var SessionExpiredError = class extends AuthError {
+  constructor(message = "Session expired", details) {
+    super(message, "SESSION_EXPIRED", 401, details);
+    this.name = "SessionExpiredError";
+  }
+};
+var TwoFactorRequiredError = class extends AuthError {
+  constructor(message = "Two-factor authentication required", challengeId, details) {
+    super(message, "TWO_FACTOR_REQUIRED", 403, { ...details, challengeId });
+    this.challengeId = challengeId;
+    this.name = "TwoFactorRequiredError";
+  }
+};
+var AccountLockedError = class extends AuthError {
+  constructor(message = "Account locked", lockedUntil, details) {
+    super(message, "ACCOUNT_LOCKED", 423, { ...details, lockedUntil });
+    this.lockedUntil = lockedUntil;
+    this.name = "AccountLockedError";
+  }
+};
+var TenantError = class extends ParsError {
+  constructor(message, code = "TENANT_ERROR", statusCode = 400, details) {
+    super(message, code, statusCode, details);
+    this.name = "TenantError";
+  }
+};
+var TenantNotFoundError = class extends TenantError {
+  constructor(message = "Tenant not found", details) {
+    super(message, "TENANT_NOT_FOUND", 404, details);
+    this.name = "TenantNotFoundError";
+  }
+};
+var TenantSuspendedError = class extends TenantError {
+  constructor(message = "Tenant suspended", details) {
+    super(message, "TENANT_SUSPENDED", 403, details);
+    this.name = "TenantSuspendedError";
+  }
+};
+var MembershipError = class extends TenantError {
+  constructor(message = "Membership error", code = "MEMBERSHIP_ERROR", statusCode = 400, details) {
+    super(message, code, statusCode, details);
+    this.name = "MembershipError";
+  }
+};
+var MembershipNotFoundError = class extends MembershipError {
+  constructor(message = "Membership not found", details) {
+    super(message, "MEMBERSHIP_NOT_FOUND", 404, details);
+    this.name = "MembershipNotFoundError";
+  }
+};
+var MembershipExpiredError = class extends MembershipError {
+  constructor(message = "Membership expired", details) {
+    super(message, "MEMBERSHIP_EXPIRED", 403, details);
+    this.name = "MembershipExpiredError";
+  }
+};
+var ValidationError = class extends ParsError {
+  constructor(message = "Validation failed", errors, details) {
+    super(message, "VALIDATION_ERROR", 400, { ...details, errors });
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends ParsError {
+  constructor(message = "Rate limit exceeded", retryAfter, details) {
+    super(message, "RATE_LIMIT_EXCEEDED", 429, { ...details, retryAfter });
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+var NotFoundError = class extends ParsError {
+  constructor(resource = "Resource", message, details) {
+    super(message ?? `${resource} not found`, "NOT_FOUND", 404, { ...details, resource });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends ParsError {
+  constructor(message = "Conflict", details) {
+    super(message, "CONFLICT", 409, details);
+    this.name = "ConflictError";
+  }
+};
+var DuplicateError = class extends ConflictError {
+  constructor(resource = "Resource", field, details) {
+    super(`${resource} already exists${field ? ` with this ${field}` : ""}`, {
+      ...details,
+      resource,
+      field
+    });
+    this.name = "DuplicateError";
+  }
+};
+
+// src/error-codes.ts
+var ErrorCodes = {
+  // ============================================================================
+  // Authentication Errors (401, 403, 423)
+  // ============================================================================
+  AUTH_ERROR: {
+    code: "AUTH_ERROR",
+    status: 401,
+    category: "auth"
+  },
+  UNAUTHORIZED: {
+    code: "UNAUTHORIZED",
+    status: 401,
+    category: "auth"
+  },
+  FORBIDDEN: {
+    code: "FORBIDDEN",
+    status: 403,
+    category: "auth"
+  },
+  INVALID_CREDENTIALS: {
+    code: "INVALID_CREDENTIALS",
+    status: 401,
+    category: "auth"
+  },
+  SESSION_EXPIRED: {
+    code: "SESSION_EXPIRED",
+    status: 401,
+    category: "auth"
+  },
+  TOKEN_EXPIRED: {
+    code: "TOKEN_EXPIRED",
+    status: 401,
+    category: "auth"
+  },
+  TOKEN_INVALID: {
+    code: "TOKEN_INVALID",
+    status: 401,
+    category: "auth"
+  },
+  TWO_FACTOR_REQUIRED: {
+    code: "TWO_FACTOR_REQUIRED",
+    status: 403,
+    category: "auth"
+  },
+  TWO_FACTOR_INVALID: {
+    code: "TWO_FACTOR_INVALID",
+    status: 401,
+    category: "auth"
+  },
+  ACCOUNT_LOCKED: {
+    code: "ACCOUNT_LOCKED",
+    status: 423,
+    category: "auth"
+  },
+  ACCOUNT_DISABLED: {
+    code: "ACCOUNT_DISABLED",
+    status: 403,
+    category: "auth"
+  },
+  PASSWORD_RESET_REQUIRED: {
+    code: "PASSWORD_RESET_REQUIRED",
+    status: 403,
+    category: "auth"
+  },
+  // ============================================================================
+  // Tenant Errors (400, 403, 404)
+  // ============================================================================
+  TENANT_ERROR: {
+    code: "TENANT_ERROR",
+    status: 400,
+    category: "tenant"
+  },
+  TENANT_NOT_FOUND: {
+    code: "TENANT_NOT_FOUND",
+    status: 404,
+    category: "tenant"
+  },
+  TENANT_SUSPENDED: {
+    code: "TENANT_SUSPENDED",
+    status: 403,
+    category: "tenant"
+  },
+  TENANT_LIMIT_EXCEEDED: {
+    code: "TENANT_LIMIT_EXCEEDED",
+    status: 403,
+    category: "tenant"
+  },
+  MEMBERSHIP_ERROR: {
+    code: "MEMBERSHIP_ERROR",
+    status: 400,
+    category: "tenant"
+  },
+  MEMBERSHIP_NOT_FOUND: {
+    code: "MEMBERSHIP_NOT_FOUND",
+    status: 404,
+    category: "tenant"
+  },
+  MEMBERSHIP_EXPIRED: {
+    code: "MEMBERSHIP_EXPIRED",
+    status: 403,
+    category: "tenant"
+  },
+  // ============================================================================
+  // Validation Errors (400, 422)
+  // ============================================================================
+  VALIDATION_ERROR: {
+    code: "VALIDATION_ERROR",
+    status: 400,
+    category: "validation"
+  },
+  BAD_REQUEST: {
+    code: "BAD_REQUEST",
+    status: 400,
+    category: "validation"
+  },
+  INVALID_INPUT: {
+    code: "INVALID_INPUT",
+    status: 422,
+    category: "validation"
+  },
+  MISSING_REQUIRED_FIELD: {
+    code: "MISSING_REQUIRED_FIELD",
+    status: 400,
+    category: "validation"
+  },
+  INVALID_FORMAT: {
+    code: "INVALID_FORMAT",
+    status: 400,
+    category: "validation"
+  },
+  // ============================================================================
+  // Resource Errors (404, 409, 410)
+  // ============================================================================
+  NOT_FOUND: {
+    code: "NOT_FOUND",
+    status: 404,
+    category: "resource"
+  },
+  CONFLICT: {
+    code: "CONFLICT",
+    status: 409,
+    category: "resource"
+  },
+  DUPLICATE: {
+    code: "DUPLICATE",
+    status: 409,
+    category: "resource"
+  },
+  GONE: {
+    code: "GONE",
+    status: 410,
+    category: "resource"
+  },
+  RESOURCE_LOCKED: {
+    code: "RESOURCE_LOCKED",
+    status: 423,
+    category: "resource"
+  },
+  // ============================================================================
+  // Rate Limiting (429)
+  // ============================================================================
+  RATE_LIMIT_EXCEEDED: {
+    code: "RATE_LIMIT_EXCEEDED",
+    status: 429,
+    category: "rate_limit",
+    retryable: true
+  },
+  QUOTA_EXCEEDED: {
+    code: "QUOTA_EXCEEDED",
+    status: 429,
+    category: "rate_limit"
+  },
+  // ============================================================================
+  // Server Errors (500, 502, 503, 504)
+  // ============================================================================
+  INTERNAL_ERROR: {
+    code: "INTERNAL_ERROR",
+    status: 500,
+    category: "server"
+  },
+  BAD_GATEWAY: {
+    code: "BAD_GATEWAY",
+    status: 502,
+    category: "server",
+    retryable: true
+  },
+  SERVICE_UNAVAILABLE: {
+    code: "SERVICE_UNAVAILABLE",
+    status: 503,
+    category: "server",
+    retryable: true
+  },
+  GATEWAY_TIMEOUT: {
+    code: "GATEWAY_TIMEOUT",
+    status: 504,
+    category: "server",
+    retryable: true
+  },
+  // ============================================================================
+  // Database Errors (500)
+  // ============================================================================
+  DATABASE_ERROR: {
+    code: "DATABASE_ERROR",
+    status: 500,
+    category: "database"
+  },
+  CONNECTION_ERROR: {
+    code: "CONNECTION_ERROR",
+    status: 503,
+    category: "database",
+    retryable: true
+  },
+  TRANSACTION_ERROR: {
+    code: "TRANSACTION_ERROR",
+    status: 500,
+    category: "database"
+  },
+  RLS_ERROR: {
+    code: "RLS_ERROR",
+    status: 500,
+    category: "database"
+  },
+  // ============================================================================
+  // External Service Errors (502, 503)
+  // ============================================================================
+  EXTERNAL_SERVICE_ERROR: {
+    code: "EXTERNAL_SERVICE_ERROR",
+    status: 502,
+    category: "external",
+    retryable: true
+  },
+  EXTERNAL_TIMEOUT: {
+    code: "EXTERNAL_TIMEOUT",
+    status: 504,
+    category: "external",
+    retryable: true
+  }
+};
+function getErrorCode(code) {
+  return ErrorCodes[code];
+}
+function getErrorCodesByCategory(category) {
+  return Object.values(ErrorCodes).filter((e) => e.category === category);
+}
+function isRetryableError(code) {
+  const errorCode = getErrorCode(code);
+  return errorCode?.retryable === true;
+}
+function getStatusForCode(code) {
+  const errorCode = getErrorCode(code);
+  return errorCode?.status ?? 500;
+}
+
+// src/transports/axiom.ts
+var AxiomTransport = class {
+  name = "axiom";
+  buffer = [];
+  flushTimer = null;
+  isFlushing = false;
+  options;
+  constructor(options) {
+    this.options = {
+      batchSize: 100,
+      flushInterval: 5e3,
+      apiUrl: "https://api.axiom.co",
+      ...options
+    };
+    if (this.options.flushInterval > 0) {
+      this.flushTimer = setInterval(
+        () => this.flush(),
+        this.options.flushInterval
+      );
+    }
+  }
+  log(entry) {
+    if (this.options.enabled === false) return;
+    const event = {
+      _time: entry.timestamp,
+      level: entry.level,
+      message: entry.message
+    };
+    if (entry.context) {
+      Object.assign(event, entry.context);
+    }
+    if (entry.error) {
+      event["error.name"] = entry.error.name;
+      event["error.message"] = entry.error.message;
+      event["error.stack"] = entry.error.stack;
+    }
+    this.buffer.push(event);
+    if (this.buffer.length >= this.options.batchSize) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.isFlushing || this.buffer.length === 0) return;
+    this.isFlushing = true;
+    const events = this.buffer;
+    this.buffer = [];
+    try {
+      const response = await fetch(
+        `${this.options.apiUrl}/v1/datasets/${this.options.dataset}/ingest`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.options.token}`,
+            "Content-Type": "application/json",
+            ...this.options.orgId && {
+              "X-Axiom-Org-Id": this.options.orgId
+            }
+          },
+          body: JSON.stringify(events)
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Axiom ingest failed: ${response.status} ${errorText}`);
+      }
+    } catch (error) {
+      if (this.options.onError) {
+        this.options.onError(
+          error instanceof Error ? error : new Error(String(error)),
+          events.length
+        );
+      } else {
+        console.error("[Axiom] Failed to send logs:", error);
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+function createAxiomTransport(options) {
+  return new AxiomTransport(options);
+}
+
+// src/transports/sentry.ts
+var SentryTransport = class {
+  name = "sentry";
+  client;
+  dsn;
+  options;
+  user = null;
+  contexts = /* @__PURE__ */ new Map();
+  breadcrumbs = [];
+  maxBreadcrumbs = 100;
+  constructor(options) {
+    this.options = {
+      sampleRate: 1,
+      ...options
+    };
+    if (options.client) {
+      this.client = options.client;
+    } else if (options.dsn) {
+      this.dsn = this.parseDSN(options.dsn);
+    } else {
+      throw new Error("SentryTransport requires either 'dsn' or 'client' option");
+    }
+  }
+  /**
+   * Parse Sentry DSN
+   */
+  parseDSN(dsn) {
+    const match = dsn.match(/^(https?):\/\/([^@]+)@([^/]+)\/(.+)$/);
+    if (!match || !match[1] || !match[2] || !match[3] || !match[4]) {
+      throw new Error(`Invalid Sentry DSN: ${dsn}`);
+    }
+    return {
+      protocol: match[1],
+      publicKey: match[2],
+      host: match[3],
+      projectId: match[4]
+    };
+  }
+  /**
+   * LogTransport implementation
+   * Only sends ERROR and FATAL level logs
+   */
+  log(entry) {
+    if (this.options.enabled === false) return;
+    if (entry.levelValue < 50) return;
+    if (entry.error) {
+      const error = new Error(entry.error.message);
+      error.name = entry.error.name;
+      if (entry.error.stack) {
+        error.stack = entry.error.stack;
+      }
+      this.captureException(
+        error,
+        entry.context ? { extra: entry.context } : void 0
+      );
+    } else {
+      this.captureMessage(
+        entry.message,
+        entry.level === "FATAL" ? "error" : "warning",
+        entry.context ? { extra: entry.context } : void 0
+      );
+    }
+  }
+  /**
+   * Capture an exception
+   */
+  captureException(error, context) {
+    if (this.options.enabled === false) return;
+    if (!this.shouldSample()) return;
+    if (this.client) {
+      this.captureWithSdk(error, context);
+    } else {
+      this.captureWithHttp(error, context);
+    }
+  }
+  /**
+   * Capture a message
+   */
+  captureMessage(message, level, context) {
+    if (this.options.enabled === false) return;
+    if (!this.shouldSample()) return;
+    if (this.client) {
+      this.client.withScope((scope) => {
+        this.applyContext(scope, context);
+        scope.setLevel(level);
+        this.client.captureMessage(message, level);
+      });
+    } else {
+      this.sendHttpEvent({
+        level: level === "warning" ? "warning" : level === "info" ? "info" : "error",
+        message: { formatted: message },
+        ...this.buildEventContext(context)
+      });
+    }
+  }
+  /**
+   * Set user context
+   */
+  setUser(user) {
+    this.user = user;
+  }
+  /**
+   * Set custom context
+   */
+  setContext(name, context) {
+    this.contexts.set(name, context);
+  }
+  /**
+   * Add breadcrumb
+   */
+  addBreadcrumb(breadcrumb) {
+    this.breadcrumbs.push({
+      ...breadcrumb,
+      timestamp: breadcrumb.timestamp ?? Date.now() / 1e3
+    });
+    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
+      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
+    }
+  }
+  /**
+   * Flush pending events
+   */
+  async flush() {
+    if (this.client?.flush) {
+      await this.client.flush(2e3);
+    }
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  shouldSample() {
+    const rate = this.options.sampleRate ?? 1;
+    return Math.random() < rate;
+  }
+  /**
+   * Capture with SDK (BYOS mode)
+   */
+  captureWithSdk(error, context) {
+    this.client.withScope((scope) => {
+      this.applyContext(scope, context);
+      this.client.captureException(error);
+    });
+  }
+  /**
+   * Apply context to SDK scope
+   */
+  applyContext(scope, context) {
+    if (this.user) {
+      scope.setUser(this.user);
+    } else if (context?.userId) {
+      scope.setUser({ id: context.userId });
+    }
+    if (this.options.tags) {
+      for (const [key, value] of Object.entries(this.options.tags)) {
+        scope.setTag(key, value);
+      }
+    }
+    if (context?.tags) {
+      for (const [key, value] of Object.entries(context.tags)) {
+        scope.setTag(key, value);
+      }
+    }
+    if (context?.requestId) {
+      scope.setTag("requestId", context.requestId);
+    }
+    if (context?.tenantId) {
+      scope.setTag("tenantId", context.tenantId);
+    }
+    if (context?.extra) {
+      scope.setExtras(context.extra);
+    }
+    for (const bc of this.breadcrumbs) {
+      scope.addBreadcrumb(bc);
+    }
+  }
+  /**
+   * Capture with HTTP API (default mode)
+   */
+  captureWithHttp(error, context) {
+    const stacktrace = this.parseStackTrace(error.stack);
+    const exceptionValue = {
+      type: error.name,
+      value: error.message
+    };
+    if (stacktrace) {
+      exceptionValue.stacktrace = stacktrace;
+    }
+    const event = {
+      level: "error",
+      exception: {
+        values: [exceptionValue]
+      },
+      ...this.buildEventContext(context)
+    };
+    this.sendHttpEvent(event);
+  }
+  /**
+   * Build event context for HTTP API
+   */
+  buildEventContext(context) {
+    const event = {};
+    if (this.options.environment) {
+      event.environment = this.options.environment;
+    }
+    if (this.options.release) {
+      event.release = this.options.release;
+    }
+    if (this.options.serverName) {
+      event.server_name = this.options.serverName;
+    }
+    const tags = { ...this.options.tags };
+    if (context?.tags) {
+      Object.assign(tags, context.tags);
+    }
+    if (context?.requestId) {
+      tags["requestId"] = context.requestId;
+    }
+    if (context?.tenantId) {
+      tags["tenantId"] = context.tenantId;
+    }
+    if (Object.keys(tags).length > 0) {
+      event.tags = tags;
+    }
+    if (context?.extra) {
+      event.extra = context.extra;
+    }
+    if (this.user) {
+      event.user = this.user;
+    } else if (context?.userId) {
+      event.user = { id: context.userId };
+    }
+    if (this.breadcrumbs.length > 0) {
+      event.breadcrumbs = this.breadcrumbs.map((bc) => {
+        const crumb = {};
+        if (bc.type) crumb.type = bc.type;
+        if (bc.category) crumb.category = bc.category;
+        if (bc.message) crumb.message = bc.message;
+        if (bc.data) crumb.data = bc.data;
+        if (bc.level) crumb.level = bc.level;
+        if (bc.timestamp !== void 0) crumb.timestamp = bc.timestamp;
+        return crumb;
+      });
+    }
+    if (this.contexts.size > 0) {
+      event.contexts = Object.fromEntries(this.contexts);
+    }
+    return event;
+  }
+  /**
+   * Parse error stack trace into Sentry format
+   */
+  parseStackTrace(stack) {
+    if (!stack) return void 0;
+    const lines = stack.split("\n").slice(1);
+    const frames = [];
+    for (const line of lines) {
+      const match = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+      if (match && match[3] && match[4]) {
+        const frame = {
+          function: match[1] || "<anonymous>",
+          lineno: parseInt(match[3], 10),
+          colno: parseInt(match[4], 10)
+        };
+        if (match[2]) {
+          frame.filename = match[2];
+        }
+        frames.push(frame);
+      }
+    }
+    frames.reverse();
+    return frames.length > 0 ? { frames } : void 0;
+  }
+  /**
+   * Generate event ID
+   */
+  generateEventId() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Send event via HTTP API
+   */
+  async sendHttpEvent(eventData) {
+    if (!this.dsn) return;
+    const event = {
+      event_id: this.generateEventId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: "javascript",
+      level: "error",
+      ...eventData
+    };
+    if (this.options.beforeSend) {
+      const result = this.options.beforeSend(event);
+      if (result === null) return;
+    }
+    const url = `${this.dsn.protocol}://${this.dsn.host}/api/${this.dsn.projectId}/store/`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentry-Auth": [
+            "Sentry sentry_version=7",
+            `sentry_client=pars-sentry/1.0.0`,
+            `sentry_key=${this.dsn.publicKey}`
+          ].join(", ")
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        throw new Error(`Sentry API error: ${response.status}`);
+      }
+    } catch (error) {
+      if (this.options.onError) {
+        this.options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+};
+function createSentryTransport(options) {
+  return new SentryTransport(options);
+}
+
+// src/transports/logtape.ts
+var FallbackLogger = class {
+  constructor(category) {
+    this.category = category;
+  }
+  log(level, message, properties) {
+    const entry = {
+      level,
+      category: this.category,
+      msg: message,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      ...properties
+    };
+    console.log(JSON.stringify(entry));
+  }
+  debug(message, properties) {
+    this.log("debug", message, properties);
+  }
+  info(message, properties) {
+    this.log("info", message, properties);
+  }
+  warn(message, properties) {
+    this.log("warn", message, properties);
+  }
+  warning(message, properties) {
+    this.log("warning", message, properties);
+  }
+  error(message, properties) {
+    this.log("error", message, properties);
+  }
+  fatal(message, properties) {
+    this.log("fatal", message, properties);
+  }
+};
+var LogtapeTransport = class {
+  name = "logtape";
+  logger;
+  includeTimestamp;
+  includeLevelValue;
+  enabled;
+  constructor(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.includeTimestamp = options.includeTimestamp !== false;
+    this.includeLevelValue = options.includeLevelValue ?? false;
+    if (options.logger) {
+      this.logger = options.logger;
+    } else {
+      this.logger = new FallbackLogger(options.category ?? "pars");
+    }
+  }
+  log(entry) {
+    if (!this.enabled) return;
+    const level = this.mapLevel(entry.level);
+    const properties = this.buildProperties(entry);
+    this.logger[level](entry.message, properties);
+  }
+  /**
+   * Map Pars log level to Logtape level
+   */
+  mapLevel(level) {
+    const mapping = {
+      TRACE: "debug",
+      DEBUG: "debug",
+      INFO: "info",
+      WARN: "warning",
+      ERROR: "error",
+      FATAL: "fatal",
+      SILENT: "debug"
+      // Should never be logged
+    };
+    return mapping[level];
+  }
+  /**
+   * Build properties object for Logtape
+   */
+  buildProperties(entry) {
+    const properties = {};
+    if (this.includeTimestamp) {
+      properties["timestamp"] = entry.timestamp;
+    }
+    if (this.includeLevelValue) {
+      properties["levelValue"] = entry.levelValue;
+    }
+    if (entry.context) {
+      Object.assign(properties, entry.context);
+    }
+    if (entry.error) {
+      properties["error"] = {
+        name: entry.error.name,
+        message: entry.error.message,
+        stack: entry.error.stack
+      };
+    }
+    return properties;
+  }
+};
+function createLogtapeTransport(options) {
+  return new LogtapeTransport(options);
+}
+
+// src/index.ts
+async function generateRandomString(length) {
+  const bytes = new Uint8Array(length);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateId() {
+  return crypto.randomUUID();
+}
+async function sha256(input) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(input);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Bytes(input) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(input);
+  return crypto.subtle.digest("SHA-256", data);
+}
+function constantTimeEquals(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  const aBytes = new TextEncoder().encode(a);
+  const bBytes = new TextEncoder().encode(b);
+  let result = 0;
+  for (let i = 0; i < aBytes.length; i++) {
+    result |= aBytes[i] ^ bBytes[i];
+  }
+  return result === 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelayMs = 1e3,
+    maxDelayMs = 3e4,
+    backoffMultiplier = 2,
+    shouldRetry = () => true,
+    onRetry
+  } = options;
+  let lastError;
+  let delay = initialDelayMs;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries || !shouldRetry(error)) {
+        throw error;
+      }
+      onRetry?.(error, attempt + 1);
+      await sleep(delay);
+      delay = Math.min(delay * backoffMultiplier, maxDelayMs);
+    }
+  }
+  throw lastError;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(deepClone);
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    cloned[key] = deepClone(obj[key]);
+  }
+  return cloned;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isNil(value) {
+  return value === null || value === void 0;
+}
+function isEmpty(value) {
+  if (isNil(value)) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function normalizeEmail(email) {
+  return email.toLowerCase().trim();
+}
+function isValidEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function slugify(str) {
+  return str.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+function debounce(fn, wait) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, wait);
+  };
+}
+function throttle(fn, wait) {
+  let lastTime = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastTime >= wait) {
+      lastTime = now;
+      fn(...args);
+    }
+  };
+}
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+async function pLimit(tasks, concurrency) {
+  const results = [];
+  const executing = [];
+  for (const [index, task] of tasks.entries()) {
+    const p = Promise.resolve().then(async () => {
+      results[index] = await task();
+    });
+    executing.push(p);
+    if (executing.length >= concurrency) {
+      await Promise.race(executing);
+      executing.splice(
+        executing.findIndex((e) => e === p),
+        1
+      );
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+export {
+  AccountLockedError,
+  AuthError,
+  AxiomTransport,
+  ConflictError,
+  ConsoleTransport,
+  Decimal,
+  DecimalUtils,
+  DuplicateError,
+  ErrorCodes,
+  ForbiddenError,
+  InvalidCredentialsError,
+  LogLevel,
+  Logger,
+  LogtapeTransport,
+  MembershipError,
+  MembershipExpiredError,
+  MembershipNotFoundError,
+  NotFoundError,
+  ParsError,
+  RateLimitError,
+  SentryTransport,
+  SessionExpiredError,
+  TenantError,
+  TenantNotFoundError,
+  TenantSuspendedError,
+  TwoFactorRequiredError,
+  UnauthorizedError,
+  ValidationError,
+  clearEdgeEnv,
+  constantTimeEquals,
+  createAxiomTransport,
+  createDeferred,
+  createEnvConfig,
+  createLogger,
+  createLogtapeTransport,
+  createRequestLogger,
+  createSentryTransport,
+  debounce,
+  decimal,
+  deepClone,
+  deepMerge,
+  detectRuntime,
+  err,
+  generateId,
+  generateRandomString,
+  getEnv,
+  getEnvArray,
+  getEnvBoolean,
+  getEnvFloat,
+  getEnvJson,
+  getEnvMode,
+  getEnvNumber,
+  getErrorCode,
+  getErrorCodesByCategory,
+  getRuntimeVersion,
+  getStatusForCode,
+  isBrowser,
+  isBun,
+  isCloudflare,
+  isDeno,
+  isDevelopment,
+  isEdge,
+  isEmpty,
+  isNil,
+  isNode,
+  isPlainObject,
+  isProduction,
+  isRetryableError,
+  isServer,
+  isTest,
+  isValidEmail,
+  logError,
+  logger,
+  measureTime,
+  normalizeEmail,
+  ok,
+  omit,
+  pLimit,
+  pick,
+  requireEnv,
+  retry,
+  runtime,
+  runtimeInfo,
+  setEdgeEnv,
+  sha256,
+  sha256Bytes,
+  sleep,
+  slugify,
+  throttle,
+  truncate
+};
+//# sourceMappingURL=index.js.map