@seekprotocol/game 0.0.0-stage → 0.1.0

package/seek-game.js

@@ -0,0 +1,982 @@
+// @seekprotocol/game: the Seek GameKit bridge. Generated by packages/game/bundle.mjs; do not edit.
+
+// src/diagnostics.ts
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+var isLogLevel = (v) => typeof v === "string" && LOG_LEVELS.includes(v);
+var HOST_EVENTS = ["no_ready", "hang", "render_gone", "load_failed"];
+var isHostEvent = (v) => typeof v === "string" && HOST_EVENTS.includes(v);
+var HOST_READY_TIMEOUT_MS = 1e4;
+var HOST_HANG_MS = 3e4;
+var HOST_EVENT_TEXT = {
+  no_ready: "The game did not call ready() within 10 seconds.",
+  hang: "The game sent no heartbeat for 30 seconds while it was in the foreground.",
+  render_gone: "The WebView process running the game died.",
+  load_failed: "The game page failed to load."
+};
+var END_REASONS = ["exit", "pagehide", "closed", "host_exit", ...HOST_EVENTS];
+var ERROR_SOURCES = ["error", "unhandledrejection", "console", "manual"];
+var isFatalSource = (s) => s === "error" || s === "unhandledrejection";
+var DIAG_LIMITS = {
+  /** Characters of a message (log or error). */
+  message: 500,
+  /** Characters of a stack, after scrubbing. */
+  stack: 4e3,
+  /** Stack frames kept. */
+  frames: 20,
+  /** Characters of a source file path. */
+  file: 200,
+  /** UTF-8 bytes of a log's data as JSON. */
+  data: 2048,
+  /** Characters of a host event's detail. */
+  detail: 200,
+  /** Entries in one batch. */
+  batchEntries: 50,
+  /** UTF-8 bytes of one batch as JSON (the proxy reads at most 64 KB). */
+  batchBytes: 48 * 1024,
+  /** Error entries per session; the proxy keeps the same limit. */
+  sessionErrors: 100,
+  /** Log entries per session. */
+  sessionLogs: 1e3,
+  /** One error entry stands for at most this many identical errors. */
+  repeat: 1e3
+};
+var DIAG_BODY_MAX_BYTES = 64 * 1024;
+var PERF_RANGES = { fps: [0, 240], jank: [0, 1e5], heap_mb: [0, 65536], ready_ms: [0, 6e5] };
+var DEVICE_CLASSES = ["phone", "tablet", "desktop", "unknown"];
+var OS_NAMES = ["ios", "android", "web", "unknown"];
+var OS_VERSION = /^\d{1,3}(?:\.\d{1,3}){0,2}$/;
+var APP_VERSION = /^(?:\d{1,3}\.\d{1,3}\.\d{1,4}|simulator)$/;
+function launchContextProblem(c) {
+  if (!c || typeof c !== "object" || Array.isArray(c)) return "ctx is an object.";
+  const x = c;
+  for (const k of Object.keys(x)) if (!["device", "os", "os_version", "app_version"].includes(k)) return `ctx has no field ${k}.`;
+  if (!DEVICE_CLASSES.includes(x.device)) return "ctx.device is phone, tablet, desktop or unknown.";
+  if (!OS_NAMES.includes(x.os)) return "ctx.os is ios, android, web or unknown.";
+  if (x.os_version !== void 0 && (typeof x.os_version !== "string" || !OS_VERSION.test(x.os_version))) return "ctx.os_version is digits and dots.";
+  if (x.app_version !== void 0 && (typeof x.app_version !== "string" || !APP_VERSION.test(x.app_version))) return "ctx.app_version is x.y.z or simulator.";
+  return null;
+}
+function normaliseContext(c) {
+  const x = c && typeof c === "object" ? c : {};
+  return {
+    device: DEVICE_CLASSES.includes(x.device) ? x.device : "unknown",
+    os: OS_NAMES.includes(x.os) ? x.os : "unknown",
+    os_version: typeof x.os_version === "string" && OS_VERSION.test(x.os_version) ? x.os_version : null,
+    app_version: typeof x.app_version === "string" && APP_VERSION.test(x.app_version) ? x.app_version : null
+  };
+}
+var SCRUBS = [
+  // A URL keeps its path but loses its query and fragment: those carry ids, tokens and positions.
+  [/\b((?:https?|wss?):\/\/[^\s?#"'<>`]*)[?#][^\s"'<>`)]*/gi, "$1?[query]"],
+  // Bearer and basic credentials.
+  [/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 [token]"],
+  // JWTs and JWS: three base64url parts, the first starting like a JSON header.
+  [/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/g, "[token]"],
+  // Emails.
+  [/[A-Za-z0-9._%+-]{1,64}@[A-Za-z0-9.-]{1,253}\.[A-Za-z]{2,24}/g, "[email]"],
+  // key=value and "key": "value" where the key names a secret.
+  [/((?<![A-Za-z])(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password|passwd|pwd|auth|authorization|session|cookie|sig|signature)["']?\s*[:=]\s*["']?)(?!(?:bearer|basic)\b|\[)[^\s"'&,;}]{4,}/gi, "$1[secret]"],
+  // A latitude, longitude pair: two decimals with at least three places, in range.
+  [/(?<![\d.])-?(?:[1-8]?\d(?:\.\d{3,})|90\.0{3,})\s*[,;/ ]\s*-?(?:1[0-7]\d|0?\d?\d)\.\d{3,}(?![\d.])/g, "[location]"],
+  // Long opaque strings: 24 or more base64url or hex characters with letters and digits mixed in.
+  [/(?<![A-Za-z0-9_-])(?=[A-Za-z0-9_-]{24,})(?=[A-Za-z_-]*\d)(?=[0-9_-]*[A-Za-z])[A-Za-z0-9_-]{24,}(?![A-Za-z0-9_-])/g, "[key]"],
+  // Long digit runs (phone, card and account numbers, timestamps), with spaces or dashes inside.
+  [/(?<![\d.])\+?\d(?:[\s-]?\d){6,}(?![\d.])/g, "[number]"]
+];
+function scrubText(s, extra = []) {
+  let out = s;
+  for (const secret of extra) if (secret && secret.length >= 8) out = out.split(secret).join("[token]");
+  for (const [re, to] of SCRUBS) out = out.replace(re, to);
+  return out;
+}
+var SECRET_KEY = /^(?:.*(?:token|secret|password|passwd|pwd|auth|cookie|session|signature|apikey|api_key|email|phone|wallet|address)|lat|lng|lon|long|latitude|longitude|coords?|position|location|ip)$/i;
+function scrubData(value, extra = [], depth = 0) {
+  if (depth > 6) return "[deep]";
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") return scrubText(value.length > DIAG_LIMITS.message ? value.slice(0, DIAG_LIMITS.message) : value, extra);
+  if (Array.isArray(value)) return value.slice(0, 50).map((v) => scrubData(v, extra, depth + 1));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value).slice(0, 50)) {
+      const key = scrubText(k.slice(0, 64), extra);
+      out[key] = SECRET_KEY.test(k) ? "[removed]" : scrubData(v, extra, depth + 1);
+    }
+    return out;
+  }
+  return null;
+}
+function boundData(value, extra = []) {
+  if (value === void 0) return void 0;
+  const clean = scrubData(value, extra);
+  let bytes = Infinity;
+  try {
+    bytes = new TextEncoder().encode(JSON.stringify(clean)).byteLength;
+  } catch {
+    return { truncated: true };
+  }
+  return bytes > DIAG_LIMITS.data ? { truncated: true, bytes } : clean;
+}
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+function shortenGameUrls(s) {
+  return s.replace(
+    /https:\/\/[a-z0-9][a-z0-9-]{1,28}[a-z0-9]-[0-9a-f]{16}\.play\.seekprotocol\.ai(?:\/@[0-9a-f]{64})?(\/[^\s?#"'()<>`]*)([?#][^\s"'()<>`]*?)?(?=:\d+:\d+|[\s"'()<>`]|$)/g,
+    (_m, path, query) => `${path}${query ? "?[query]" : ""}`
+  );
+}
+var CHROME_FRAME = /^\s*at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/;
+var GECKO_FRAME = /^\s*(.*?)@(.+?):(\d+):(\d+)\s*$/;
+function parseStack(stack) {
+  if (!stack) return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const m = CHROME_FRAME.exec(raw) ?? GECKO_FRAME.exec(raw);
+    if (!m) continue;
+    frames.push({ fn: (m[1] ?? "").trim(), file: m[2].trim(), line: Number(m[3]), col: Number(m[4]) });
+    if (frames.length >= DIAG_LIMITS.frames) break;
+  }
+  return frames;
+}
+function normaliseMessage(message) {
+  return message.replace(/\[(?:email|token|key|secret|location|number|query)\]/g, "<x>").replace(/(["'`])(?:(?!\1).){0,200}\1/g, "<s>").replace(/\b0x[0-9a-f]+\b/gi, "<n>").replace(/\b[0-9a-f]{8,}\b/gi, "<n>").replace(/-?\d+(?:\.\d+)?/g, "<n>").replace(/\s+/g, " ").trim().toLowerCase().slice(0, 300);
+}
+var FINGERPRINT_FRAMES = 3;
+var frameKey = (f) => `${shortenGameUrls(f.file).replace(/[?#].*$/, "")}:${f.fn || `line ${f.line ?? "?"}`}`;
+var hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+async function sha256HexOf(s) {
+  return hex(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s)));
+}
+function fingerprintInput(kind, message, stack, file, line) {
+  const frames = parseStack(stack).slice(0, FINGERPRINT_FRAMES).map(frameKey);
+  if (!frames.length && file) frames.push(`${shortenGameUrls(file)}:line ${line ?? "?"}`);
+  return [kind, normaliseMessage(message), ...frames].join("\n");
+}
+async function fingerprint(kind, message, stack, file, line) {
+  return (await sha256HexOf(fingerprintInput(kind, message, stack, file, line))).slice(0, 32);
+}
+async function sessionIdOf(appId, runId) {
+  return (await sha256HexOf(`seek-diag-session:v1:${appId}:${runId.toLowerCase()}`)).slice(0, 32);
+}
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var txt = (v, max) => typeof v === "string" && v.length > 0 ? clip(v, max) : null;
+var int = (v, min, max) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? v : void 0;
+function parseDiagnosticsBatch(body, opts = { from: "game" }) {
+  if (!isObj(body) || !Array.isArray(body.entries)) return null;
+  const secrets = opts.secrets ?? [];
+  const out = { entries: [], invalid: 0, hostOnly: 0, dropped: int(body.dropped, 0, 1e6) ?? 0 };
+  const list = body.entries.slice(0, DIAG_LIMITS.batchEntries);
+  out.invalid += body.entries.length - list.length;
+  for (const e of list) {
+    const entry = cleanDiagnosticEntry(e, secrets);
+    if (!entry) out.invalid++;
+    else if (entry.kind === "host" && opts.from !== "host") out.hostOnly++;
+    else out.entries.push(entry);
+  }
+  return out;
+}
+function cleanDiagnosticEntry(e, secrets = []) {
+  if (!isObj(e)) return null;
+  const at = typeof e.at === "number" && Number.isFinite(e.at) ? Math.round(e.at) : NaN;
+  if (!Number.isFinite(at)) return null;
+  const scrub = (s, max) => clip(scrubText(shortenGameUrls(s), secrets), max);
+  switch (e.kind) {
+    case "heartbeat": {
+      const fps = int(e.fps, ...PERF_RANGES.fps);
+      const jank = int(e.jank, ...PERF_RANGES.jank);
+      const heap = int(e.heap_mb, ...PERF_RANGES.heap_mb);
+      return { kind: "heartbeat", at, ...fps !== void 0 ? { fps } : {}, ...jank !== void 0 ? { jank } : {}, ...heap !== void 0 ? { heap_mb: heap } : {} };
+    }
+    case "start": {
+      const ready = int(e.ready_ms, ...PERF_RANGES.ready_ms);
+      return { kind: "start", at, ...ready !== void 0 ? { ready_ms: ready } : {} };
+    }
+    case "end":
+      return END_REASONS.includes(e.reason) ? { kind: "end", at, reason: e.reason } : null;
+    case "host": {
+      if (!isHostEvent(e.event)) return null;
+      const detail = txt(e.detail, DIAG_LIMITS.detail);
+      return { kind: "host", at, event: e.event, ...detail ? { detail: scrub(detail, DIAG_LIMITS.detail) } : {} };
+    }
+    case "log": {
+      const message = txt(e.message, DIAG_LIMITS.message * 2);
+      if (!isLogLevel(e.level) || message === null) return null;
+      const data = e.data === void 0 ? void 0 : boundData(e.data, secrets);
+      return {
+        kind: "log",
+        at,
+        level: e.level,
+        message: scrub(message, DIAG_LIMITS.message),
+        ...data !== void 0 ? { data } : {},
+        source: e.source === "console" ? "console" : "log"
+      };
+    }
+    case "error": {
+      const message = txt(e.message, DIAG_LIMITS.message * 2) ?? "Unknown error";
+      if (!ERROR_SOURCES.includes(e.source)) return null;
+      const stack = txt(e.stack, DIAG_LIMITS.stack * 2);
+      const file = txt(e.file, DIAG_LIMITS.file * 2);
+      const line = int(e.line, 0, 1e7);
+      const col = int(e.col, 0, 1e7);
+      const count = int(e.count, 1, DIAG_LIMITS.repeat);
+      return {
+        kind: "error",
+        at,
+        source: e.source,
+        message: scrub(message, DIAG_LIMITS.message),
+        ...stack ? { stack: scrub(stack, DIAG_LIMITS.stack) } : {},
+        ...file ? { file: scrub(file, DIAG_LIMITS.file) } : {},
+        ...line !== void 0 ? { line } : {},
+        ...col !== void 0 ? { col } : {},
+        ...count !== void 0 && count > 1 ? { count } : {}
+      };
+    }
+    default:
+      return null;
+  }
+}
+var isCrashEntry = (e) => e.kind === "host" || e.kind === "error" && isFatalSource(e.source);
+function createHostWatchdog(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const setT = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearT = opts.clearTimer ?? ((t) => clearTimeout(t));
+  const readyMs = opts.readyTimeoutMs ?? HOST_READY_TIMEOUT_MS;
+  const hangMs = opts.hangMs ?? HOST_HANG_MS;
+  let timer = null;
+  let isReady = false;
+  let paused = false;
+  let done = false;
+  const arm = (ms, event) => {
+    if (timer !== null) clearT(timer);
+    timer = done || paused ? null : setT(() => report(event), ms);
+  };
+  const report = (event, detail) => {
+    if (done) return;
+    done = true;
+    if (timer !== null) clearT(timer);
+    timer = null;
+    opts.onCrash({ kind: "host", at: now(), event, ...detail ? { detail: clip(scrubText(detail), DIAG_LIMITS.detail) } : {} });
+  };
+  arm(readyMs, "no_ready");
+  return {
+    ready() {
+      if (!isReady && !done) {
+        isReady = true;
+        arm(hangMs, "hang");
+      }
+    },
+    beat() {
+      if (isReady && !done) arm(hangMs, "hang");
+    },
+    pause() {
+      paused = true;
+      if (timer !== null) clearT(timer);
+      timer = null;
+    },
+    resume() {
+      paused = false;
+      if (!done) arm(isReady ? hangMs : readyMs, isReady ? "hang" : "no_ready");
+    },
+    fail(event, detail) {
+      report(event, detail);
+    },
+    stop() {
+      done = true;
+      if (timer !== null) clearT(timer);
+      timer = null;
+    }
+  };
+}
+
+// src/protocol.ts
+var PROTOCOL = "seek-game";
+var PROTOCOL_VERSION = 1;
+var BRIDGE_VERSION = "0.1.0";
+var MAX_MESSAGE_BYTES = 96 * 1024;
+var STORAGE_MAX_BYTES = 64 * 1024;
+var STORAGE_KEY = /^[A-Za-z0-9_.-]{1,64}$/;
+var TRACK_EVENT = /^[a-z][a-z0-9_]{0,31}$/;
+var TRACK_PROP_KEY = /^[a-z][a-z0-9_]{0,31}$/;
+var TRACK_MAX_PROPS = 8;
+var TRACK_MAX_STRING = 64;
+var MAX_TOKEN_LENGTH = 4096;
+var PROXY_ORIGIN = "https://api.play.seekprotocol.ai";
+var DEFAULT_HOST_ORIGINS = ["https://storeconnect.seekprotocol.ai"];
+var utf8Bytes = (s) => new TextEncoder().encode(s).byteLength;
+function jsonBytes(value) {
+  try {
+    const s = JSON.stringify(value);
+    return s === void 0 ? Infinity : utf8Bytes(s);
+  } catch {
+    return Infinity;
+  }
+}
+function isJsonValue(v, depth = 0) {
+  if (depth > 32) return false;
+  if (v === null || typeof v === "string" || typeof v === "boolean") return true;
+  if (typeof v === "number") return Number.isFinite(v);
+  if (Array.isArray(v)) return v.every((x) => isJsonValue(x, depth + 1));
+  if (typeof v === "object") {
+    const proto = Object.getPrototypeOf(v);
+    return (proto === Object.prototype || proto === null) && Object.values(v).every((x) => isJsonValue(x, depth + 1));
+  }
+  return false;
+}
+var storageKeyProblem = (key) => typeof key === "string" && STORAGE_KEY.test(key) ? null : "A storage key is 1 to 64 letters, digits, dots, hyphens and underscores.";
+function trackProblem(event, props) {
+  if (typeof event !== "string" || !TRACK_EVENT.test(event)) return "An event name is 1 to 32 lowercase letters, digits and underscores, starting with a letter.";
+  if (props === void 0) return null;
+  if (!props || typeof props !== "object" || Array.isArray(props)) return "Props are an object.";
+  const entries = Object.entries(props);
+  if (entries.length > TRACK_MAX_PROPS) return `At most ${TRACK_MAX_PROPS} props.`;
+  for (const [k, v] of entries) {
+    if (!TRACK_PROP_KEY.test(k)) return `Prop "${k}": names are lowercase letters, digits and underscores.`;
+    if (typeof v === "string") {
+      if (v.length > TRACK_MAX_STRING) return `Prop "${k}": text is at most ${TRACK_MAX_STRING} characters.`;
+    } else if (typeof v === "number") {
+      if (!Number.isFinite(v)) return `Prop "${k}": numbers are finite.`;
+    } else if (typeof v !== "boolean") {
+      return `Prop "${k}": a prop is text, a number or true/false.`;
+    }
+  }
+  return null;
+}
+function finishProblem(r) {
+  const x = r;
+  if (!x || typeof x !== "object") return "finish takes { score, seconds }.";
+  if (typeof x.score !== "number" || !Number.isFinite(x.score) || x.score < 0 || x.score > 1e9) return "score is a number from 0 to 1,000,000,000.";
+  if (typeof x.seconds !== "number" || !Number.isFinite(x.seconds) || x.seconds < 0 || x.seconds > 86400) return "seconds is a number from 0 to 86,400.";
+  return null;
+}
+var isObj2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function parseHostMessage(data) {
+  let m = data;
+  if (typeof data === "string") {
+    if (data.length > MAX_MESSAGE_BYTES || utf8Bytes(data) > MAX_MESSAGE_BYTES) return null;
+    try {
+      m = JSON.parse(data);
+    } catch {
+      return null;
+    }
+  } else if (jsonBytes(data) > MAX_MESSAGE_BYTES) {
+    return null;
+  }
+  if (!isObj2(m) || m.seek !== PROTOCOL || m.v !== PROTOCOL_VERSION) return null;
+  if (typeof m.event === "string") {
+    return m.event === "pause" || m.event === "resume" || m.event === "exit" ? { seek: PROTOCOL, v: PROTOCOL_VERSION, event: m.event } : null;
+  }
+  if (typeof m.re !== "string" || m.re.length > 64 || typeof m.ok !== "boolean") return null;
+  if (m.ok) return { seek: PROTOCOL, v: PROTOCOL_VERSION, re: m.re, ok: true, payload: m.payload };
+  const e = isObj2(m.error) ? m.error : {};
+  return {
+    seek: PROTOCOL,
+    v: PROTOCOL_VERSION,
+    re: m.re,
+    ok: false,
+    error: { code: typeof e.code === "string" ? e.code.slice(0, 64) : "host_error", message: typeof e.message === "string" ? e.message.slice(0, 500) : "The host refused." }
+  };
+}
+function parseGameRequest(data) {
+  let m = data;
+  if (typeof data === "string") {
+    if (utf8Bytes(data) > MAX_MESSAGE_BYTES) return null;
+    try {
+      m = JSON.parse(data);
+    } catch {
+      return null;
+    }
+  } else if (jsonBytes(data) > MAX_MESSAGE_BYTES) {
+    return null;
+  }
+  if (!isObj2(m) || m.seek !== PROTOCOL || m.v !== PROTOCOL_VERSION || typeof m.id !== "string" || !m.id || m.id.length > 64) return null;
+  const types = ["ready", "finish", "storage.get", "storage.set", "storage.remove", "track", "heartbeat", "diagnostics"];
+  if (!types.includes(m.type)) return null;
+  const p = m.payload;
+  switch (m.type) {
+    case "finish":
+      if (finishProblem(p)) return null;
+      break;
+    case "storage.get":
+    case "storage.remove":
+      if (!isObj2(p) || storageKeyProblem(p.key)) return null;
+      break;
+    case "storage.set":
+      if (!isObj2(p) || storageKeyProblem(p.key) || !isJsonValue(p.value)) return null;
+      break;
+    case "track":
+      if (!isObj2(p) || trackProblem(p.event, p.props)) return null;
+      break;
+    case "heartbeat":
+      if (!isObj2(p) || p.ended !== void 0 && typeof p.ended !== "boolean") return null;
+      break;
+    case "diagnostics": {
+      const batch = parseDiagnosticsBatch(p, { from: "game" });
+      if (!batch || batch.hostOnly) return null;
+      return { seek: PROTOCOL, v: PROTOCOL_VERSION, id: m.id, type: "diagnostics", payload: { entries: batch.entries, ...batch.dropped ? { dropped: batch.dropped } : {} } };
+    }
+    case "ready":
+      break;
+  }
+  return { seek: PROTOCOL, v: PROTOCOL_VERSION, id: m.id, type: m.type, payload: p };
+}
+var fromB64url = (s) => {
+  const bin = atob(s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4));
+  return new TextDecoder().decode(Uint8Array.from(bin, (c) => c.charCodeAt(0)));
+};
+function decodeLaunchToken(token) {
+  if (typeof token !== "string" || token.length > MAX_TOKEN_LENGTH) return null;
+  const parts = token.split(".");
+  if (parts.length !== 3 || !parts.every((p) => /^[A-Za-z0-9_-]+$/.test(p))) return null;
+  let c;
+  try {
+    c = JSON.parse(fromB64url(parts[1]));
+  } catch {
+    return null;
+  }
+  if (!isObj2(c)) return null;
+  const { run, seed, lang, sub, game, version, exp } = c;
+  if (typeof run !== "string" || typeof sub !== "string" || typeof game !== "string" || typeof version !== "string" || typeof lang !== "string") return null;
+  if (typeof seed !== "number" || !Number.isSafeInteger(seed) || typeof exp !== "number") return null;
+  return { runId: run, seed, lang, sub, game, version, expiresAt: exp * 1e3 };
+}
+
+// src/collector.ts
+var PRE_READY_ENTRIES = 20;
+function createCollector(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const timers = opts.timers ?? {
+    setInterval: (fn, ms) => setInterval(fn, ms),
+    clearInterval: (t) => clearInterval(t)
+  };
+  const flushMs = Math.max(1e3, opts.flushMs ?? 5e3);
+  const heartbeatMs = Math.min(25e3, Math.max(5e3, opts.heartbeatMs ?? 1e4));
+  const rate = opts.rate ?? { perSecond: 5, burst: 30 };
+  const secrets = () => opts.secrets?.() ?? [];
+  let session = null;
+  let ended = false;
+  let queue = [];
+  let dropped = 0;
+  let droppedTotal = 0;
+  let sent = 0;
+  let batches = 0;
+  let seq = 0;
+  let errors = 0;
+  let logs = 0;
+  let tokens = rate.burst;
+  let lastRefill = now();
+  let flushTimer = null;
+  let beatTimer = null;
+  const drop = () => {
+    dropped++;
+    droppedTotal++;
+    return false;
+  };
+  const allow = () => {
+    const t = now();
+    tokens = Math.min(rate.burst, tokens + (t - lastRefill) / 1e3 * rate.perSecond);
+    lastRefill = t;
+    if (tokens < 1) return false;
+    tokens -= 1;
+    return true;
+  };
+  const push = (raw, limited = true) => {
+    if (ended) return false;
+    if (limited && !allow()) return drop();
+    const entry = cleanDiagnosticEntry(raw, secrets());
+    if (!entry) return drop();
+    if (!session && queue.length >= PRE_READY_ENTRIES) return drop();
+    queue.push(entry);
+    if (session && queue.length >= DIAG_LIMITS.batchEntries) void flush();
+    return true;
+  };
+  const bytes = (b) => new TextEncoder().encode(JSON.stringify(b)).byteLength;
+  async function flush(final = false) {
+    if (!session || !queue.length && !dropped) return;
+    const pending = queue;
+    queue = [];
+    while (pending.length || dropped) {
+      const batch = { session, seq: ++seq, entries: [], ...dropped ? { dropped } : {} };
+      dropped = 0;
+      while (pending.length && batch.entries.length < DIAG_LIMITS.batchEntries) {
+        batch.entries.push(pending[0]);
+        if (batch.entries.length > 1 && bytes(batch) > DIAG_LIMITS.batchBytes) {
+          batch.entries.pop();
+          break;
+        }
+        pending.shift();
+      }
+      batches++;
+      sent += batch.entries.length;
+      try {
+        await opts.send(batch, final && !pending.length);
+      } catch {
+      }
+    }
+  }
+  const collector = {
+    get session() {
+      return session;
+    },
+    get ended() {
+      return ended;
+    },
+    start(id, readyMs) {
+      if (session || ended) return;
+      session = id;
+      const start = cleanDiagnosticEntry({ kind: "start", at: now(), ...readyMs !== void 0 ? { ready_ms: readyMs } : {} });
+      queue.unshift(start ?? { kind: "start", at: now() });
+      void flush();
+      flushTimer = timers.setInterval(() => void flush(), flushMs);
+      beatTimer = timers.setInterval(() => {
+        if (ended) return;
+        let sample = {};
+        try {
+          sample = opts.sample?.() ?? {};
+        } catch {
+        }
+        queue.push(cleanDiagnosticEntry({ ...sample, kind: "heartbeat", at: now() }) ?? { kind: "heartbeat", at: now() });
+        try {
+          opts.beat?.(false);
+        } catch {
+        }
+      }, heartbeatMs);
+      try {
+        opts.beat?.(false);
+      } catch {
+      }
+    },
+    error(e) {
+      if (ended) return false;
+      if (errors >= DIAG_LIMITS.sessionErrors) return drop();
+      const entry = cleanDiagnosticEntry({ kind: "error", at: now(), ...e }, secrets());
+      if (!entry || entry.kind !== "error") return drop();
+      const same = queue.find((q) => q.kind === "error" && q.source === entry.source && q.message === entry.message && q.stack === entry.stack);
+      if (same && (same.count ?? 1) < DIAG_LIMITS.repeat) {
+        same.count = (same.count ?? 1) + 1;
+        return true;
+      }
+      if (!push(entry)) return false;
+      errors++;
+      return true;
+    },
+    log(level, message, data, source = "log") {
+      if (logs >= DIAG_LIMITS.sessionLogs) return drop();
+      if (!push({ kind: "log", at: now(), level, message: typeof message === "string" && message ? message : String(message || "(empty)"), ...data !== void 0 ? { data } : {}, source })) return false;
+      logs++;
+      return true;
+    },
+    async end(reason) {
+      if (ended) return;
+      if (session) queue.push({ kind: "end", at: now(), reason });
+      ended = true;
+      if (flushTimer !== null) timers.clearInterval(flushTimer);
+      if (beatTimer !== null) timers.clearInterval(beatTimer);
+      flushTimer = beatTimer = null;
+      try {
+        opts.beat?.(true);
+      } catch {
+      }
+      await flush(true);
+    },
+    flush,
+    stats: () => ({ sent, dropped: droppedTotal, errors, logs, batches })
+  };
+  return collector;
+}
+
+// src/perf.ts
+var JANK_FRAME_MS = 50;
+var PAUSE_MS = 1e3;
+function createPerfSampler(win) {
+  const raf = win.requestAnimationFrame?.bind(win);
+  const perf = win.performance;
+  let frames = 0;
+  let jank = 0;
+  let visibleMs = 0;
+  let last = null;
+  let id = null;
+  let stopped = false;
+  const tick = (t) => {
+    if (stopped) return;
+    if (last !== null && !win.document?.hidden) {
+      const gap = t - last;
+      if (gap < PAUSE_MS) {
+        frames++;
+        visibleMs += gap;
+        if (gap > JANK_FRAME_MS) jank++;
+      }
+    }
+    last = t;
+    id = raf(tick);
+  };
+  if (raf) id = raf(tick);
+  return {
+    sample() {
+      const out = {};
+      if (visibleMs >= 500) {
+        out.fps = Math.min(240, Math.round(frames * 1e3 / visibleMs));
+        out.jank = jank;
+      }
+      const heap = perf?.memory?.usedJSHeapSize;
+      if (typeof heap === "number" && Number.isFinite(heap) && heap > 0) out.heap_mb = Math.round(heap / (1024 * 1024));
+      frames = 0;
+      jank = 0;
+      visibleMs = 0;
+      return out;
+    },
+    sinceLoad() {
+      const now = perf?.now();
+      return typeof now === "number" && Number.isFinite(now) ? Math.round(now) : void 0;
+    },
+    stop() {
+      stopped = true;
+      if (id !== null) win.cancelAnimationFrame?.(id);
+    }
+  };
+}
+
+// src/bridge.ts
+var BridgeError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BridgeError";
+  }
+};
+var TRACK_PER_LAUNCH = 200;
+function createBridge(opts = {}) {
+  const win = opts.window ?? globalThis;
+  const hostOrigins = [...opts.hostOrigins ?? DEFAULT_HOST_ORIGINS];
+  const doFetch = opts.fetch ?? ((...a) => fetch(...a));
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  const native = typeof win.ReactNativeWebView?.postMessage === "function";
+  const parent = !native && win.parent && win.parent !== win ? win.parent : null;
+  let seq = 0;
+  let lockedOrigin = null;
+  let readyPromise = null;
+  let launchInfo = null;
+  let token = "";
+  let transport = "proxy";
+  let finished = false;
+  let tracked = 0;
+  let closed = false;
+  const pending = /* @__PURE__ */ new Map();
+  const handlers = { pause: /* @__PURE__ */ new Set(), resume: /* @__PURE__ */ new Set(), exit: /* @__PURE__ */ new Set() };
+  const vopts = opts.vitals === false ? null : opts.vitals ?? {};
+  let vitals = null;
+  const trusted = (e) => {
+    if (native) return e.source === null || e.source === void 0;
+    if (!parent || e.source !== parent) return false;
+    return lockedOrigin ? e.origin === lockedOrigin : hostOrigins.includes(e.origin);
+  };
+  const onMessage = (e) => {
+    if (closed || !trusted(e)) return;
+    const m = parseHostMessage(e.data);
+    if (!m) return;
+    if ("event" in m) {
+      if (m.event === "exit") void vitals?.end("host_exit");
+      for (const fn of handlers[m.event]) {
+        try {
+          fn();
+        } catch {
+        }
+      }
+      return;
+    }
+    const p = pending.get(m.re);
+    if (!p) return;
+    if (!native && !lockedOrigin) lockedOrigin = e.origin;
+    pending.delete(m.re);
+    clearTimeout(p.timer);
+    if (m.ok) p.resolve(m.payload);
+    else p.reject(new BridgeError(m.error.code, m.error.message));
+  };
+  win.addEventListener("message", onMessage);
+  if (native) win.document?.addEventListener("message", onMessage);
+  function post(type, payload, wait = true, ms = timeoutMs) {
+    if (closed) return Promise.reject(new BridgeError("closed", "The bridge is closed."));
+    if (!native && !parent) return Promise.reject(new BridgeError("no_host", "Not running inside Seek or the simulator."));
+    const msg = { seek: PROTOCOL, v: PROTOCOL_VERSION, id: `g${++seq}-${Math.random().toString(36).slice(2, 10)}`, type, payload };
+    const json = JSON.stringify(msg);
+    if (utf8Bytes(json) > MAX_MESSAGE_BYTES) return Promise.reject(new BridgeError("too_big", `A message is at most ${MAX_MESSAGE_BYTES} bytes.`));
+    const sent = new Promise((resolve, reject) => {
+      if (!wait) return resolve(void 0);
+      const timer = setTimeout(() => {
+        pending.delete(msg.id);
+        reject(new BridgeError("timeout", `The host did not answer ${type}.`));
+      }, ms);
+      pending.set(msg.id, { resolve, reject, timer });
+    });
+    if (native) win.ReactNativeWebView.postMessage(json);
+    else if (lockedOrigin) parent.postMessage(msg, lockedOrigin);
+    else for (const origin of hostOrigins) parent.postMessage(msg, origin);
+    return sent;
+  }
+  const needLaunch = () => {
+    if (!launchInfo) throw new BridgeError("not_ready", "Call ready() first.");
+    return launchInfo;
+  };
+  async function proxy(method, path, body) {
+    let res;
+    try {
+      res = await doFetch(`${PROXY_ORIGIN}${path}`, {
+        method,
+        headers: { authorization: `Bearer ${token}`, ...body !== void 0 ? { "content-type": "application/json" } : {} },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+        credentials: "omit",
+        mode: "cors",
+        ...method === "POST" ? { keepalive: true } : {}
+      });
+    } catch {
+      throw new BridgeError("offline", "Could not reach Seek.");
+    }
+    let data = {};
+    try {
+      data = await res.json();
+    } catch {
+    }
+    if (!res.ok) throw new BridgeError(typeof data.error === "string" ? data.error : `http_${res.status}`, typeof data.message === "string" ? data.message : "Seek refused.");
+    return data;
+  }
+  const sendBatch = (batch) => transport === "host" ? post("diagnostics", batch, false) : proxy("POST", "/v1/diagnostics", batch);
+  const perf = vopts && vopts.performance !== false ? createPerfSampler(win) : null;
+  if (vopts) {
+    vitals = createCollector({
+      ...perf ? { sample: () => perf.sample() } : {},
+      send: (batch) => sendBatch(batch),
+      beat: (ended) => {
+        if (!closed) post("heartbeat", ended ? { ended: true } : {}, false).catch(() => void 0);
+      },
+      secrets: () => token ? [token] : [],
+      ...vopts.now ? { now: vopts.now } : {},
+      ...vopts.timers ? { timers: vopts.timers } : {},
+      ...vopts.heartbeatSeconds ? { heartbeatMs: vopts.heartbeatSeconds * 1e3 } : {},
+      ...vopts.flushSeconds ? { flushMs: vopts.flushSeconds * 1e3 } : {}
+    });
+  }
+  const errorOf = (v) => {
+    if (v && typeof v === "object" && typeof v.message === "string") {
+      const e = v;
+      return { message: `${e.name && e.name !== "Error" ? `${e.name}: ` : ""}${e.message || "Error"}`, ...typeof e.stack === "string" ? { stack: e.stack } : {} };
+    }
+    if (typeof v === "string") return { message: v || "Error" };
+    try {
+      return { message: JSON.stringify(v)?.slice(0, 500) ?? String(v) };
+    } catch {
+      return { message: String(v) };
+    }
+  };
+  const onError = (e) => {
+    if (!vitals || !e || "data" in e || typeof e.message !== "string") return;
+    const err = e.error ? errorOf(e.error) : { message: e.message || "Script error" };
+    vitals.error({
+      source: "error",
+      message: err.message || e.message,
+      ...err.stack ? { stack: err.stack } : {},
+      ...typeof e.filename === "string" && e.filename ? { file: e.filename } : {},
+      ...Number.isInteger(e.lineno) ? { line: e.lineno } : {},
+      ...Number.isInteger(e.colno) ? { col: e.colno } : {}
+    });
+  };
+  const onRejection = (e) => {
+    if (!vitals || !e || "data" in e || !("reason" in e)) return;
+    const err = errorOf(e.reason);
+    vitals.error({ source: "unhandledrejection", message: `Unhandled rejection: ${err.message}`, ...err.stack ? { stack: err.stack } : {} });
+  };
+  const onPageHide = (e) => {
+    if (!vitals || !e || "data" in e || e.type !== "pagehide") return;
+    void vitals.end("pagehide");
+  };
+  if (vitals && vopts?.errors !== false) {
+    win.addEventListener("error", onError);
+    win.addEventListener("unhandledrejection", onRejection);
+  }
+  if (vitals) win.addEventListener("pagehide", onPageHide);
+  const restoreConsole = [];
+  if (vitals && vopts?.console) {
+    const target = vopts.consoleObject ?? globalThis.console;
+    const wanted = new Set(vopts.console === true ? LOG_LEVELS : vopts.console.filter(isLogLevel));
+    const levelOf = { debug: "debug", log: "info", info: "info", warn: "warn", error: "error" };
+    let inside = false;
+    for (const method of Object.keys(levelOf)) {
+      const original = target?.[method];
+      if (!target || typeof original !== "function" || !wanted.has(levelOf[method])) continue;
+      target[method] = (...args) => {
+        original.apply(target, args);
+        if (inside) return;
+        inside = true;
+        try {
+          const parts = args.map((a) => typeof a === "string" ? a : errorOf(a).message);
+          const err = args.find((a) => a instanceof Error);
+          if (method === "error" && err) vitals.error({ source: "console", ...errorOf(err), message: parts.join(" ") });
+          else vitals.log(levelOf[method], parts.join(" "), void 0, "console");
+        } catch {
+        } finally {
+          inside = false;
+        }
+      };
+      restoreConsole.push(() => {
+        target[method] = original;
+      });
+    }
+  }
+  const bridge = {
+    ready() {
+      if (readyPromise) return readyPromise;
+      readyPromise = post("ready", { bridge: BRIDGE_VERSION, protocol: PROTOCOL_VERSION }).then((payload) => {
+        const p = payload;
+        const info = decodeLaunchToken(p?.token);
+        if (!info) throw new BridgeError("bad_launch", "The host sent no valid launch token.");
+        token = p.token;
+        transport = p.transport === "host" ? "host" : "proxy";
+        launchInfo = info;
+        if (vitals && !vitals.session) {
+          const readyMs = perf?.sinceLoad();
+          void sessionIdOf(info.game, info.runId).then((id) => vitals?.start(id, readyMs)).catch(() => void 0);
+        }
+        return info;
+      });
+      readyPromise.catch(() => {
+        readyPromise = null;
+      });
+      return readyPromise;
+    },
+    launch: () => ({ ...needLaunch() }),
+    async finish(result) {
+      needLaunch();
+      const problem = finishProblem(result);
+      if (problem) throw new BridgeError("bad_finish", problem);
+      if (finished) throw new BridgeError("already_finished", "A run is finished once.");
+      finished = true;
+      const answer = await post("finish", { score: result.score, seconds: result.seconds }, true, Math.max(timeoutMs, 3e4));
+      return { accepted: answer?.accepted === true };
+    },
+    storage: {
+      async get(key) {
+        needLaunch();
+        const problem = storageKeyProblem(key);
+        if (problem) throw new BridgeError("bad_key", problem);
+        const data = transport === "host" ? await post("storage.get", { key }) : await proxy("GET", `/v1/storage/${encodeURIComponent(key)}`);
+        return data?.value ?? null;
+      },
+      async set(key, value) {
+        needLaunch();
+        const problem = storageKeyProblem(key);
+        if (problem) throw new BridgeError("bad_key", problem);
+        if (!isJsonValue(value)) throw new BridgeError("bad_value", "Storage holds plain JSON: objects, arrays, text, finite numbers, true/false and null.");
+        if (jsonBytes(value) > STORAGE_MAX_BYTES) throw new BridgeError("storage_full", `A game keeps at most ${STORAGE_MAX_BYTES} bytes per player.`);
+        if (transport === "host") await post("storage.set", { key, value });
+        else await proxy("PUT", `/v1/storage/${encodeURIComponent(key)}`, { value });
+      },
+      async remove(key) {
+        needLaunch();
+        const problem = storageKeyProblem(key);
+        if (problem) throw new BridgeError("bad_key", problem);
+        if (transport === "host") await post("storage.remove", { key });
+        else await proxy("DELETE", `/v1/storage/${encodeURIComponent(key)}`);
+      }
+    },
+    track(event, props) {
+      if (!launchInfo || closed || tracked >= TRACK_PER_LAUNCH || trackProblem(event, props)) return false;
+      tracked++;
+      const body = { event, ...props ? { props } : {} };
+      const sent = transport === "host" ? post("track", body, false) : proxy("POST", "/v1/track", body);
+      sent.catch(() => {
+      });
+      return true;
+    },
+    log(level, message, data) {
+      if (!vitals || !isLogLevel(level)) return false;
+      return vitals.log(level, typeof message === "string" ? message : String(message), data);
+    },
+    async exit() {
+      await vitals?.end("exit");
+    },
+    sessionId: () => vitals?.session ?? null,
+    on(event, fn) {
+      handlers[event].add(fn);
+      return () => handlers[event].delete(fn);
+    },
+    close() {
+      if (closed) return;
+      void vitals?.end("closed");
+      perf?.stop();
+      closed = true;
+      win.removeEventListener("message", onMessage);
+      win.removeEventListener("error", onError);
+      win.removeEventListener("unhandledrejection", onRejection);
+      win.removeEventListener("pagehide", onPageHide);
+      for (const restore of restoreConsole) restore();
+      if (native) win.document?.removeEventListener("message", onMessage);
+      for (const [id, p] of pending) {
+        clearTimeout(p.timer);
+        p.reject(new BridgeError("closed", "The bridge is closed."));
+        pending.delete(id);
+      }
+    }
+  };
+  return bridge;
+}
+export {
+  BRIDGE_VERSION,
+  BridgeError,
+  DEFAULT_HOST_ORIGINS,
+  DEVICE_CLASSES,
+  DIAG_BODY_MAX_BYTES,
+  DIAG_LIMITS,
+  END_REASONS,
+  ERROR_SOURCES,
+  FINGERPRINT_FRAMES,
+  HOST_EVENTS,
+  HOST_EVENT_TEXT,
+  HOST_HANG_MS,
+  HOST_READY_TIMEOUT_MS,
+  JANK_FRAME_MS,
+  LOG_LEVELS,
+  MAX_MESSAGE_BYTES,
+  MAX_TOKEN_LENGTH,
+  OS_NAMES,
+  PERF_RANGES,
+  PRE_READY_ENTRIES,
+  PROTOCOL,
+  PROTOCOL_VERSION,
+  PROXY_ORIGIN,
+  STORAGE_KEY,
+  STORAGE_MAX_BYTES,
+  TRACK_EVENT,
+  TRACK_MAX_PROPS,
+  TRACK_MAX_STRING,
+  TRACK_PER_LAUNCH,
+  TRACK_PROP_KEY,
+  boundData,
+  cleanDiagnosticEntry,
+  createBridge,
+  createCollector,
+  createHostWatchdog,
+  createPerfSampler,
+  decodeLaunchToken,
+  fingerprint,
+  fingerprintInput,
+  finishProblem,
+  frameKey,
+  isCrashEntry,
+  isFatalSource,
+  isHostEvent,
+  isJsonValue,
+  isLogLevel,
+  jsonBytes,
+  launchContextProblem,
+  normaliseContext,
+  normaliseMessage,
+  parseDiagnosticsBatch,
+  parseGameRequest,
+  parseHostMessage,
+  parseStack,
+  scrubData,
+  scrubText,
+  sessionIdOf,
+  sha256HexOf,
+  shortenGameUrls,
+  storageKeyProblem,
+  trackProblem,
+  utf8Bytes
+};