@bstage-sdk/analytics 0.0.0-stage → 0.9.0

package/dist/index.cjs

@@ -0,0 +1,1534 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ATTR_MAX: () => ATTR_MAX,
+  BATCH_MAX: () => BATCH_MAX,
+  BID_NAME: () => BID_NAME,
+  BODY_MAX: () => BODY_MAX,
+  CLICK_ATTR: () => CLICK_ATTR,
+  DEPTHS: () => DEPTHS,
+  EVENT_ATTR: () => EVENT_ATTR,
+  EVENT_MAX: () => EVENT_MAX,
+  FLUSH_WAIT: () => FLUSH_WAIT,
+  IDLE_MAX: () => IDLE_MAX,
+  IMPRESSION_OPT: () => IMPRESSION_OPT,
+  ITEM_ATTR: () => ITEM_ATTR,
+  ITEM_INDEX_ATTR: () => ITEM_INDEX_ATTR,
+  ITEM_NAME_ATTR: () => ITEM_NAME_ATTR,
+  LOG_PATH: () => LOG_PATH,
+  MASK_MAX: () => MASK_MAX,
+  MAX_AGE: () => MAX_AGE,
+  MAX_HELD: () => MAX_HELD,
+  NAME_MAX: () => NAME_MAX,
+  PARAM_LIMIT: () => PARAM_LIMIT,
+  PARAM_PREFIX: () => PARAM_PREFIX,
+  RESERVED: () => RESERVED,
+  RETRY_MAX: () => RETRY_MAX,
+  ROUTE_EVENT: () => ROUTE_EVENT,
+  SECTION_ATTR: () => SECTION_ATTR,
+  SID_NAME: () => SID_NAME,
+  TEXT_MAX: () => TEXT_MAX,
+  UTM_MAX: () => UTM_MAX,
+  VERSION: () => VERSION,
+  backoff: () => backoff,
+  checkName: () => checkName,
+  checkParams: () => checkParams,
+  destroy: () => destroy,
+  events: () => events,
+  flush: () => flush,
+  identify: () => identify,
+  ids: () => ids,
+  init: () => init,
+  logUrl: () => logUrl,
+  mask: () => mask,
+  queue: () => queue,
+  readEvent: () => readEvent,
+  readImpression: () => readImpression,
+  send: () => send,
+  setConsent: () => setConsent,
+  sizeOf: () => sizeOf,
+  trim: () => trim
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/batch.ts
+var BATCH_MAX = 20;
+var FLUSH_WAIT = 5e3;
+var Batch = class {
+  constructor(ship, size = BATCH_MAX, wait = FLUSH_WAIT) {
+    this.ship = ship;
+    this.size = size;
+    this.wait = wait;
+    this.buffer = [];
+    this.timer = null;
+  }
+  add(event) {
+    this.buffer.push(event);
+    if (this.buffer.length >= this.size) {
+      this.flush();
+      return;
+    }
+    if (this.timer === null) this.timer = setTimeout(() => this.flush(), this.wait);
+  }
+  flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length === 0) return;
+    const evts = this.buffer;
+    this.buffer = [];
+    this.ship(evts);
+  }
+  /** 대기 중인 이벤트. 육안 검증용이다 */
+  pending() {
+    return [...this.buffer];
+  }
+};
+
+// src/limits.ts
+var NAME_MAX = 40;
+var TEXT_MAX = 50;
+var ATTR_MAX = 200;
+var UTM_MAX = 100;
+var EVENT_MAX = 16 * 1024;
+var PARAM_LIMIT = {
+  keys: 25,
+  keyLength: 40,
+  valueLength: 500
+};
+function checkParams(params) {
+  const issues = [];
+  const keys = Object.keys(params);
+  if (keys.length > PARAM_LIMIT.keys) {
+    issues.push(`params key count ${keys.length} > ${PARAM_LIMIT.keys}`);
+  }
+  for (const key of keys) {
+    if (key.length > PARAM_LIMIT.keyLength) {
+      issues.push(`params key "${key}" length > ${PARAM_LIMIT.keyLength}`);
+    }
+    const value = params[key];
+    if (typeof value === "string" && value.length > PARAM_LIMIT.valueLength) {
+      issues.push(`params value of "${key}" length > ${PARAM_LIMIT.valueLength}`);
+    }
+  }
+  return issues;
+}
+function sizeOf(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value)).length;
+  } catch {
+    return null;
+  }
+}
+var clipped = /* @__PURE__ */ new Set();
+function clip(value, max, field) {
+  if (value.length <= max) return value;
+  if (!clipped.has(field)) {
+    clipped.add(field);
+    console.warn(`[bstage-analytics] E_ATTR_CLIPPED: "${field}" exceeds the ${max}-char limit`);
+  }
+  return value.slice(0, max);
+}
+var RESERVED = [
+  "page_view",
+  "click",
+  "impression",
+  "scroll_depth",
+  "runtime_error"
+];
+function isReserved(name) {
+  return typeof name === "string" && RESERVED.includes(name);
+}
+function checkName(name) {
+  if (typeof name !== "string") return false;
+  return name.length <= NAME_MAX && /^[a-z][a-z0-9_]*$/.test(name);
+}
+
+// src/mask.ts
+var MASK_MAX = 2e3;
+function mask(text) {
+  return text.slice(0, MASK_MAX).replace(
+    /([?&#](?:access_token|refresh_token|id_token|token|key|apikey|api_key|password|passwd|secret|code|auth|session|sig|signature|state|ticket|otp|invite)=)[^&\s#]+/gi,
+    "$1***"
+  ).replace(/\bBearer\s+[\w.-]+/gi, "Bearer ***").replace(/\beyJ[\w-]{6,}\.[\w-]+\.[\w-]+/g, "***").replace(/(\/\/)[^/@\s:]+:[^/@\s]+@/g, "$1***:***@");
+}
+function maskUrl(url) {
+  return url ? mask(url) : void 0;
+}
+
+// src/click.ts
+var CLICK_ATTR = "data-log-click";
+var SECTION_ATTR = "data-log-section";
+var EVENT_ATTR = "data-log-event";
+var PARAM_PREFIX = "data-log-param-";
+var TARGET = `a, button, [${CLICK_ATTR}], [${EVENT_ATTR}]`;
+function findTarget(event) {
+  for (const node of event.composedPath()) {
+    if (node instanceof Element && node.matches(TARGET)) return node;
+  }
+  const target = event.target;
+  return target instanceof Element ? target.closest(TARGET) : null;
+}
+function readClick(node, x, y) {
+  return {
+    tag: node.tagName.toLowerCase(),
+    id: node.id ? clip(node.id, ATTR_MAX, "click.id") : void 0,
+    text: readText(node),
+    href: node.tagName === "A" ? maskUrl(node.href) : void 0,
+    x,
+    y,
+    section: readSection(node)
+  };
+}
+function readSection(node) {
+  const section = node.closest(`[${SECTION_ATTR}]`)?.getAttribute(SECTION_ATTR);
+  return section ? clip(section, ATTR_MAX, SECTION_ATTR) : void 0;
+}
+function readEvent(node) {
+  const owner = node.closest(`[${EVENT_ATTR}]`);
+  const name = owner?.getAttribute(EVENT_ATTR)?.trim();
+  if (!owner || !name) return null;
+  return { name, params: readParams(owner) };
+}
+function readParams(owner) {
+  let params;
+  let count = 0;
+  for (const attr of owner.getAttributeNames()) {
+    if (!attr.startsWith(PARAM_PREFIX)) continue;
+    if (count >= PARAM_LIMIT.keys) break;
+    const key = toCamel(attr.slice(PARAM_PREFIX.length));
+    const value = owner.getAttribute(attr)?.trim();
+    if (!okKey(key) || !value) continue;
+    params = { ...params, [key]: clip(mask(value), ATTR_MAX, PARAM_PREFIX) };
+    count += 1;
+  }
+  return params;
+}
+var UNSAFE_KEYS = ["constructor", "prototype", "__proto__"];
+function okKey(key) {
+  if (key.length === 0 || key.length > PARAM_LIMIT.keyLength) return false;
+  if (UNSAFE_KEYS.includes(key.toLowerCase())) return false;
+  return /^[a-z][a-zA-Z0-9_]*$/.test(key);
+}
+function toCamel(key) {
+  return key.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function readText(node) {
+  const text = node.textContent?.replace(/\s+/g, " ").trim();
+  if (!text) return void 0;
+  return mask(text).slice(0, TEXT_MAX);
+}
+
+// src/config.ts
+var LOG_PATH = "/api/v2/logs/analytics";
+var HALTED = "; analytics did not start";
+function checkConfig(config, base = pageBase()) {
+  if (!config.key) return `E_KEY_MISSING: init({ key }) is missing${HALTED}`;
+  if (!config.endpoint) return `E_ENDPOINT_MISSING: init({ endpoint }) is missing${HALTED}`;
+  const issue = endpointIssue(config.endpoint, base) ?? (config.path === void 0 ? null : pathIssue(config.path));
+  return issue && `${issue}${HALTED}`;
+}
+function pathIssue(path) {
+  if (path === "") return null;
+  if (path.includes("\\") || [...path].some(isControl)) {
+    return "E_PATH_ILLEGAL_CHAR: path contains a control character or a backslash";
+  }
+  if (/[?#]/.test(path)) return "E_PATH_QUERY_OR_FRAGMENT: path contains a query or a fragment";
+  if (!path.startsWith("/")) return 'E_PATH_NOT_ABSOLUTE: path does not start with "/"';
+  if (/%(2f|5c|25)/i.test(path)) {
+    return "E_PATH_ENCODED: path contains an encoded separator or percent (%2F, %5C, %25)";
+  }
+  const dots = path.split("/").map((seg) => seg.toLowerCase().replace(/%2e/g, "."));
+  if (dots.some((seg) => seg === "." || seg === "..")) {
+    return 'E_PATH_DOT_SEGMENT: path contains a "." or ".." segment';
+  }
+  return null;
+}
+function endpointIssue(endpoint, base) {
+  if (endpoint.trim() === "") return "E_ENDPOINT_EMPTY: endpoint is empty";
+  if (endpoint.includes("\\") || [...endpoint].some(isControl)) {
+    return "E_ENDPOINT_ILLEGAL_CHAR: endpoint contains a control character or a backslash";
+  }
+  if (/[?#]/.test(endpoint)) {
+    return "E_ENDPOINT_QUERY_OR_FRAGMENT: endpoint contains a query or a fragment";
+  }
+  let url;
+  try {
+    url = new URL(endpoint, base);
+  } catch {
+    return "E_ENDPOINT_UNPARSABLE: endpoint cannot be parsed as a URL";
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    return `E_ENDPOINT_SCHEME: endpoint scheme is not allowed: ${url.protocol}`;
+  }
+  if (url.username || url.password) {
+    return "E_ENDPOINT_USERINFO: endpoint contains userinfo (username or password)";
+  }
+  if (!/^https?:\/\//i.test(endpoint) && url.origin !== new URL(base).origin) {
+    return "E_ENDPOINT_CROSS_ORIGIN: relative endpoint resolves to a different origin";
+  }
+  return null;
+}
+function logUrl(endpoint, base = pageBase(), path = LOG_PATH) {
+  const url = new URL(endpoint, base);
+  url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
+  url.search = "";
+  url.hash = "";
+  return url.href;
+}
+function isControl(ch) {
+  return ch < " " || ch === "\x7F";
+}
+function pageBase() {
+  return typeof location === "undefined" ? "https://localhost" : location.href;
+}
+
+// src/engagement.ts
+var Engagement = class {
+  constructor(now = Date.now) {
+    this.now = now;
+    this.total = 0;
+    this.from = null;
+  }
+  show() {
+    if (this.from === null) this.from = this.now();
+  }
+  hide() {
+    if (this.from === null) return;
+    this.total += this.now() - this.from;
+    this.from = null;
+  }
+  elapsed() {
+    return this.from === null ? this.total : this.total + (this.now() - this.from);
+  }
+  /** 라우트 전환 시점에 누적값을 전달하고 0으로 초기화 */
+  take() {
+    const elapsed = this.elapsed();
+    this.total = 0;
+    this.from = this.from === null ? null : this.now();
+    return elapsed;
+  }
+};
+
+// src/version.ts
+var VERSION = "0.9.0";
+
+// src/env.ts
+function readEnv() {
+  return {
+    ua: navigator.userAgent,
+    lang: navigator.language,
+    screen: { w: screen.width, h: screen.height },
+    viewport: { w: innerWidth, h: innerHeight },
+    timezone: timezone(),
+    sdkVer: VERSION
+  };
+}
+function timezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "";
+  } catch {
+    return "";
+  }
+}
+
+// src/store.ts
+var cookieStore = {
+  get(name) {
+    const prefix = `${name}=`;
+    for (const chunk of document.cookie.split("; ")) {
+      if (!chunk.startsWith(prefix)) continue;
+      const raw = chunk.slice(prefix.length);
+      try {
+        return decodeURIComponent(raw);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  },
+  set(name, value, maxAge) {
+    const v = encodeURIComponent(value);
+    document.cookie = `${name}=${v}; path=/; max-age=${maxAge}; SameSite=Lax; Secure`;
+  },
+  remove(name) {
+    document.cookie = `${name}=; path=/; max-age=0; SameSite=Lax`;
+  }
+};
+
+// src/uuid.ts
+function uuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  if (!c?.getRandomValues)
+    throw new Error("[bstage-analytics] crypto\uB97C \uC4F8 \uC218 \uC5C6\uC5B4 \uC2DD\uBCC4\uC790\uB97C \uB9CC\uB4E4 \uC218 \uC5C6\uB2E4");
+  const bytes = new Uint8Array(16);
+  c.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/identity.ts
+var BID_NAME = "_bsa_bid";
+var SID_NAME = "_bsa_sid";
+var BID_AGE = 365 * 24 * 60 * 60;
+var IDLE_MAX = 30 * 60 * 1e3;
+var Identity = class {
+  constructor(store = cookieStore, now = Date.now) {
+    this.store = store;
+    this.now = now;
+    this.granted = false;
+    this.user = {};
+  }
+  get tabSId() {
+    return this.tabSIdValue ?? (this.tabSIdValue = uuid());
+  }
+  get consent() {
+    return { analytics: this.granted };
+  }
+  setConsent(analytics) {
+    const granted = analytics === true;
+    this.granted = granted;
+    if (granted) return;
+    this.store.remove(BID_NAME);
+    this.store.remove(SID_NAME);
+    this.user = {};
+  }
+  identify(userId, props) {
+    this.user = props ? { id: userId, props } : { id: userId };
+  }
+  touch() {
+    const base = { tabSId: this.tabSId, consent: this.consent };
+    if (!this.granted) return base;
+    const session = this.rollSession();
+    return {
+      ...base,
+      bId: this.browserId(),
+      sId: session.id,
+      startedAt: session.startedAt,
+      user: this.user.id ? this.user : void 0
+    };
+  }
+  peek() {
+    const base = { tabSId: this.tabSId, consent: this.consent };
+    if (!this.granted) return base;
+    const session = this.parse(this.store.get(SID_NAME));
+    return {
+      ...base,
+      bId: this.store.get(BID_NAME) ?? void 0,
+      sId: session?.id,
+      startedAt: session?.startedAt,
+      user: this.user.id ? this.user : void 0
+    };
+  }
+  browserId() {
+    const saved = this.store.get(BID_NAME);
+    if (saved) return saved;
+    const issued = uuid();
+    this.store.set(BID_NAME, issued, BID_AGE);
+    return issued;
+  }
+  rollSession() {
+    const at = this.now();
+    const prev = this.parse(this.store.get(SID_NAME));
+    const next = prev && at - prev.seenAt <= IDLE_MAX ? { ...prev, seenAt: at } : { id: uuid(), startedAt: at, seenAt: at };
+    this.store.set(SID_NAME, `${next.id}|${next.startedAt}|${next.seenAt}`, IDLE_MAX / 1e3);
+    return next;
+  }
+  parse(raw) {
+    if (!raw) return null;
+    const [id, startedAt, seenAt] = raw.split("|");
+    if (!id || !startedAt || !seenAt) return null;
+    const s = Number(startedAt);
+    const v = Number(seenAt);
+    return Number.isFinite(s) && Number.isFinite(v) ? { id, startedAt: s, seenAt: v } : null;
+  }
+};
+
+// src/impression.ts
+var ITEM_ATTR = "data-log-item";
+var ITEM_NAME_ATTR = "data-log-item-name";
+var ITEM_INDEX_ATTR = "data-log-item-index";
+var IMPRESSION_OPT = {
+  threshold: 0.5,
+  duration: 2e3,
+  rootMargin: "0px"
+};
+function readImpression(node) {
+  const itemId = node.getAttribute(ITEM_ATTR)?.trim();
+  if (!itemId) return null;
+  return {
+    // ⛔ `click.ts`의 reader를 그대로 쓴다 — 같은 키여야 `params.section`으로 조인해 CTR이 나온다
+    section: readSection(node),
+    // ⚠️ `itemId`는 마스킹하지 않는다 — 조인 키라 값이 바뀌면 지표가 끊긴다. 길이 상한만 건다
+    itemId: clip(itemId, ATTR_MAX, ITEM_ATTR),
+    itemName: readName(node),
+    itemIndex: readIndex(node)
+  };
+}
+function readName(node) {
+  const name = node.getAttribute(ITEM_NAME_ATTR)?.replace(/\s+/g, " ").trim();
+  if (!name) return void 0;
+  return mask(name).slice(0, TEXT_MAX);
+}
+function readIndex(node) {
+  const raw = node.getAttribute(ITEM_INDEX_ATTR);
+  if (raw === null || raw.trim() === "") return void 0;
+  const index = Number(raw);
+  return Number.isInteger(index) && index >= 0 ? index : void 0;
+}
+function resolveOpt(over) {
+  const opt = { ...IMPRESSION_OPT };
+  if (typeof over?.threshold === "number" && Number.isFinite(over.threshold)) {
+    opt.threshold = Math.min(1, Math.max(0, over.threshold));
+  }
+  if (typeof over?.duration === "number" && Number.isFinite(over.duration)) {
+    opt.duration = Math.max(0, over.duration);
+  }
+  if (typeof over?.rootMargin === "string" && over.rootMargin.trim() !== "") {
+    opt.rootMargin = over.rootMargin;
+  }
+  return opt;
+}
+var ImpressionGate = class {
+  constructor(duration, emit) {
+    this.duration = duration;
+    this.emit = emit;
+    this.fired = /* @__PURE__ */ new Set();
+    this.timers = /* @__PURE__ */ new Map();
+  }
+  enter(key, value) {
+    if (this.fired.has(key) || this.timers.has(key)) return;
+    if (this.duration <= 0) {
+      this.fire(key, value);
+      return;
+    }
+    this.timers.set(
+      key,
+      setTimeout(() => this.fire(key, value), this.duration)
+    );
+  }
+  leave(key) {
+    const timer = this.timers.get(key);
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    this.timers.delete(key);
+  }
+  /** 라우트 전환. 발화 이력과 대기 중인 체류를 전부 되돌린다 */
+  reset() {
+    this.stop();
+    this.fired.clear();
+  }
+  /** 대기 중인 체류만 취소한다. 발화 이력은 남는다 */
+  stop() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+  }
+  fire(key, value) {
+    this.timers.delete(key);
+    this.fired.add(key);
+    this.emit(value);
+  }
+};
+var Impressions = class {
+  constructor(opt, emit) {
+    this.opt = opt;
+    this.io = null;
+    this.mos = /* @__PURE__ */ new Set();
+    this.roots = /* @__PURE__ */ new WeakSet();
+    this.seen = /* @__PURE__ */ new WeakSet();
+    this.gate = new ImpressionGate(opt.duration, emit);
+  }
+  /** 브라우저가 두 Observer를 지원하지 않으면 조용히 아무 것도 하지 않는다 */
+  start() {
+    if (this.io !== null) return;
+    this.io = makeObserver(this.opt, (entries) => this.onIntersect(entries));
+    if (this.io === null) return;
+    this.walk(document);
+  }
+  /**
+   * 라우트 전환. ⛔ 관찰을 통째로 다시 건다 — 발화 이력만 지우면 이미 화면에 있던 대상은
+   * 교차 상태가 변하지 않아 IntersectionObserver가 다시 알려주지 않는다.
+   */
+  reset() {
+    this.stop();
+    this.start();
+  }
+  stop() {
+    this.gate.reset();
+    this.io?.disconnect();
+    this.io = null;
+    for (const mo of this.mos) mo.disconnect();
+    this.mos.clear();
+    this.roots = /* @__PURE__ */ new WeakSet();
+    this.seen = /* @__PURE__ */ new WeakSet();
+  }
+  onIntersect(entries) {
+    for (const entry of entries) {
+      const params = readImpression(entry.target);
+      if (params === null) continue;
+      const key = `${params.section ?? ""}\0${params.itemId}`;
+      if (entry.isIntersecting && entry.intersectionRatio >= this.opt.threshold) {
+        this.gate.enter(key, params);
+      } else {
+        this.gate.leave(key);
+      }
+    }
+  }
+  /** ⚠️ `start()`·`reset()`에서만 부른다 — mutation마다 전체를 훑으면 고객사 페이지가 무거워진다 */
+  walk(root) {
+    this.register(root);
+    this.scan(root);
+  }
+  /** 루트에 MutationObserver를 단다. 처음 보는 루트일 때만 true다 */
+  register(root) {
+    if (this.roots.has(root)) return false;
+    this.roots.add(root);
+    const mo = watch(root, (records) => this.onMutate(records));
+    if (mo !== null) this.mos.add(mo);
+    return true;
+  }
+  scan(root) {
+    root.querySelectorAll("*").forEach((el) => this.consider(el));
+  }
+  /** 추가된 서브트리만 훑는다. 피드는 lazy load가 기본이라 이 경로가 주 경로다 */
+  onMutate(records) {
+    for (const record of records) {
+      record.addedNodes.forEach((node) => {
+        if (!(node instanceof Element)) return;
+        this.consider(node);
+        node.querySelectorAll("*").forEach((el) => this.consider(el));
+      });
+    }
+  }
+  /**
+   * ⛔ `shadowRoot` 재귀를 빼지 말 것. 게스트 템플릿은 Shadow DOM에 마운트되고
+   * `document.querySelectorAll`은 그 경계를 넘지 못한다 — 재귀가 없으면 게스트의 대상이
+   * 하나도 관찰되지 않는다.
+   *
+   * ⛔ 처음 보는 루트만 훑는다. `register()` 없이 스캔하면 mutation마다 이미 등록된 루트를
+   * 통째로 다시 훑어, shadow host를 반복 추가하는 마크업이 메인 스레드를 점유한다.
+   */
+  consider(el) {
+    if (el.shadowRoot !== null && this.register(el.shadowRoot)) this.scan(el.shadowRoot);
+    if (this.seen.has(el) || !el.hasAttribute(ITEM_ATTR)) return;
+    this.seen.add(el);
+    this.io?.observe(el);
+  }
+};
+function makeObserver(opt, callback) {
+  if (typeof IntersectionObserver === "undefined") return null;
+  try {
+    return new IntersectionObserver(callback, {
+      rootMargin: opt.rootMargin,
+      threshold: opt.threshold
+    });
+  } catch {
+    return new IntersectionObserver(callback, { threshold: opt.threshold });
+  }
+}
+function watch(root, callback) {
+  if (typeof MutationObserver === "undefined") return null;
+  const mo = new MutationObserver(callback);
+  mo.observe(root, { childList: true, subtree: true });
+  return mo;
+}
+
+// src/page.ts
+var UTM_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+function readPage(logicalRef) {
+  const { href, pathname } = location;
+  return {
+    url: mask(href),
+    // ⚠️ `pathname`도 마스킹을 지난다 — 길이 상한(`MASK_MAX`)이 함께 딸려 오고,
+    // 경로에 실려 오는 리셋 토큰류도 같은 규칙으로 처리된다.
+    path: mask(pathname),
+    title: maskUrl(document.title),
+    ref: maskUrl(document.referrer || void 0),
+    logicalRef: maskUrl(logicalRef),
+    viewId: uuid()
+  };
+}
+function readUtm(search) {
+  const query = new URLSearchParams(search);
+  const utm = {};
+  for (const key of UTM_KEYS) {
+    const value = query.get(key);
+    if (value) utm[key] = clip(value, UTM_MAX, key);
+  }
+  return utm;
+}
+function readLoad() {
+  const entry = performance?.getEntriesByType?.("navigation")[0];
+  return entry?.type === "reload" || entry?.type === "back_forward" ? entry.type : "navigate";
+}
+
+// src/queue.ts
+var MAX_HELD = 500;
+var MAX_AGE = 3 * 24 * 60 * 60 * 1e3;
+var RETRY_MAX = 5;
+function trim(records, now) {
+  const alive = records.filter(
+    (held) => now - held.savedAt <= MAX_AGE && held.retryCount < RETRY_MAX
+  );
+  const sorted = [...alive].sort((a, b) => a.savedAt - b.savedAt);
+  const keep = sorted.slice(Math.max(0, sorted.length - MAX_HELD));
+  return { keep, dropped: records.length - keep.length };
+}
+function backoff(retryCount) {
+  return 1e3 * 2 ** Math.min(retryCount, 4);
+}
+var DB_NAME = "bstage-analytics";
+var STORE_NAME = "held";
+async function wipeStore() {
+  try {
+    const store = await openStore();
+    await store?.clear();
+  } catch {
+    return;
+  }
+}
+async function openStore() {
+  let db = await openDb();
+  if (db && !db.objectStoreNames.contains(STORE_NAME)) {
+    db.close();
+    await deleteDb();
+    db = await openDb();
+  }
+  if (!db?.objectStoreNames.contains(STORE_NAME)) return null;
+  const run = (mode, body) => new Promise((resolve) => {
+    try {
+      const request = body(db.transaction(STORE_NAME, mode).objectStore(STORE_NAME));
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+  return {
+    // ⛔ 한 트랜잭션으로 쓴다 — 트랜잭션은 생성 순서대로 커밋되는데, 건마다 await하며 열면
+    // 두 번째부터는 그 사이 열린 `clear()`보다 늦게 커밋돼 철회로 지운 보관분이 되살아난다.
+    // 트랜잭션은 호출 시점에 동기로 열린다 — 호출자가 확인과 호출 사이에 await하지 않으면 된다.
+    // 한 건의 요청 오류는 `preventDefault()`로 삼킨다 — 두지 않으면 트랜잭션 전체가 롤백된다.
+    // 커밋 여부를 돌려준다: 트랜잭션이 중단되면(용량 초과 등) 아무것도 쓰이지 않았다.
+    put(records) {
+      return new Promise((resolve) => {
+        if (records.length === 0) return resolve(true);
+        try {
+          const tx = db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          for (const held of records) {
+            try {
+              store.put(held).onerror = (event) => event.preventDefault();
+            } catch {
+              continue;
+            }
+          }
+          tx.oncomplete = () => resolve(true);
+          tx.onabort = () => resolve(false);
+        } catch {
+          resolve(false);
+        }
+      });
+    },
+    async all() {
+      return await run("readonly", (store) => store.getAll()) ?? [];
+    },
+    async remove(evtIds) {
+      for (const id of evtIds) await run("readwrite", (store) => store.delete(id));
+    },
+    async clear() {
+      await run("readwrite", (store) => store.clear());
+    }
+  };
+}
+function deleteDb() {
+  return new Promise((resolve) => {
+    try {
+      const request = indexedDB.deleteDatabase(DB_NAME);
+      request.onsuccess = () => resolve();
+      request.onerror = () => resolve();
+      request.onblocked = () => resolve();
+    } catch {
+      resolve();
+    }
+  });
+}
+function openDb() {
+  return new Promise((resolve) => {
+    try {
+      const request = indexedDB.open(DB_NAME, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore(STORE_NAME, { keyPath: "evtId" });
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => resolve(null);
+      request.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+// src/persist.ts
+var LOCK_PREFIX = "bstage-analytics:owner:";
+var LEGACY = "legacy";
+var Persist = class {
+  constructor(now = Date.now, open = openStore, locks = globalThis.navigator?.locks ?? null) {
+    this.now = now;
+    this.open = open;
+    this.locks = locks;
+    this.owner = uuid();
+    this.store = null;
+    this.enabled = false;
+    this.locked = null;
+    this.held = /* @__PURE__ */ new Map();
+  }
+  get durable() {
+    return this.store !== null;
+  }
+  /** 동의 시 IndexedDB를 연다. 열리지 않으면 메모리 보관만 계속한다 */
+  async enable() {
+    if (this.store) return;
+    this.enabled = true;
+    const store = await this.open();
+    if (!this.enabled) {
+      await store?.clear();
+      return;
+    }
+    if (store) await this.lock();
+    if (!this.enabled) {
+      await store?.clear();
+      return;
+    }
+    this.store = store;
+    if (this.store && this.held.size > 0) await this.store.put([...this.held.values()]);
+  }
+  /**
+   * 동의 철회. 메모리 보관분까지 비우고 저장소를 지운다
+   */
+  async disable() {
+    this.enabled = false;
+    const store = this.store;
+    this.store = null;
+    this.held.clear();
+    if (store) await store.clear();
+    else await wipeStore();
+  }
+  hold(events2, snapshot) {
+    const records = events2.map((event) => ({
+      evtId: event.evtId,
+      event,
+      savedAt: this.now(),
+      retryCount: 0,
+      snapshot,
+      owner: this.owner
+    }));
+    for (const held of records) this.held.set(held.evtId, held);
+    void this.store?.put(records);
+  }
+  /** 전송이 성공한 이벤트를 보관에서 지운다 */
+  settle(evtIds) {
+    for (const id of evtIds) this.held.delete(id);
+    void this.store?.remove(evtIds);
+  }
+  fail(evtIds) {
+    const records = [];
+    for (const id of evtIds) {
+      const held = this.held.get(id);
+      if (held) records.push({ ...held, retryCount: held.retryCount + 1 });
+    }
+    for (const held of records) this.held.set(held.evtId, held);
+    void this.store?.put(records);
+  }
+  async recover() {
+    const store = this.store;
+    const stale = [];
+    const valid = [];
+    for (const held of await store?.all() ?? []) {
+      if (held.snapshot) valid.push(held);
+      else stale.push(held.evtId);
+    }
+    if (!this.live(store)) return [];
+    const claimed = await this.claim(valid, store);
+    if (!this.live(store)) return [];
+    for (const held of claimed) {
+      if (!this.held.has(held.evtId)) this.held.set(held.evtId, held);
+    }
+    if (stale.length > 0) {
+      void this.store?.remove(stale);
+      console.warn(
+        `[bstage-analytics] E_HELD_NO_SNAPSHOT: discarded ${stale.length} held event(s) with no identity snapshot`
+      );
+    }
+    const { keep, dropped } = trim([...this.held.values()], this.now());
+    if (dropped > 0) {
+      const gone = [...this.held.keys()].filter((id) => !keep.some((held) => held.evtId === id));
+      this.held.clear();
+      void this.store?.remove(gone);
+      console.warn(
+        `[bstage-analytics] E_HELD_OVERFLOW: discarded ${dropped} held event(s) over the retention limit`
+      );
+    } else {
+      this.held.clear();
+    }
+    for (const held of keep) this.held.set(held.evtId, held);
+    return keep;
+  }
+  /** 페이지가 죽을 때까지 쥐는 lock. 콜백이 끝나지 않으므로 브라우저만 풀 수 있다 */
+  lock() {
+    const locks = this.locks;
+    if (!locks) return Promise.resolve();
+    this.locked ?? (this.locked = new Promise((granted) => {
+      locks.request(LOCK_PREFIX + this.owner, () => {
+        granted();
+        return new Promise(() => {
+        });
+      }).catch(() => granted());
+    }));
+    return this.locked;
+  }
+  /**
+   * 내 보관분과, 주인 탭이 죽은 보관분만 돌려준다. 죽은 탭의 것은 그 탭의 lock 안에서 다시
+   * 읽어 소유를 넘겨받는다 — 두 탭이 동시에 넘겨받으려 해도 lock이 한 쪽만 들여보내고, 늦은
+   * 쪽은 다시 읽은 목록이 비어 있다.
+   */
+  async claim(rows, store) {
+    const locks = this.locks;
+    if (!locks || !store) return rows;
+    const mine = rows.filter((held) => held.owner === this.owner);
+    const others = new Set(
+      rows.filter((held) => held.owner !== this.owner).map((held) => held.owner ?? LEGACY)
+    );
+    for (const owner of others) {
+      await locks.request(LOCK_PREFIX + owner, { ifAvailable: true }, async (lock) => {
+        if (!lock || !this.live(store)) return;
+        const orphans = (await store.all()).filter((held) => held.snapshot && (held.owner ?? LEGACY) === owner).map((held) => ({ ...held, owner: this.owner }));
+        if (!this.live(store)) return;
+        if (await store.put(orphans)) mine.push(...orphans);
+      }).catch(() => {
+      });
+    }
+    return mine;
+  }
+  /** 읽기를 시작한 저장소가 아직 쓰이고 있다 — 그 사이 철회·재동의가 없었다 */
+  live(store) {
+    return this.store === store && (store === null || this.enabled);
+  }
+  /**
+   * 지금 보관 중인 것. ⛔ **`recover()`의 반환값 대신 이것을 쓴다** — 반환값은 그 시점에
+   * 고정된 사본이라, 돌려주는 사이에 전송이 끝나 `settle()`이 돌면 이미 지워진 이벤트가
+   * 목록에는 남는다. 그것을 재전송하면 방금 보낸 것을 한 번 더 보내게 된다.
+   */
+  pending() {
+    return [...this.held.values()];
+  }
+  /** 보관 중인 건수. 육안 검증용이다 */
+  size() {
+    return this.held.size;
+  }
+};
+
+// src/route.ts
+var ROUTE_EVENT = "bstage:route";
+var HOOK_FLAG = "__bstageRouteHook";
+function browserHost() {
+  return {
+    history,
+    bus: window,
+    flags: window,
+    event: () => window.event
+  };
+}
+function hookRoute(host = browserHost()) {
+  if (host.flags[HOOK_FLAG]) return () => {
+  };
+  host.flags[HOOK_FLAG] = true;
+  let alive = true;
+  let popping = false;
+  const inPop = () => popping || host.event?.()?.type === "popstate";
+  const originals = {};
+  const mine = {};
+  for (const name of ["pushState", "replaceState"]) {
+    const original = host.history[name];
+    originals[name] = original;
+    const patched = function(...args) {
+      const result = original.apply(this, args);
+      if (alive && !(name === "replaceState" && inPop())) notify(host, "navigate");
+      return result;
+    };
+    mine[name] = patched;
+    host.history[name] = patched;
+  }
+  const abort = new AbortController();
+  host.bus.addEventListener(
+    "popstate",
+    () => {
+      popping = true;
+      setTimeout(() => {
+        popping = false;
+        if (alive) notify(host, "back_forward");
+      });
+    },
+    { signal: abort.signal }
+  );
+  return () => {
+    alive = false;
+    for (const name of ["pushState", "replaceState"]) {
+      if (host.history[name] === mine[name]) host.history[name] = originals[name];
+    }
+    abort.abort();
+    delete host.flags[HOOK_FLAG];
+  };
+}
+function onRoute(fn, opts = {}) {
+  const host = opts.host ?? browserHost();
+  host.bus.addEventListener(
+    ROUTE_EVENT,
+    (event) => {
+      const detail = event.detail;
+      if (!isLoadType(detail)) return;
+      Promise.resolve().then(() => fn(detail));
+    },
+    { signal: opts.signal }
+  );
+}
+var LOAD_TYPES = ["navigate", "reload", "back_forward"];
+function isLoadType(value) {
+  return typeof value === "string" && LOAD_TYPES.includes(value);
+}
+function notify(host, loadType) {
+  host.bus.dispatchEvent(new CustomEvent(ROUTE_EVENT, { detail: loadType }));
+}
+
+// src/scroll.ts
+var DEPTHS = [50, 90];
+var ScrollDepth = class {
+  constructor(emit) {
+    this.emit = emit;
+    this.fired = /* @__PURE__ */ new Set();
+  }
+  check(ratio) {
+    for (const depth of DEPTHS) {
+      if (ratio >= depth && !this.fired.has(depth)) {
+        this.fired.add(depth);
+        this.emit(depth);
+      }
+    }
+  }
+  reset() {
+    this.fired.clear();
+  }
+};
+function readRatio(top, viewport, total) {
+  const scrollable = total - viewport;
+  if (scrollable <= 0) return 100;
+  return Math.min(100, (top + viewport) / total * 100);
+}
+
+// src/transport.ts
+var BODY_MAX = 48 * 1024;
+function overBodyMax(body) {
+  return new TextEncoder().encode(body).length > BODY_MAX;
+}
+async function post(url, body) {
+  if (navigator.onLine === false) return false;
+  const blob = new Blob([body], { type: "text/plain" });
+  if (navigator.sendBeacon?.(url, blob)) return true;
+  try {
+    await fetch(url, {
+      method: "POST",
+      body: blob,
+      keepalive: true,
+      mode: "no-cors",
+      referrerPolicy: "no-referrer"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tracker.ts
+var Tracker = class {
+  constructor() {
+    this.identity = new Identity();
+    this.engagement = new Engagement();
+    this.depth = new ScrollDepth(
+      (depth) => this.auto({ name: "scroll_depth", params: { depth } })
+    );
+    /** 노출 관찰. init 전에는 없다 */
+    this.impressions = null;
+    this.config = null;
+    this.env = null;
+    this.page = null;
+    this.warned = false;
+    this.batch = new Batch((evts) => void this.ship(evts));
+    this.persist = new Persist();
+    /**
+     * 배치·전송이 쥐고 있는 이벤트. 보관은 write-ahead라 보관소에는 「아직 전송 차례가 오지
+     * 않은 것」과 「전송에 실패해 다시 보내야 하는 것」이 섞여 있는데, 이 표시가 그 둘을 가른다.
+     *
+     * ⛔ **버퍼를 들여다보는 것으로는 가를 수 없다.** 보관분을 읽는 사이에도 이벤트는 추가되고
+     * flush되므로, 목록을 읽기 전에 잡으면 그 사이 추가된 것을, 읽은 뒤에 잡으면 그 사이
+     * flush된 것을 놓친다. 소유권은 시점이 아니라 상태여야 한다.
+     *
+     * 이전 세션의 보관분은 여기에 없다 — 그래서 탭이 죽은 뒤의 복구는 그대로 동작한다.
+     */
+    this.owned = /* @__PURE__ */ new Set();
+    this.retryTimer = null;
+    this.abort = null;
+    this.unhook = null;
+    this.revived = false;
+    this.stopped = false;
+    this.snapshot = null;
+  }
+  get ready() {
+    return this.config !== null;
+  }
+  init(config = {}) {
+    if (this.ready) return true;
+    if (typeof document === "undefined") return false;
+    const c = globalThis.crypto;
+    if (!c?.randomUUID && !c?.getRandomValues) {
+      this.warn("E_CRYPTO_UNAVAILABLE: crypto is unavailable; analytics did not start");
+      return false;
+    }
+    const merged = strip(config);
+    const issue = checkConfig(merged);
+    if (issue) {
+      this.warn(issue);
+      return false;
+    }
+    this.config = merged;
+    this.env = readEnv();
+    this.stopped = false;
+    this.watch();
+    this.impressions = new Impressions(
+      resolveOpt(merged.impression),
+      (params) => this.auto({ name: "impression", params })
+    );
+    this.impressions.start();
+    this.pageView(this.revived ? "navigate" : readLoad());
+    return true;
+  }
+  identify(userId, props) {
+    this.identity.identify(userId, safeProps(props));
+  }
+  setConsent(analytics) {
+    this.batch.flush();
+    this.identity.setConsent(analytics);
+    if (analytics === true) {
+      void this.persist.enable().then(() => this.retry());
+      return;
+    }
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    void this.persist.disable();
+  }
+  ids() {
+    return this.identity.peek();
+  }
+  flush() {
+    this.batch.flush();
+  }
+  destroy() {
+    if (!this.ready) return;
+    this.stopped = true;
+    this.flush();
+    this.abort?.abort();
+    this.abort = null;
+    this.unhook?.();
+    this.unhook = null;
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    this.engagement.hide();
+    this.depth.reset();
+    this.impressions?.stop();
+    this.impressions = null;
+    this.config = null;
+    this.env = null;
+    this.page = null;
+    this.revived = true;
+  }
+  events() {
+    return this.batch.pending();
+  }
+  queue() {
+    return { durable: this.persist.durable, held: this.persist.size() };
+  }
+  send(name, params) {
+    if (!this.ready) return;
+    if (!checkName(name)) {
+      console.warn(
+        `[bstage-analytics] E_NAME_INVALID: event name does not match the naming rule; dropped: ${name}`
+      );
+      return;
+    }
+    if (params) {
+      const size = sizeOf(params);
+      if (size === null || size > EVENT_MAX) {
+        console.warn(
+          `[bstage-analytics] E_PARAMS_TOO_LARGE: params exceed the ${EVENT_MAX}B limit; "${name}" dropped`
+        );
+        return;
+      }
+      for (const issue of checkParams(params)) {
+        console.warn(`[bstage-analytics] E_PARAMS_LIMIT: ${name}: ${issue}`);
+      }
+    }
+    this.record(name, params);
+  }
+  /** ⛔ 예약 이름 판정은 여기서만 한다 — `send()`에 두면 자동 계측 경로가 검사를 건너뛴다 */
+  record(name, params) {
+    if (typeof name !== "string" || isReserved(name)) {
+      console.warn(
+        `[bstage-analytics] E_NAME_RESERVED: event name is reserved or not a string; dropped: ${String(name)}`
+      );
+      return;
+    }
+    this.emit(name, params);
+  }
+  /** 자동 계측 전용 경로. 예약 이름을 낼 수 있는 유일한 곳이라 SDK 내부에서만 부른다 */
+  auto(event) {
+    this.emit(event.name, event.params);
+  }
+  emit(name, params) {
+    if (!this.ready) return;
+    this.snapshot = this.identity.touch();
+    const event = {
+      evtId: uuid(),
+      ts: Date.now(),
+      name,
+      page: this.page ?? (this.page = readPage(this.prevUrl)),
+      params
+    };
+    this.owned.add(event.evtId);
+    this.batch.add(event);
+    this.persist.hold([event], this.snapshot);
+  }
+  /**
+   * ⛔ **전송이 시작된 이벤트도 그 전송이 끝날 때까지 소유한다.** 백오프와 `online`이 겹쳐
+   * 돌면 재전송이 두 번 시작될 수 있는데, 표시가 없으면 아직 날아가는 중인 보관분을 두
+   * 번째 재전송이 다시 집어간다. `record()`가 붙인 표시와 같은 표시다(집합이라 겹쳐도 된다).
+   */
+  async ship(evts, retryCount = 0, held) {
+    const evtIds = evts.map((event) => event.evtId);
+    for (const id of evtIds) this.owned.add(id);
+    try {
+      await this.deliver(evts, evtIds, retryCount, held);
+    } catch {
+      console.warn(
+        `[bstage-analytics] E_SHIP_FAILED: could not serialize or send ${evts.length} event(s)`
+      );
+      this.persist.fail(evtIds);
+      this.scheduleRetry(retryCount);
+    } finally {
+      this.release(evtIds);
+    }
+  }
+  /** ⛔ 쪼갤 수 없는 1건이 상한을 넘으면 드롭한다 — 그대로 보내면 브라우저가 조용히 삼킨다 */
+  async deliver(evts, evtIds, retryCount, held) {
+    const config = this.config;
+    const env = this.env;
+    const snapshot = held ?? this.snapshot;
+    if (!config || !env || !snapshot) return;
+    const { consent, startedAt: _startedAt, ...ids2 } = snapshot;
+    const payload = {
+      version: 2,
+      key: config.key,
+      ...ids2,
+      env,
+      consent,
+      // 발화 임계값은 **배치당 1회**만 싣는다. 이벤트마다 반복하면 정작 「무엇이 노출됐는가」를
+      // 담을 자리가 없어진다 — `ImpressionParams` 주석 참조.
+      ...this.impressions === null ? {} : { impressionOpt: this.impressions.opt },
+      sentAt: Date.now(),
+      retryCount,
+      evts
+    };
+    const body = JSON.stringify(payload);
+    if (overBodyMax(body)) {
+      if (evts.length > 1) {
+        const half = Math.ceil(evts.length / 2);
+        await Promise.all([
+          this.ship(evts.slice(0, half), retryCount, snapshot),
+          this.ship(evts.slice(half), retryCount, snapshot)
+        ]);
+        return;
+      }
+      console.warn(`[bstage-analytics] \uC774\uBCA4\uD2B8 1\uAC74\uC774 body \uC0C1\uD55C\uC744 \uB118\uC5B4 \uB4DC\uB86D\uD55C\uB2E4: "${evts[0]?.name}"`);
+      this.persist.settle(evtIds);
+      return;
+    }
+    if (await post(logUrl(config.endpoint, void 0, config.path), body)) {
+      this.persist.settle(evtIds);
+      return;
+    }
+    if (navigator.onLine === false) return;
+    this.persist.fail(evtIds);
+    this.scheduleRetry(retryCount);
+  }
+  /** 배치·전송이 쥐고 있던 이벤트를 놓는다. 놓인 것만 재전송 대상이 된다 */
+  release(evtIds) {
+    for (const id of evtIds) this.owned.delete(id);
+  }
+  /**
+   * 보관분 재전송.
+   *
+   * ⛔ **배치 버퍼가 아직 들고 있는 이벤트는 재전송 대상이 아니다.** 보관은 write-ahead라
+   * 이벤트가 버퍼에 들어가는 시점에 이미 기록된다 — 걸러내지 않으면 여기서 한 번, 버퍼가
+   * 제 차례에 또 한 번 보내 같은 `evtId`가 수집 서버에 두 레코드로 남는다.
+   *
+   * ⛔ **제외는 꺼내는 쪽인 여기서 한다.** 보관을 늦추면 flush 전에 탭이 죽었을 때 복구되지
+   * 않는다 — write-ahead의 목적 자체가 사라진다.
+   *
+   * ⛔ **소유권 표시로 가른다 — 버퍼를 읽는 시점으로 가르지 않는다.** 보관분을 읽는 사이에도
+   * 이벤트는 추가되고 flush되므로 어느 시점에 버퍼를 읽어도 한쪽 창이 남는다(`owned` 참조).
+   */
+  async retry() {
+    if (this.stopped) return;
+    await this.persist.recover();
+    const records = this.persist.pending().filter((held) => !this.owned.has(held.evtId));
+    const groups = /* @__PURE__ */ new Map();
+    for (const held of records) {
+      const key = JSON.stringify(held.snapshot);
+      const group = groups.get(key);
+      if (group) group.push(held);
+      else groups.set(key, [held]);
+    }
+    for (const group of groups.values()) {
+      for (let at = 0; at < group.length; at += BATCH_MAX) {
+        const slice = group.slice(at, at + BATCH_MAX);
+        const attempt = Math.max(...slice.map((held) => held.retryCount));
+        void this.ship(
+          slice.map((held) => held.event),
+          attempt,
+          slice[0].snapshot
+        );
+      }
+    }
+  }
+  scheduleRetry(retryCount) {
+    if (this.stopped || this.retryTimer !== null) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.retry();
+    }, backoff(retryCount));
+  }
+  pageView(loadType, engagementTime) {
+    this.page = readPage(this.prevUrl);
+    this.prevUrl = this.page.url;
+    const { startedAt } = this.identity.touch();
+    this.auto({
+      name: "page_view",
+      params: {
+        loadType,
+        ...engagementTime === void 0 ? {} : { engagementTime },
+        ...startedAt === void 0 ? {} : { sessionDuration: Date.now() - startedAt },
+        ...readUtm(location.search)
+      }
+    });
+  }
+  click(event) {
+    if (!event.isTrusted) return;
+    const el = findTarget(event);
+    if (!el) return;
+    this.auto({ name: "click", params: readClick(el, event.pageX, event.pageY) });
+    const custom = readEvent(el);
+    if (custom) this.send(custom.name, custom.params);
+  }
+  watch() {
+    const abort = this.abort = new AbortController();
+    const { signal } = abort;
+    if (document.visibilityState === "visible") this.engagement.show();
+    document.addEventListener(
+      "visibilitychange",
+      () => {
+        if (document.visibilityState === "visible") this.engagement.show();
+        else this.engagement.hide();
+      },
+      { signal }
+    );
+    document.addEventListener(
+      "visibilitychange",
+      () => {
+        if (document.visibilityState === "hidden") this.batch.flush();
+      },
+      { signal }
+    );
+    addEventListener("pagehide", () => this.batch.flush(), { signal });
+    addEventListener("online", () => void this.retry(), { signal });
+    document.addEventListener("click", (event) => this.click(event), { capture: true, signal });
+    let ticking = false;
+    addEventListener(
+      "scroll",
+      (event) => {
+        if (!event.isTrusted || ticking) return;
+        ticking = true;
+        requestAnimationFrame(() => {
+          ticking = false;
+          this.depth.check(readRatio(scrollY, innerHeight, document.documentElement.scrollHeight));
+        });
+      },
+      { passive: true, signal }
+    );
+    this.unhook = hookRoute();
+    onRoute(
+      (loadType) => afterPaint(() => {
+        if (location.href === this.prevUrl) return;
+        this.depth.reset();
+        this.impressions?.reset();
+        this.pageView(loadType, this.engagement.take());
+      }, signal),
+      { signal }
+    );
+  }
+  warn(message) {
+    if (this.warned) return;
+    this.warned = true;
+    console.warn(`[bstage-analytics] ${message}`);
+  }
+};
+function safeProps(props) {
+  if (!props) return void 0;
+  let json;
+  try {
+    json = JSON.stringify(props);
+  } catch {
+    json = void 0;
+  }
+  if (json === void 0) {
+    console.warn(
+      "[bstage-analytics] E_PROPS_UNSERIALIZABLE: identify props could not be serialized; props dropped, userId kept"
+    );
+    return void 0;
+  }
+  if (new TextEncoder().encode(json).length > EVENT_MAX) {
+    console.warn(
+      `[bstage-analytics] E_PROPS_TOO_LARGE: identify props exceed the ${EVENT_MAX}B limit; props dropped, userId kept`
+    );
+    return void 0;
+  }
+  return JSON.parse(json);
+}
+function strip(config) {
+  return Object.fromEntries(Object.entries(config).filter(([, v]) => v !== void 0));
+}
+var PAINT_MAX = 100;
+function afterPaint(fn, signal) {
+  let done = false;
+  const run = () => {
+    if (done || signal.aborted) return;
+    done = true;
+    fn();
+  };
+  requestAnimationFrame(() => requestAnimationFrame(run));
+  setTimeout(run, PAINT_MAX);
+}
+
+// src/index.ts
+var tracker = new Tracker();
+function init(config = {}) {
+  tracker.init(config);
+}
+function identify(userId, props) {
+  tracker.identify(userId, props);
+}
+function send(name, params) {
+  tracker.send(name, params);
+}
+function setConsent(analytics) {
+  tracker.setConsent(analytics);
+}
+function ids() {
+  return tracker.ids();
+}
+function flush() {
+  tracker.flush();
+}
+function destroy() {
+  tracker.destroy();
+}
+function events() {
+  return tracker.events();
+}
+function queue() {
+  return tracker.queue();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ATTR_MAX,
+  BATCH_MAX,
+  BID_NAME,
+  BODY_MAX,
+  CLICK_ATTR,
+  DEPTHS,
+  EVENT_ATTR,
+  EVENT_MAX,
+  FLUSH_WAIT,
+  IDLE_MAX,
+  IMPRESSION_OPT,
+  ITEM_ATTR,
+  ITEM_INDEX_ATTR,
+  ITEM_NAME_ATTR,
+  LOG_PATH,
+  MASK_MAX,
+  MAX_AGE,
+  MAX_HELD,
+  NAME_MAX,
+  PARAM_LIMIT,
+  PARAM_PREFIX,
+  RESERVED,
+  RETRY_MAX,
+  ROUTE_EVENT,
+  SECTION_ATTR,
+  SID_NAME,
+  TEXT_MAX,
+  UTM_MAX,
+  VERSION,
+  backoff,
+  checkName,
+  checkParams,
+  destroy,
+  events,
+  flush,
+  identify,
+  ids,
+  init,
+  logUrl,
+  mask,
+  queue,
+  readEvent,
+  readImpression,
+  send,
+  setConsent,
+  sizeOf,
+  trim
+});