scorezilla 0.1.0-next.0

package/dist/index.js

@@ -0,0 +1,680 @@
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.scorezilla.dev";
+var PUBLIC_KEY_PATTERN = /^pk_[a-z0-9-]+_[A-Za-z0-9]+$/;
+var SECRET_KEY_PREFIX = "sk_live_";
+function validateConfig(cfg) {
+  if (!cfg || typeof cfg !== "object") {
+    throw new Error("scorezilla: config must be an object with publicKey or secretKey");
+  }
+  const hasPublic = "publicKey" in cfg && cfg.publicKey !== void 0;
+  const hasSecret = "secretKey" in cfg && cfg.secretKey !== void 0;
+  if (hasPublic && hasSecret) {
+    throw new Error("scorezilla: config must not contain both publicKey and secretKey");
+  }
+  if (!hasPublic && !hasSecret) {
+    throw new Error("scorezilla: config must contain either publicKey or secretKey");
+  }
+  let auth;
+  if (hasPublic) {
+    const pk = cfg.publicKey;
+    if (typeof pk !== "string" || !PUBLIC_KEY_PATTERN.test(pk)) {
+      throw new Error(
+        `scorezilla: publicKey must match ${PUBLIC_KEY_PATTERN.toString()} (got: ${typeof pk === "string" ? pk.slice(0, 12) + "\u2026" : typeof pk})`
+      );
+    }
+    auth = { kind: "public", key: pk };
+  } else {
+    const sk = cfg.secretKey;
+    if (!sk || typeof sk !== "object" || typeof sk.id !== "string" || typeof sk.secret !== "string") {
+      throw new Error("scorezilla: secretKey must be an object with string `id` and `secret`");
+    }
+    if (!sk.secret.startsWith(SECRET_KEY_PREFIX)) {
+      throw new Error(
+        `scorezilla: secretKey.secret must start with "${SECRET_KEY_PREFIX}" (live keys only)`
+      );
+    }
+    auth = { kind: "secret", keyId: sk.id, secret: sk.secret };
+  }
+  const baseUrlRaw = cfg.baseUrl ?? DEFAULT_BASE_URL;
+  if (typeof baseUrlRaw !== "string" || baseUrlRaw.length === 0) {
+    throw new Error("scorezilla: baseUrl must be a non-empty string when provided");
+  }
+  return {
+    baseUrl: baseUrlRaw.replace(/\/+$/, ""),
+    fetch: cfg.fetch,
+    timeoutMs: cfg.timeoutMs,
+    maxRetries: cfg.maxRetries,
+    userAgent: cfg.userAgent,
+    auth
+  };
+}
+
+// src/paths.ts
+function encodeSegment(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`scorezilla: ${label} must be a non-empty string`);
+  }
+  return encodeURIComponent(value);
+}
+function buildQueryString(params) {
+  const usp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) usp.set(k, String(v));
+  }
+  const qs = usp.toString();
+  return qs.length > 0 ? `?${qs}` : "";
+}
+function submitScorePath(boardId) {
+  return `/v1/boards/${encodeSegment(boardId, "boardId")}/scores`;
+}
+function getLeaderboardPath(boardId, q) {
+  return `/v1/boards/${encodeSegment(boardId, "boardId")}/leaderboard` + buildQueryString({ top: q?.top, offset: q?.offset });
+}
+function getPlayerRankPath(boardId, playerId) {
+  return `/v1/boards/${encodeSegment(boardId, "boardId")}/players/${encodeSegment(playerId, "playerId")}/rank`;
+}
+function getWindowAroundPath(boardId, playerId, q) {
+  return `/v1/boards/${encodeSegment(boardId, "boardId")}/players/${encodeSegment(playerId, "playerId")}/window` + buildQueryString({ before: q?.before, after: q?.after });
+}
+
+// src/errors.ts
+var MESSAGE_MAX_CHARS = 500;
+var TRUNCATION_SUFFIX = "\u2026 [truncated]";
+var STATUS_NETWORK_ERROR = 0;
+function truncateMessage(raw) {
+  if (typeof raw !== "string") return "";
+  if (raw.length <= MESSAGE_MAX_CHARS) return raw;
+  const sliceEnd = Math.max(0, MESSAGE_MAX_CHARS - TRUNCATION_SUFFIX.length);
+  return raw.slice(0, sliceEnd) + TRUNCATION_SUFFIX;
+}
+var ScorezillaError = class _ScorezillaError extends Error {
+  /** HTTP status of the response, or {@link STATUS_NETWORK_ERROR} (0) for
+   *  network / abort / timeout. */
+  status;
+  /** Machine-stable error code from the API. Open union — see
+   *  {@link ScorezillaErrorCode}. For network errors, this is `'network_error'`;
+   *  for aborts, `'aborted'`; for timeouts, `'timeout'`. */
+  code;
+  /** Sub-classifier — present on `out_of_bounds` (`'below_min' | 'above_max'`)
+   *  and possibly other codes in future minor releases. */
+  reason;
+  /** Seconds — present on `rate_limited`. Honored by the transport's retry
+   *  policy (Step 2.4). */
+  retryAfter;
+  /** Server-issued request ID, lifted from the `X-Request-Id` response
+   *  header. Pass this to support when filing bugs. */
+  requestId;
+  /** The bound value crossed on `out_of_bounds`. */
+  bound;
+  /** Which rate-limit layer fired on `rate_limited`. */
+  layer;
+  /** The underlying cause (e.g., a `TypeError: fetch failed`) for
+   *  network/abort/timeout paths. `undefined` when the error came from a
+   *  successfully-parsed API error body. */
+  cause;
+  constructor(message, init) {
+    super(truncateMessage(message));
+    this.name = "ScorezillaError";
+    this.status = init.status;
+    this.code = init.code;
+    this.reason = init.reason;
+    this.retryAfter = init.retryAfter;
+    this.requestId = init.requestId;
+    this.bound = init.bound;
+    this.layer = init.layer;
+    this.cause = init.cause;
+    Object.setPrototypeOf(this, _ScorezillaError.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _ScorezillaError);
+    }
+  }
+  // ─── Sub-message helpers ─────────────────────────────────────────────
+  // Stable wrappers over the `code` discriminator so consumers can write
+  // `if (err.isRateLimited())` instead of memorizing the code spelling.
+  /** `true` when this error is a 429 / `rate_limited`. */
+  isRateLimited() {
+    return this.code === "rate_limited";
+  }
+  /** `true` when this error is a 401 / `unauthorized` (or 403 / `forbidden`). */
+  isAuth() {
+    return this.code === "unauthorized" || this.code === "forbidden";
+  }
+  /** `true` when this error is a 404 / `not_found`. */
+  isNotFound() {
+    return this.code === "not_found";
+  }
+  /** `true` when this error is a 422 / `out_of_bounds` (score below/above board limit). */
+  isOutOfBounds() {
+    return this.code === "out_of_bounds";
+  }
+  /** `true` for transient / retryable conditions: network errors, timeouts,
+   *  5xx, and 429. The transport layer relies on this for its retry policy. */
+  isTransient() {
+    if (this.status === STATUS_NETWORK_ERROR) return true;
+    if (this.status >= 500 && this.status < 600) return true;
+    return this.isRateLimited();
+  }
+  // ─── Factory ─────────────────────────────────────────────────────────
+  /**
+   * Build a `ScorezillaError` from a fetch round-trip outcome.
+   *
+   * Prefer this over `new ScorezillaError(...)` from the transport layer —
+   * it does the mapping from API response shape to error fields in one
+   * place, so future fields like `correlationId` get added once here.
+   *
+   * @param init - status, optional parsed body, optional requestId, optional cause
+   */
+  static from(init) {
+    const { status, body, requestId, cause } = init;
+    if (body && body.ok === false && typeof body.error === "string") {
+      return new _ScorezillaError(body.message ?? `Request failed: ${body.error}`, {
+        status,
+        code: body.error,
+        reason: body.reason,
+        retryAfter: body.retryAfter,
+        bound: body.bound,
+        layer: body.layer,
+        requestId,
+        cause
+      });
+    }
+    const code = codeForStatus(status);
+    return new _ScorezillaError(`Request failed with status ${status}`, {
+      status,
+      code,
+      requestId,
+      cause
+    });
+  }
+  /**
+   * Build a `ScorezillaError` for a transport-level failure (no HTTP
+   * response received): network error, abort, or timeout.
+   */
+  static network(message, cause) {
+    return new _ScorezillaError(message, {
+      status: STATUS_NETWORK_ERROR,
+      code: "network_error",
+      cause
+    });
+  }
+  /** Build a `ScorezillaError` for an `AbortSignal`-triggered cancellation. */
+  static aborted(cause) {
+    return new _ScorezillaError("Request aborted", {
+      status: STATUS_NETWORK_ERROR,
+      code: "aborted",
+      cause
+    });
+  }
+  /** Build a `ScorezillaError` for a request that exceeded its timeout budget. */
+  static timeout(timeoutMs) {
+    return new _ScorezillaError(`Request timed out after ${timeoutMs}ms`, {
+      status: STATUS_NETWORK_ERROR,
+      code: "timeout"
+    });
+  }
+};
+function codeForStatus(status) {
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "not_found";
+  if (status === 422) return "out_of_bounds";
+  if (status === 429) return "rate_limited";
+  if (status >= 500) return "internal_error";
+  if (status >= 400) return "invalid_input";
+  return "internal_error";
+}
+
+// src/retry.ts
+var DEFAULT_MAX_RETRIES = 2;
+var BASE_DELAY_MS = 200;
+var MAX_DELAY_MS = 4e3;
+var MAX_RETRY_AFTER_SEC = 30;
+function nextDelay(attempt, retryAfterSec, random = Math.random) {
+  if (typeof retryAfterSec === "number" && Number.isFinite(retryAfterSec) && retryAfterSec >= 0 && retryAfterSec <= MAX_RETRY_AFTER_SEC) {
+    return Math.round(retryAfterSec * 1e3);
+  }
+  const exponential = Math.min(BASE_DELAY_MS * 2 ** attempt, MAX_DELAY_MS);
+  const jitterFactor = 0.5 + random() * 0.5;
+  return Math.round(exponential * jitterFactor);
+}
+function shouldRetryStatus(status) {
+  if (status === 429) return true;
+  if (status >= 500 && status < 600) return true;
+  return false;
+}
+function shouldRetryError(err) {
+  if (err instanceof ScorezillaError) {
+    return err.code === "network_error";
+  }
+  return false;
+}
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (!c || typeof c.randomUUID !== "function") {
+    throw new Error(
+      "scorezilla: globalThis.crypto.randomUUID is unavailable. The SDK requires Node \u2265 20 or a modern browser. Check your runtime."
+    );
+  }
+  return c.randomUUID();
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/transport.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function request(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "scorezilla: globalThis.fetch is unavailable. Either upgrade your runtime (Node \u2265 20 has fetch built in) or pass `fetch: yourFetch` in the SDK config."
+    );
+  }
+  const url = buildUrl(opts.baseUrl, opts.path);
+  const maxRetries = opts.retry?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const random = opts.retry?.random ?? Math.random;
+  const sleepImpl = opts.retry?.sleepImpl ?? sleep;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error(
+      `scorezilla: timeoutMs must be a positive finite number (got ${String(timeoutMs)})`
+    );
+  }
+  const retrySleep = async (delay) => {
+    try {
+      await sleepImpl(delay, opts.signal);
+    } catch (cause) {
+      throw ScorezillaError.aborted(cause);
+    }
+  };
+  const idempotencyKey = opts.method === "POST" ? generateIdempotencyKey() : null;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const combined = combineSignalsWithTimeout(opts.signal, timeoutMs);
+    try {
+      const init = {
+        method: opts.method,
+        headers: buildHeaders(opts, idempotencyKey),
+        signal: combined.signal
+      };
+      if (opts.body !== void 0) {
+        init.body = JSON.stringify(opts.body);
+      }
+      const response = await fetchImpl(url, init);
+      combined.cleanup();
+      if (response.ok) {
+        return await parseJson(response);
+      }
+      const body = await safelyParseErrorBody(response);
+      const err = ScorezillaError.from({
+        status: response.status,
+        body,
+        requestId: response.headers.get("X-Request-Id") ?? void 0
+      });
+      if (shouldRetryStatus(response.status) && attempt < maxRetries) {
+        const retryAfter = readRetryAfter(response);
+        const delay = nextDelay(attempt, retryAfter, random);
+        await retrySleep(delay);
+        lastError = err;
+        continue;
+      }
+      throw err;
+    } catch (caught) {
+      combined.cleanup();
+      if (caught instanceof ScorezillaError) {
+        if (shouldRetryError(caught) && attempt < maxRetries) {
+          const delay = nextDelay(attempt, void 0, random);
+          await retrySleep(delay);
+          lastError = caught;
+          continue;
+        }
+        throw caught;
+      }
+      const mapped = mapTransportError(caught, opts.signal, timeoutMs, combined);
+      if (shouldRetryError(mapped) && attempt < maxRetries) {
+        const delay = nextDelay(attempt, void 0, random);
+        await retrySleep(delay);
+        lastError = mapped;
+        continue;
+      }
+      throw mapped;
+    }
+  }
+  throw lastError ?? new ScorezillaError("Request failed after retries", {
+    status: 0,
+    code: "internal_error"
+  });
+}
+function buildUrl(baseUrl, path) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return base + path;
+}
+function buildHeaders(opts, idempotencyKey) {
+  const headers = { Accept: "application/json" };
+  if (opts.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (idempotencyKey !== null) {
+    headers["Idempotency-Key"] = idempotencyKey;
+  }
+  if (opts.headers) {
+    for (const [k, v] of Object.entries(opts.headers)) headers[k] = v;
+  }
+  return headers;
+}
+async function parseJson(response) {
+  try {
+    return await response.json();
+  } catch (cause) {
+    throw new ScorezillaError("Response body was not valid JSON", {
+      status: response.status,
+      code: "invalid_json",
+      requestId: response.headers.get("X-Request-Id") ?? void 0,
+      cause
+    });
+  }
+}
+async function safelyParseErrorBody(response) {
+  try {
+    const json = await response.json();
+    if (json && typeof json === "object" && "ok" in json && json.ok === false) {
+      return json;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readRetryAfter(response) {
+  const raw = response.headers.get("Retry-After");
+  if (!raw) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function combineSignalsWithTimeout(caller, timeoutMs) {
+  const ctrl = new AbortController();
+  let didTimeOut = false;
+  if (caller?.aborted) {
+    ctrl.abort(caller.reason);
+    return { signal: ctrl.signal, cleanup: () => {
+    }, timedOut: () => false };
+  }
+  const onCallerAbort = () => {
+    ctrl.abort(caller?.reason);
+  };
+  caller?.addEventListener("abort", onCallerAbort, { once: true });
+  const timer = setTimeout(() => {
+    didTimeOut = true;
+    ctrl.abort(new DOMException(`Request timed out after ${timeoutMs}ms`, "TimeoutError"));
+  }, timeoutMs);
+  return {
+    signal: ctrl.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      caller?.removeEventListener("abort", onCallerAbort);
+    },
+    timedOut: () => didTimeOut
+  };
+}
+function mapTransportError(caught, callerSignal, timeoutMs, combined) {
+  if (callerSignal?.aborted) {
+    return ScorezillaError.aborted(callerSignal.reason ?? caught);
+  }
+  if (combined.timedOut()) {
+    return ScorezillaError.timeout(timeoutMs);
+  }
+  const message = caught instanceof Error ? caught.message : "Network request failed";
+  return ScorezillaError.network(message, caught);
+}
+
+// src/user-agent.ts
+function detectRuntime(g = globalThis) {
+  if (typeof g.Bun !== "undefined") return "bun";
+  if (typeof g.Deno !== "undefined") return "deno";
+  if (typeof g.navigator?.userAgent === "string" && g.navigator.userAgent.includes("Cloudflare-Workers")) {
+    return "workers";
+  }
+  if (typeof g.process?.versions?.node === "string") return "node";
+  if (typeof g.document !== "undefined") return "browser";
+  return "unknown";
+}
+function defaultUserAgent(version, runtime = detectRuntime()) {
+  return `scorezilla-js/${version} (${runtime})`;
+}
+
+// src/client.ts
+var METADATA_MAX_BYTES = 4096;
+function validateMetadata(metadata) {
+  if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
+    throw new Error(
+      "scorezilla: metadata must be a plain object (got " + (Array.isArray(metadata) ? "array" : typeof metadata) + ")"
+    );
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(metadata, (_key, value) => {
+      if (typeof value === "function") {
+        throw new Error("scorezilla: metadata may not contain functions");
+      }
+      if (typeof value === "symbol") {
+        throw new Error("scorezilla: metadata may not contain symbols");
+      }
+      if (typeof value === "bigint") {
+        throw new Error("scorezilla: metadata may not contain BigInt");
+      }
+      return value;
+    });
+  } catch (cause) {
+    if (cause instanceof Error) {
+      if (cause.message.startsWith("scorezilla:")) throw cause;
+      if (/circular|convert|cyclic/i.test(cause.message)) {
+        throw new Error("scorezilla: metadata contains circular references");
+      }
+    }
+    throw cause;
+  }
+  const byteLength = new TextEncoder().encode(serialized).length;
+  if (byteLength > METADATA_MAX_BYTES) {
+    throw new Error(
+      `scorezilla: metadata exceeds ${METADATA_MAX_BYTES} bytes (got ${byteLength} bytes when JSON-stringified)`
+    );
+  }
+}
+var Scorezilla = class _Scorezilla {
+  /** The package version, injected at build time from `package.json`. */
+  static version = "0.1.0-next.0";
+  #config;
+  #userAgent;
+  #authHeader;
+  /**
+   * @param config - public-key configuration. Passing `secretKey` throws —
+   *                 use the `scorezilla/server` adapter (v0.2.0) for HMAC.
+   */
+  constructor(config) {
+    const resolved = validateConfig(config);
+    if (resolved.auth.kind !== "public") {
+      throw new Error(
+        "scorezilla: the default `Scorezilla` client is public-key only. Secret-key (HMAC) auth ships in v0.2.0 via the `scorezilla/server` adapter \u2014 use that for server-side code; use `publicKey` for browser / public clients."
+      );
+    }
+    this.#config = resolved;
+    this.#userAgent = resolved.userAgent ?? defaultUserAgent(_Scorezilla.version);
+    this.#authHeader = `Bearer ${resolved.auth.key}`;
+  }
+  /**
+   * Submit a score to a board.
+   *
+   * Maps to `POST /v1/boards/:boardId/scores`. See [API.md](../API.md#submitscore)
+   * for the full contract.
+   *
+   * @example
+   * ```ts
+   * try {
+   *   const r = await sz.submitScore({ boardId, playerId: 'alice', score: 9001 });
+   *   if (r.isPersonalBest) console.log(`PB! Rank ${r.rank} of ${r.totalEntries}`);
+   * } catch (e) {
+   *   if (e instanceof ScorezillaError && e.code === 'out_of_bounds') {
+   *     console.warn(`Score outside board bounds (${e.reason}, limit ${e.bound})`);
+   *   } else throw e;
+   * }
+   * ```
+   *
+   * @throws {ScorezillaError} `unauthorized` (bad publicKey), `forbidden`
+   *   (key not bound to this board), `not_found` (board doesn't exist),
+   *   `out_of_bounds` (score outside board's min/max), `rate_limited`
+   *   (Layer 2/3 throttle hit), `invalid_input`, `network_error`, `timeout`.
+   * @since 0.1.0
+   * @stability stable
+   */
+  async submitScore(input) {
+    if (input.metadata !== void 0) {
+      validateMetadata(input.metadata);
+    }
+    const body = {
+      playerId: input.playerId,
+      score: input.score
+    };
+    if (input.metadata !== void 0) {
+      body.metadata = input.metadata;
+    }
+    return this.#request({
+      path: submitScorePath(input.boardId),
+      method: "POST",
+      body
+    });
+  }
+  /**
+   * Fetch the top-N leaderboard for a board.
+   *
+   * Maps to `GET /v1/boards/:boardId/leaderboard`.
+   *
+   * @example
+   * ```ts
+   * const { entries } = await sz.getLeaderboard({ boardId, top: 25 });
+   * for (const e of entries) console.log(`${e.rank}. ${e.playerId}: ${e.score}`);
+   * ```
+   *
+   * @throws {ScorezillaError} `not_found`, `network_error`, `timeout`.
+   * @since 0.1.0
+   * @stability stable
+   */
+  async getLeaderboard(input) {
+    const q = {};
+    if (input.top !== void 0) q.top = input.top;
+    if (input.offset !== void 0) q.offset = input.offset;
+    return this.#request({
+      path: getLeaderboardPath(input.boardId, q),
+      method: "GET"
+    });
+  }
+  /**
+   * Fetch a single player's rank on a board.
+   *
+   * Maps to `GET /v1/boards/:boardId/players/:playerId/rank`. Returns 404
+   * (`not_found`) if the player has no entry yet.
+   *
+   * @example
+   * ```ts
+   * try {
+   *   const { rank, score } = await sz.getPlayerRank({ boardId, playerId: 'alice' });
+   *   console.log(`Alice is rank ${rank} with score ${score}`);
+   * } catch (e) {
+   *   if (e instanceof ScorezillaError && e.isNotFound()) {
+   *     console.log('Alice has no submission on this board yet.');
+   *   } else throw e;
+   * }
+   * ```
+   *
+   * @throws {ScorezillaError} `not_found` (player has no submission),
+   *   `network_error`, `timeout`.
+   * @since 0.1.0
+   * @stability stable
+   */
+  async getPlayerRank(input) {
+    return this.#request({
+      path: getPlayerRankPath(input.boardId, input.playerId),
+      method: "GET"
+    });
+  }
+  /**
+   * Fetch the slice of entries surrounding a player.
+   *
+   * Maps to `GET /v1/boards/:boardId/players/:playerId/window?before=&after=`.
+   *
+   * @example
+   * ```ts
+   * const { entries } = await sz.getWindowAround({
+   *   boardId, playerId: 'alice', before: 2, after: 2,
+   * });
+   * ```
+   *
+   * @throws {ScorezillaError} `network_error`, `timeout`.
+   * @since 0.1.0
+   * @stability stable
+   */
+  async getWindowAround(input) {
+    const q = {};
+    if (input.before !== void 0) q.before = input.before;
+    if (input.after !== void 0) q.after = input.after;
+    return this.#request({
+      path: getWindowAroundPath(input.boardId, input.playerId, q),
+      method: "GET"
+    });
+  }
+  // ─── Internal ────────────────────────────────────────────────────────
+  /**
+   * Common request wiring — auth header, default fetch impl, timeout, retry.
+   * Each public method composes its `path`, `method`, and (optionally) `body`
+   * and hands them to this thin pass-through. Keeps the four method bodies
+   * boilerplate-free and ensures every call shares identical defaults.
+   */
+  async #request(opts) {
+    const headers = {
+      Authorization: this.#authHeader,
+      // User-Agent: ignored by browsers (per Fetch spec), useful in
+      // Node/Bun/Deno/Workers for server-side observability.
+      "User-Agent": this.#userAgent,
+      // X-Scorezilla-Client: browser-honored, mirrors the UA for telemetry
+      // parity across runtimes.
+      "X-Scorezilla-Client": this.#userAgent
+    };
+    const requestOpts = {
+      baseUrl: this.#config.baseUrl,
+      path: opts.path,
+      method: opts.method,
+      headers
+    };
+    if (opts.body !== void 0) requestOpts.body = opts.body;
+    if (this.#config.fetch !== void 0) requestOpts.fetchImpl = this.#config.fetch;
+    if (this.#config.timeoutMs !== void 0) requestOpts.timeoutMs = this.#config.timeoutMs;
+    if (this.#config.maxRetries !== void 0) {
+      requestOpts.retry = { maxRetries: this.#config.maxRetries };
+    }
+    return request(requestOpts);
+  }
+};
+function createClient(config) {
+  return new Scorezilla(config);
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.0-next.0";
+
+export { SDK_VERSION, Scorezilla, ScorezillaError, createClient, detectRuntime };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map