@solhun/feedback-kit-core 0.1.0

package/dist/index.js

@@ -0,0 +1,2268 @@
+// src/uuid.ts
+function pickRandomBytes() {
+  const g = typeof globalThis !== "undefined" ? globalThis : {};
+  const crypto = g.crypto;
+  const getRandomValues = crypto?.getRandomValues;
+  if (typeof getRandomValues === "function") {
+    return (arr) => getRandomValues.call(crypto, arr);
+  }
+  return (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      arr[i] = Math.floor(Math.random() * 256);
+    }
+    return arr;
+  };
+}
+function uuidv4() {
+  const fill = pickRandomBytes();
+  const b = new Uint8Array(16);
+  fill(b);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = Array.from(b, (n) => n.toString(16).padStart(2, "0"));
+  return h.slice(0, 4).join("") + "-" + h.slice(4, 6).join("") + "-" + h.slice(6, 8).join("") + "-" + h.slice(8, 10).join("") + "-" + h.slice(10, 16).join("");
+}
+
+// src/guest-id.ts
+var GUEST_KEY = "feedback-kit:guest-id";
+async function getOrCreateGuestId(storage) {
+  const existing = await storage.get(GUEST_KEY);
+  if (existing && existing.length > 0) {
+    return existing;
+  }
+  const id = `guest_${uuidv4()}`;
+  await storage.set(GUEST_KEY, id);
+  return id;
+}
+function guestUser(id) {
+  return { id, isGuest: true };
+}
+
+// src/context.ts
+async function resolveContextUser(getUser, storage) {
+  if (typeof getUser === "function") {
+    try {
+      const u = await Promise.resolve(getUser());
+      if (u && typeof u.id === "string" && u.id.length > 0) {
+        return normalizeUser(u);
+      }
+    } catch {
+    }
+  }
+  try {
+    const id = await getOrCreateGuestId(storage);
+    return { id, email: null, isGuest: true };
+  } catch {
+    return null;
+  }
+}
+function normalizeUser(u) {
+  const out = {
+    id: u.id,
+    email: typeof u.email === "string" ? u.email : null,
+    // isGuest 생략 = 로그인 사용자.
+    isGuest: u.isGuest === true
+  };
+  if (typeof u.name === "string") out.name = u.name;
+  if (typeof u.role === "string") out.role = u.role;
+  return out;
+}
+async function buildContext(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const iso = opts.iso ?? ((n) => new Date(n).toISOString());
+  const user = await resolveContextUser(opts.getUser, opts.storage);
+  const screen = safeCall(opts.getCurrentScreen, null);
+  return {
+    app: opts.app,
+    screen: typeof screen === "string" ? screen : null,
+    url: nullableString(safeCall(opts.getUrl, null)),
+    sessionId: opts.sessionId,
+    user,
+    source: opts.source ?? { screenId: null, sourceFile: null },
+    platform: opts.platform,
+    timezone: resolveTimezone(opts.getTimezone),
+    clientTimestamp: iso(now()),
+    native: buildNative(opts, typeof screen === "string" ? screen : null),
+    web: buildWeb(opts),
+    // 공급자가 없으면 null — 빈 배열을 상수로 보내지 않는다.
+    diagnostics: opts.getDiagnostics ? normalizeDiagnostics(safeCall(opts.getDiagnostics, null)) : null,
+    extra: opts.extra ?? {}
+  };
+}
+function hasNativeProvider(opts) {
+  return Boolean(
+    opts.getAppInfo || opts.getDevice || opts.getDisplay || opts.getNavPath || opts.getRouteParams || opts.screenSourceMap
+  );
+}
+function buildNative(opts, screen) {
+  if (opts.platform !== "native" || !hasNativeProvider(opts)) return null;
+  const navPathRaw = safeCall(opts.getNavPath, null);
+  const navPath = Array.isArray(navPathRaw) ? navPathRaw.filter((s) => typeof s === "string") : (
+    // 스택을 못 구했으면 최소한 현재 화면 한 칸이라도 남긴다.
+    screen ? [screen] : []
+  );
+  const app = safeCall(opts.getAppInfo, null) ?? {};
+  const device = safeCall(opts.getDevice, null) ?? {};
+  const display = safeCall(opts.getDisplay, null) ?? {};
+  return {
+    // 매핑이 없으면 여기만 null 이고 나머지 컨텍스트는 그대로 수집된다.
+    screenPath: lookupScreenPath(opts.screenSourceMap, screen),
+    navPath,
+    routeParams: toPlainRecord(safeCall(opts.getRouteParams, void 0)),
+    appInfo: {
+      version: nullableString(app.version),
+      channel: nullableString(app.channel),
+      updateId: nullableString(app.updateId),
+      runtimeVersion: nullableString(app.runtimeVersion)
+    },
+    device: {
+      model: nullableString(device.model),
+      osName: nullableString(device.osName),
+      osVersion: nullableString(device.osVersion),
+      deviceType: nullableString(device.deviceType)
+    },
+    display: {
+      width: nullableNumber(display.width),
+      height: nullableNumber(display.height),
+      pixelRatio: nullableNumber(display.pixelRatio),
+      fontScale: nullableNumber(display.fontScale)
+    }
+  };
+}
+function buildWeb(opts) {
+  if (opts.platform !== "web" || !opts.getWebContext) return null;
+  const w = safeCall(opts.getWebContext, null) ?? {};
+  const vp = w.viewport ?? {};
+  return {
+    viewport: {
+      width: nullableNumber(vp.width),
+      height: nullableNumber(vp.height),
+      devicePixelRatio: nullableNumber(vp.devicePixelRatio)
+    },
+    userAgent: nullableString(w.userAgent)
+  };
+}
+function lookupScreenPath(map, screen) {
+  if (!map || !screen) return null;
+  const hit = map[screen];
+  return typeof hit === "string" && hit.length > 0 ? hit : null;
+}
+function normalizeDiagnostics(snap) {
+  if (!snap || !Array.isArray(snap.network) || !Array.isArray(snap.logs)) {
+    return null;
+  }
+  return snap;
+}
+function safeCall(fn, fallback) {
+  if (typeof fn !== "function") return fallback;
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function nullableString(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function nullableNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function resolveTimezone(getTimezone) {
+  const injected = safeCall(getTimezone, null);
+  if (typeof injected === "string" && injected.length > 0) return injected;
+  try {
+    const tz = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return typeof tz === "string" && tz.length > 0 ? tz : null;
+  } catch {
+    return null;
+  }
+}
+function toPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  let json2;
+  try {
+    json2 = JSON.stringify(value, (_key, v) => {
+      if (typeof v === "function") return void 0;
+      if (v && typeof v === "object") {
+        if (seen.has(v)) return "[Circular]";
+        seen.add(v);
+      }
+      return v;
+    });
+  } catch {
+    return null;
+  }
+  if (typeof json2 !== "string") return null;
+  try {
+    const parsed = JSON.parse(json2);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/report.ts
+async function buildReport(parts, opts) {
+  const now = opts.now ?? (() => Date.now());
+  const iso = opts.iso ?? ((n) => new Date(n).toISOString());
+  const context = await buildContext(opts);
+  return {
+    clientSubmissionId: uuidv4(),
+    kind: parts.kind,
+    comment: parts.comment,
+    priority: parts.priority,
+    screenshot: parts.screenshot,
+    pin: parts.pin,
+    element: parts.element,
+    context,
+    createdAt: iso(now())
+  };
+}
+
+// src/queue.ts
+var QUEUE_KEY = "feedback-kit:queue";
+var MAX_QUEUE_ITEMS = 50;
+var MAX_QUEUE_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var BACKOFF_BASE_MS = 5 * 1e3;
+var BACKOFF_MAX_MS = 5 * 60 * 1e3;
+var RATE_LIMIT_MIN_DELAY_MS = 10 * 60 * 1e3;
+function defaultBackoff(attempts, retryAfterMs, rateLimited = false) {
+  const serverHint = typeof retryAfterMs === "number" && retryAfterMs >= 0 ? retryAfterMs : null;
+  if (rateLimited) {
+    return Math.max(RATE_LIMIT_MIN_DELAY_MS, serverHint ?? 0);
+  }
+  if (serverHint !== null) {
+    return Math.min(serverHint, BACKOFF_MAX_MS);
+  }
+  const v = BACKOFF_BASE_MS * Math.pow(2, Math.max(0, attempts - 1));
+  return Math.min(v, BACKOFF_MAX_MS);
+}
+var FeedbackQueue = class {
+  constructor(opts) {
+    /**
+     * 저장소 접근 직렬화 체인.
+     *
+     * 왜 필요한가: `load → 수정 → save` 사이에 다른 경로가 끼어들면 그 사이 쓰기가 통째로
+     * 사라진다(flush 가 [A]를 읽는 동안 enqueue 가 [A,B]를 저장 → flush 가 []를 저장 →
+     * B 유실). 단순한 `flushing` 불리언은 재진입을 "무시"할 뿐이라 이 경합을 못 막고,
+     * 무시된 flush 를 기다리던 `submit()` 이 자기 전송을 await 할 수도 없다.
+     */
+    this.chain = Promise.resolve();
+    /** 아직 시작하지 않은 flush 요청(있으면 재사용해서 타이머 연타를 합친다). */
+    this.queuedFlush = null;
+    this.timer = null;
+    this.onlineHandler = null;
+    this.pending = 0;
+    this.sending = false;
+    this.lastError = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    /** 제출 단위 결과 캐시. `submit()` 이 자기 건의 결말을 알아내는 데 쓴다. */
+    this.outcomes = /* @__PURE__ */ new Map();
+    this.storage = opts.storage;
+    this.adapter = opts.adapter;
+    this.flushIntervalMs = opts.flushIntervalMs ?? 3e4;
+    this.now = opts.now ?? (() => Date.now());
+    this.backoff = opts.backoff ?? defaultBackoff;
+    this.warn = opts.warn ?? defaultWarn;
+  }
+  // ── 공개 API ──────────────────────────────────────────────
+  /**
+   * 제보를 큐에 넣고 전송을 시도한 뒤, 그 한 건의 결말을 돌려준다.
+   * 실패해도 예외를 던지지 않는다 — 제보는 큐에 남고 `queued: true` 로 알린다.
+   */
+  async submit(report) {
+    this.outcomes.delete(report.clientSubmissionId);
+    await this.serialize(() => this.enqueueInner(report));
+    await this.flush();
+    const outcome = this.outcomes.get(report.clientSubmissionId);
+    if (outcome) {
+      return { delivered: outcome.delivered, id: outcome.id, queued: false };
+    }
+    return { delivered: false, id: null, queued: true };
+  }
+  /** 큐에 제보를 추가하고, 전송을 백그라운드로 시도한다. */
+  async enqueue(report) {
+    await this.serialize(() => this.enqueueInner(report));
+    void this.flush();
+  }
+  /**
+   * 만기된 큐 항목들을 한 건씩 순서대로 전송한다.
+   * 이미 진행 중이면 그 뒤에 한 번만 예약해 붙는다(타이머 연타로 flush 가 쌓이지 않는다).
+   */
+  flush() {
+    if (this.queuedFlush) return this.queuedFlush;
+    const p = this.serialize(async () => {
+      this.queuedFlush = null;
+      await this.doFlush();
+    });
+    this.queuedFlush = p;
+    return p;
+  }
+  /**
+   * 지금 즉시 재시도한다. 네트워크 복귀·앱 포그라운드 복귀·[다시 보내기] 용.
+   * 백오프 대기를 앞당기되, **429 로 묶인 항목은 앞당기지 않는다**(서버가 명시한 한도라
+   * 무시하면 다시 429 만 받는다).
+   */
+  async retryNow() {
+    await this.serialize(async () => {
+      const queue = await this.load();
+      let changed = false;
+      for (const item of queue) {
+        if (item.rateLimited === true) continue;
+        if (item.nextAttemptAt !== null) {
+          item.nextAttemptAt = null;
+          changed = true;
+        }
+      }
+      if (changed) await this.persist(queue);
+    });
+    await this.flush();
+  }
+  /** 현재 큐 길이(대기 중 제보 수). 검증/진단용. */
+  async size() {
+    const queue = await this.serialize(() => this.load());
+    this.setPending(queue.length);
+    return queue.length;
+  }
+  /** 현재 전송 상태 스냅샷. */
+  getStatus() {
+    return {
+      state: this.sending ? "sending" : this.pending > 0 ? "pending" : "idle",
+      pending: this.pending,
+      lastError: this.lastError
+    };
+  }
+  /** 특정 clientSubmissionId의 마지막 확정 결말. 큐에 있거나 아직 시도 전이면 null이다. */
+  getOutcome(clientSubmissionId) {
+    return this.outcomes.get(clientSubmissionId) ?? null;
+  }
+  /** 전송 상태 구독. 반환값을 호출하면 해지된다. 구독 즉시 현재 상태를 1회 통지한다. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    try {
+      listener(this.getStatus());
+    } catch {
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 마운트 시 호출. 만기 항목 정리 + 즉시 재시도 + 주기 flush + `online` 재시도를 건다.
+   * 앱(RN)에는 `online` 이벤트가 없으므로, 호스트가 포그라운드 복귀 시 `retryNow()` 를
+   * 직접 부른다(코어는 플랫폼 API 를 모른다).
+   */
+  start() {
+    this.stop();
+    const g = globalThis;
+    if (typeof g.addEventListener === "function") {
+      const handler = () => {
+        void this.retryNow();
+      };
+      g.addEventListener("online", handler);
+      this.onlineHandler = handler;
+    }
+    if (this.flushIntervalMs > 0 && typeof g.setInterval === "function") {
+      this.timer = g.setInterval(() => {
+        void this.flush();
+      }, this.flushIntervalMs);
+    }
+    void this.retryNow();
+  }
+  /** 타이머와 이벤트 구독을 해제한다. 큐 내용은 그대로 남는다. */
+  stop() {
+    const g = globalThis;
+    if (this.timer !== null) {
+      if (typeof g.clearInterval === "function") g.clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.onlineHandler !== null) {
+      if (typeof g.removeEventListener === "function") {
+        g.removeEventListener("online", this.onlineHandler);
+      }
+      this.onlineHandler = null;
+    }
+  }
+  // ── 내부: 적재 / 전송 ─────────────────────────────────────
+  async enqueueInner(report) {
+    const queue = this.purgeExpired(await this.load());
+    queue.push({
+      report,
+      attempts: 0,
+      nextAttemptAt: null,
+      enqueuedAt: this.now()
+    });
+    while (queue.length > MAX_QUEUE_ITEMS) {
+      const dropped = queue.shift();
+      this.warn(
+        `feedback-kit: \uB300\uAE30 \uD050\uAC00 ${MAX_QUEUE_ITEMS}\uAC74\uC744 \uB118\uC5B4 \uAC00\uC7A5 \uC624\uB798\uB41C \uC81C\uBCF4\uB97C \uBC84\uB838\uB2E4`,
+        dropped?.report.clientSubmissionId
+      );
+    }
+    await this.persist(queue);
+  }
+  async doFlush() {
+    let queue = await this.load();
+    const kept = this.purgeExpired(queue);
+    if (kept.length !== queue.length) {
+      queue = kept;
+      await this.persist(queue);
+    }
+    this.setPending(queue.length);
+    if (queue.length === 0) {
+      this.emit();
+      return;
+    }
+    const now = this.now();
+    const due = queue.filter(
+      (item) => item.nextAttemptAt === null || now >= item.nextAttemptAt
+    );
+    if (due.length === 0) {
+      this.emit();
+      return;
+    }
+    this.sending = true;
+    this.emit();
+    try {
+      for (const item of due) {
+        if (queue.indexOf(item) === -1) continue;
+        const result = await this.submitOne(item.report);
+        const at = this.now();
+        const index = queue.indexOf(item);
+        if (result.ok) {
+          if (index !== -1) queue.splice(index, 1);
+          this.recordOutcome(item.report.clientSubmissionId, true, result.id);
+          this.lastError = null;
+        } else if (!result.retryable) {
+          if (index !== -1) queue.splice(index, 1);
+          this.recordOutcome(item.report.clientSubmissionId, false, null);
+          this.lastError = "non-retryable";
+          this.warn(
+            "feedback-kit: \uC7AC\uC2DC\uB3C4 \uBD88\uAC00 \uC2E4\uD328\uB85C \uC81C\uBCF4\uB97C \uBC84\uB838\uB2E4",
+            item.report.clientSubmissionId
+          );
+        } else {
+          item.attempts += 1;
+          item.rateLimited = result.rateLimited === true;
+          item.nextAttemptAt = at + this.backoff(item.attempts, result.retryAfterMs, item.rateLimited);
+          this.lastError = item.rateLimited ? "rate-limited" : "retryable";
+        }
+        await this.persist(queue);
+        this.setPending(queue.length);
+        this.emit();
+      }
+    } finally {
+      this.sending = false;
+      this.emit();
+    }
+  }
+  /** 어댑터 호출. 어댑터가 예외를 던져도 결과값으로 흡수한다(전송 보장 우선). */
+  async submitOne(report) {
+    try {
+      return await this.adapter.submit(report);
+    } catch (err) {
+      this.warn("feedback-kit: \uC5B4\uB311\uD130\uAC00 \uC608\uC678\uB97C \uB358\uC84C\uB2E4(\uC77C\uC2DC \uC2E4\uD328\uB85C \uCC98\uB9AC)", err);
+      return { ok: false, id: null, retryable: true, retryAfterMs: null };
+    }
+  }
+  // ── 내부: 저장소 ──────────────────────────────────────────
+  async load() {
+    let raw = null;
+    try {
+      raw = await this.storage.get(QUEUE_KEY);
+    } catch (err) {
+      this.warn("feedback-kit: \uD050\uB97C \uC77D\uC9C0 \uBABB\uD588\uB2E4", err);
+      return [];
+    }
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter(isQueuedReport).map(normalizeEntry(this.now()));
+    } catch {
+      this.warn("feedback-kit: \uD050\uAC00 \uC190\uC0C1\uB3FC \uCD08\uAE30\uD654\uD588\uB2E4");
+      return [];
+    }
+  }
+  /**
+   * 큐를 저장한다. 저장소 한도(쿼터)에 걸리면 **스크린샷부터** 떼어내고, 그래도 안 되면
+   * 가장 오래된 제보를 버린다. 사용자가 쓴 글이 스크린샷보다 우선이다.
+   * 인자로 받은 배열을 제자리에서 수정한다(호출부가 들고 있는 항목 참조는 유지된다).
+   */
+  async persist(queue) {
+    for (; ; ) {
+      try {
+        await this.storage.set(QUEUE_KEY, JSON.stringify(queue));
+        this.setPending(queue.length);
+        return;
+      } catch (err) {
+        if (queue.length === 0) {
+          this.warn("feedback-kit: \uD050\uB97C \uC800\uC7A5\uD558\uC9C0 \uBABB\uD588\uB2E4", err);
+          return;
+        }
+        const shotIndex = queue.findIndex(
+          (item) => item.report.screenshot !== null
+        );
+        if (shotIndex !== -1) {
+          const entry = queue[shotIndex];
+          entry.report = { ...entry.report, screenshot: null };
+          entry.screenshotDropped = true;
+          this.warn(
+            "feedback-kit: \uC800\uC7A5 \uD55C\uB3C4\uB97C \uB118\uC5B4 \uC2A4\uD06C\uB9B0\uC0F7\uC744 \uB5BC\uC5B4\uB0B4\uACE0 \uC81C\uBCF4\uB9CC \uBCF4\uAD00\uD55C\uB2E4",
+            entry.report.clientSubmissionId
+          );
+          continue;
+        }
+        const evicted = queue.shift();
+        this.warn(
+          "feedback-kit: \uC800\uC7A5 \uD55C\uB3C4\uB97C \uB118\uC5B4 \uAC00\uC7A5 \uC624\uB798\uB41C \uC81C\uBCF4\uB97C \uBC84\uB838\uB2E4",
+          evicted?.report.clientSubmissionId
+        );
+      }
+    }
+  }
+  /** 7일이 지난 항목을 걸러낸다. 만기 항목은 전송을 시도하지 않는다. */
+  purgeExpired(queue) {
+    const now = this.now();
+    const kept = queue.filter((item) => now - item.enqueuedAt <= MAX_QUEUE_AGE_MS);
+    if (kept.length !== queue.length) {
+      this.warn(
+        `feedback-kit: \uBCF4\uAD00 \uAE30\uAC04(7\uC77C)\uC774 \uC9C0\uB09C \uC81C\uBCF4 ${queue.length - kept.length}\uAC74\uC744 \uC815\uB9AC\uD588\uB2E4`
+      );
+    }
+    return kept;
+  }
+  // ── 내부: 상태 통지 ───────────────────────────────────────
+  recordOutcome(id, delivered, serverId) {
+    if (this.outcomes.size >= 100) {
+      const oldest = this.outcomes.keys().next();
+      if (!oldest.done) this.outcomes.delete(oldest.value);
+    }
+    this.outcomes.set(id, { delivered, id: serverId });
+  }
+  setPending(n) {
+    if (this.pending === n) return;
+    this.pending = n;
+  }
+  emit() {
+    if (this.listeners.size === 0) return;
+    const status = this.getStatus();
+    for (const listener of this.listeners) {
+      try {
+        listener(status);
+      } catch {
+      }
+    }
+  }
+  serialize(fn) {
+    const next = this.chain.then(fn, fn);
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+};
+function defaultWarn(...a) {
+  const g = globalThis;
+  g.console?.warn?.(...a);
+}
+function isQueuedReport(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const report = v.report;
+  if (typeof report !== "object" || report === null) return false;
+  return typeof report.clientSubmissionId === "string";
+}
+function normalizeEntry(now) {
+  return (v) => ({
+    ...v,
+    attempts: typeof v.attempts === "number" && v.attempts >= 0 ? v.attempts : 0,
+    nextAttemptAt: typeof v.nextAttemptAt === "number" ? v.nextAttemptAt : null,
+    // enqueuedAt 이 없던 시절의 항목은 "방금 들어온 것"으로 봐서 즉시 버리지 않는다.
+    enqueuedAt: typeof v.enqueuedAt === "number" ? v.enqueuedAt : now
+  });
+}
+
+// src/keepalive.ts
+var KEEPALIVE_BODY_LIMIT_BYTES = 64 * 1024;
+function canUseKeepalive(bodyByteLength) {
+  if (!Number.isFinite(bodyByteLength) || bodyByteLength < 0) return false;
+  return bodyByteLength <= KEEPALIVE_BODY_LIMIT_BYTES;
+}
+function byteLengthOf(body) {
+  const g = globalThis;
+  if (typeof g.TextEncoder === "function") {
+    return new g.TextEncoder().encode(body).length;
+  }
+  return body.length * 3;
+}
+
+// src/ring-buffer.ts
+var RingBuffer = class {
+  constructor(capacity) {
+    this.items = [];
+    this.capacity = Number.isFinite(capacity) && capacity > 0 ? Math.floor(capacity) : 0;
+  }
+  push(item) {
+    if (this.capacity === 0) {
+      return;
+    }
+    this.items.push(item);
+    const overflow = this.items.length - this.capacity;
+    if (overflow > 0) {
+      this.items.splice(0, overflow);
+    }
+  }
+  /** 현재 내용의 복사본. 호출자가 들고 있어도 이후 push 에 영향받지 않는다. */
+  toArray() {
+    return this.items.slice();
+  }
+  get size() {
+    return this.items.length;
+  }
+  clear() {
+    this.items = [];
+  }
+};
+
+// src/diagnostics.ts
+var NETWORK_BUFFER_LIMIT = 30;
+var LOG_BUFFER_LIMIT = 50;
+var MAX_LOG_MESSAGE_CHARS = 2e3;
+var DiagnosticsCollector = class {
+  constructor(opts = {}) {
+    this.installed = false;
+    // 원본 참조(원복용 + 위젯 우회용).
+    this.originalFetch = null;
+    this.originalXhrOpen = null;
+    this.originalXhrSend = null;
+    this.originalWarn = null;
+    this.originalError = null;
+    this.excludeMatcher = null;
+    /**
+     * 패치된 fetch 안에서 동기적으로 XHR 이 열리는 깊이.
+     *
+     * React Native 의 `fetch` 는 whatwg-fetch 폴리필이라 내부에서 XMLHttpRequest 를 쓴다.
+     * 둘 다 패치해두면 요청 1건이 2건으로 기록된다. fetch 폴리필은 Promise 실행자 안에서
+     * **동기적으로** `send()` 를 부르므로, 그 구간을 세어 XHR 쪽 기록만 건너뛴다.
+     */
+    this.fetchDepth = 0;
+    /** 위젯이 자신의 로그를 캡처 없이 찍을 때 쓰는 원본 console. */
+    this.originalConsole = {
+      warn: (...a) => {
+        (this.originalWarn ?? consoleMethod("warn"))(...a);
+      },
+      error: (...a) => {
+        (this.originalError ?? consoleMethod("error"))(...a);
+      },
+      log: (...a) => {
+        consoleMethod("log")(...a);
+      }
+    };
+    this.now = opts.now ?? (() => Date.now());
+    this.iso = opts.iso ?? ((n) => new Date(n).toISOString());
+    this.network = new RingBuffer(
+      opts.networkLimit ?? NETWORK_BUFFER_LIMIT
+    );
+    this.logs = new RingBuffer(opts.logLimit ?? LOG_BUFFER_LIMIT);
+  }
+  /** 글로벌 fetch/XHR/console 을 패치한다. 이미 설치했으면 no-op. */
+  install(opts = {}) {
+    if (this.installed) return;
+    this.installed = true;
+    this.excludeMatcher = opts.excludeMatcher ?? null;
+    if (opts.now) this.now = opts.now;
+    if (opts.iso) this.iso = opts.iso;
+    this.patchFetch();
+    this.patchXhr();
+    this.patchConsole();
+  }
+  /** 글로벌 패치를 모두 원복한다. 버퍼 내용은 그대로 남는다. */
+  uninstall() {
+    if (!this.installed) return;
+    this.installed = false;
+    const g = globalThis;
+    if (this.originalFetch) {
+      g.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+    const XHR = g.XMLHttpRequest;
+    if (XHR?.prototype && this.originalXhrOpen && this.originalXhrSend) {
+      XHR.prototype.open = this.originalXhrOpen;
+      XHR.prototype.send = this.originalXhrSend;
+    }
+    this.originalXhrOpen = null;
+    this.originalXhrSend = null;
+    const c = g.console;
+    if (c && this.originalWarn) c.warn = this.originalWarn;
+    if (c && this.originalError) c.error = this.originalError;
+    this.originalWarn = null;
+    this.originalError = null;
+    this.excludeMatcher = null;
+    this.fetchDepth = 0;
+  }
+  /**
+   * 지금까지 모인 것을 그대로 스냅샷으로 낸다.
+   * 반환 배열은 사본이라 이후 수집이 제보 페이로드를 바꾸지 않는다.
+   */
+  snapshot() {
+    return { network: this.network.toArray(), logs: this.logs.toArray() };
+  }
+  /** 두 버퍼를 비운다. */
+  clear() {
+    this.network.clear();
+    this.logs.clear();
+  }
+  // ── 내부: 기록 ────────────────────────────────────────────
+  recordNetwork(method, url, status, startedAt) {
+    this.network.push({
+      method,
+      url,
+      status,
+      durationMs: Math.max(0, Math.round(this.now() - startedAt)),
+      at: this.iso(startedAt)
+    });
+  }
+  recordLog(level, args) {
+    this.logs.push({
+      level,
+      message: safeStringify(args).slice(0, MAX_LOG_MESSAGE_CHARS),
+      at: this.iso(this.now())
+    });
+  }
+  isExcluded(url, method) {
+    if (!this.excludeMatcher) return false;
+    try {
+      return this.excludeMatcher({ url, method }) === true;
+    } catch {
+      return false;
+    }
+  }
+  // ── 내부: 패치 ────────────────────────────────────────────
+  patchFetch() {
+    const g = globalThis;
+    if (typeof g.fetch !== "function") return;
+    this.originalFetch = g.fetch;
+    const originalFetch = this.originalFetch;
+    const self = this;
+    g.fetch = function patchedFetch(input, init) {
+      const { url, method } = describeRequest(input, init);
+      const excluded = self.isExcluded(url, method);
+      const start = self.now();
+      let pending;
+      self.fetchDepth += 1;
+      try {
+        pending = Promise.resolve(originalFetch(input, init));
+      } catch (err) {
+        self.fetchDepth -= 1;
+        if (!excluded) self.recordNetwork(method, url, null, start);
+        throw err;
+      }
+      self.fetchDepth -= 1;
+      return pending.then(
+        (raw) => {
+          if (!excluded) {
+            const status = raw?.status;
+            self.recordNetwork(
+              method,
+              url,
+              typeof status === "number" ? status : null,
+              start
+            );
+          }
+          return raw;
+        },
+        (err) => {
+          if (!excluded) self.recordNetwork(method, url, null, start);
+          throw err;
+        }
+      );
+    };
+  }
+  patchXhr() {
+    const g = globalThis;
+    const XHR = g.XMLHttpRequest;
+    if (typeof g.XMLHttpRequest !== "function" || !XHR?.prototype) return;
+    const proto = XHR.prototype;
+    if (typeof proto.open !== "function" || typeof proto.send !== "function") return;
+    this.originalXhrOpen = proto.open;
+    this.originalXhrSend = proto.send;
+    const oOpen = this.originalXhrOpen;
+    const oSend = this.originalXhrSend;
+    const self = this;
+    proto.open = function patchedOpen(method, url, ...rest) {
+      this.__fk_meta = {
+        method: String(method ?? "GET").toUpperCase(),
+        url: sanitizeUrl(String(url ?? ""))
+      };
+      return oOpen.call(this, method, url, ...rest);
+    };
+    proto.send = function patchedSend(...args) {
+      const meta = this.__fk_meta;
+      const viaFetch = self.fetchDepth > 0;
+      const addEv = this.addEventListener;
+      if (meta && !viaFetch && typeof addEv === "function") {
+        const excluded = self.isExcluded(meta.url, meta.method);
+        const start = self.now();
+        let recorded = false;
+        addEv.call(this, "loadend", () => {
+          if (recorded || excluded) return;
+          recorded = true;
+          const status = this.status;
+          self.recordNetwork(
+            meta.method,
+            meta.url,
+            typeof status === "number" && status > 0 ? status : null,
+            start
+          );
+        });
+      }
+      return oSend.apply(this, args);
+    };
+  }
+  patchConsole() {
+    const c = globalThis.console;
+    if (!c) return;
+    const self = this;
+    if (typeof c.warn === "function") {
+      const orig = c.warn.bind(c);
+      this.originalWarn = orig;
+      c.warn = function patchedWarn(...args) {
+        self.recordLog("warn", args);
+        orig(...args);
+      };
+    }
+    if (typeof c.error === "function") {
+      const orig = c.error.bind(c);
+      this.originalError = orig;
+      c.error = function patchedError(...args) {
+        self.recordLog("error", args);
+        orig(...args);
+      };
+    }
+  }
+};
+var sharedDiagnostics = new DiagnosticsCollector();
+function consoleMethod(name) {
+  return (...a) => {
+    const c = globalThis.console;
+    c?.[name]?.(...a);
+  };
+}
+function safeStringify(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    if (a instanceof Error) return `${a.name}: ${a.message}`;
+    try {
+      return JSON.stringify(a) ?? String(a);
+    } catch {
+      try {
+        return String(a);
+      } catch {
+        return "[unserializable]";
+      }
+    }
+  }).join(" ");
+}
+function describeRequest(input, init) {
+  let url = "";
+  let method = "GET";
+  if (typeof input === "string") {
+    url = input;
+  } else if (input && typeof input === "object") {
+    const maybeUrl = input.url;
+    const maybeHref = input.href;
+    if (typeof maybeUrl === "string") url = maybeUrl;
+    else if (typeof maybeHref === "string") url = maybeHref;
+    else {
+      try {
+        url = String(input);
+      } catch {
+        url = "";
+      }
+    }
+    const maybeMethod = input.method;
+    if (typeof maybeMethod === "string") method = maybeMethod;
+  }
+  if (init && typeof init.method === "string") method = init.method;
+  return { url: sanitizeUrl(url), method: method.toUpperCase() };
+}
+var CREDENTIAL_PARAMS = /* @__PURE__ */ new Set([
+  "accesskey",
+  "accesstoken",
+  "apikey",
+  "apisecret",
+  "auth",
+  "authorization",
+  "authtoken",
+  "clientsecret",
+  "code",
+  "credential",
+  "credentials",
+  "idtoken",
+  "jwt",
+  "key",
+  "password",
+  "passwd",
+  "privatekey",
+  "pwd",
+  "refreshtoken",
+  "secret",
+  "secretkey",
+  "session",
+  "sessionid",
+  "sessiontoken",
+  "sid",
+  "sig",
+  "signature",
+  "token"
+]);
+var REDACTED = "REDACTED";
+function isCredentialParam(rawName) {
+  const name = rawName.toLowerCase().replace(/[-_.]/g, "");
+  if (CREDENTIAL_PARAMS.has(name)) return true;
+  return name.endsWith("token") || name.endsWith("secret") || name.endsWith("password") || name.endsWith("apikey");
+}
+function sanitizeUrl(raw) {
+  if (!raw) return "";
+  const hashAt = raw.indexOf("#");
+  const withoutHash = hashAt >= 0 ? raw.slice(0, hashAt) : raw;
+  const queryAt = withoutHash.indexOf("?");
+  const base = stripUserInfo(
+    queryAt >= 0 ? withoutHash.slice(0, queryAt) : withoutHash
+  );
+  if (queryAt < 0) return base;
+  const query = withoutHash.slice(queryAt + 1);
+  if (query.length === 0) return base;
+  const parts = query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq < 0) return pair;
+    const name = pair.slice(0, eq);
+    return isCredentialParam(name) ? `${name}=${REDACTED}` : pair;
+  });
+  return `${base}?${parts.join("&")}`;
+}
+function stripUserInfo(url) {
+  const schemeAt = url.indexOf("://");
+  if (schemeAt < 0) return url;
+  const authorityStart = schemeAt + 3;
+  const pathAt = url.indexOf("/", authorityStart);
+  const authority = pathAt < 0 ? url.slice(authorityStart) : url.slice(authorityStart, pathAt);
+  const at = authority.lastIndexOf("@");
+  if (at < 0) return url;
+  const cleaned = authority.slice(at + 1);
+  return url.slice(0, authorityStart) + cleaned + (pathAt < 0 ? "" : url.slice(pathAt));
+}
+
+// src/config.ts
+var VISIBILITY_KEYWORDS = ["all", "internal", "dev-only"];
+var DEFAULT_INTERNAL_ROLES = ["internal", "admin", "staff"];
+var CORNERS = [
+  "bottom-right",
+  "bottom-left",
+  "top-right",
+  "top-left"
+];
+var DEFAULT_POSITION = {
+  corner: "bottom-right",
+  offsetX: 16,
+  offsetY: 16
+};
+var ADAPTER_NAMES = ["lasso", "linear", "notion"];
+var DEFAULT_ADAPTER = "lasso";
+var ENDPOINT_FROM_ADAPTER = null;
+function looksUnsubstituted(token) {
+  const t = token.trim();
+  if (t === "undefined" || t === "null" || t === "NaN") return true;
+  if (t.includes("process.env.") || t.includes("import.meta.env")) return true;
+  if (/^\$\{.*\}$/.test(t) || /^%.*%$/.test(t)) return true;
+  return false;
+}
+function detectDevBuild() {
+  const g = globalThis;
+  if (typeof g.__DEV__ === "boolean") return g.__DEV__;
+  const proc = g.process;
+  const nodeEnv = proc?.env?.NODE_ENV;
+  if (typeof nodeEnv === "string") return nodeEnv !== "production";
+  return false;
+}
+function normalizePosition(input, warn) {
+  if (input === void 0 || input === null) return { ...DEFAULT_POSITION };
+  if (typeof input === "string") {
+    if (CORNERS.includes(input)) {
+      return { ...DEFAULT_POSITION, corner: input };
+    }
+    warn("unknown-position", `\uBAA8\uB974\uB294 position "${input}" \u2014 \uC6B0\uD558\uB2E8\uC73C\uB85C \uB418\uB3CC\uB9B0\uB2E4.`);
+    return { ...DEFAULT_POSITION };
+  }
+  const corner = input.corner !== void 0 && CORNERS.includes(input.corner) ? input.corner : DEFAULT_POSITION.corner;
+  if (input.corner !== void 0 && !CORNERS.includes(input.corner)) {
+    warn("unknown-position", `\uBAA8\uB974\uB294 position.corner "${String(input.corner)}" \u2014 \uC6B0\uD558\uB2E8\uC73C\uB85C \uB418\uB3CC\uB9B0\uB2E4.`);
+  }
+  return {
+    corner,
+    offsetX: numberOr(input.offsetX, DEFAULT_POSITION.offsetX),
+    offsetY: numberOr(input.offsetY, DEFAULT_POSITION.offsetY)
+  };
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizeAdapter(input, warn) {
+  if (input === void 0 || input === null) return DEFAULT_ADAPTER;
+  if (typeof input === "object") return input;
+  if (ADAPTER_NAMES.includes(input)) return input;
+  warn("unknown-adapter", `\uBAA8\uB974\uB294 \uC5B4\uB311\uD130 "${String(input)}" \u2014 "${DEFAULT_ADAPTER}" \uB85C \uB418\uB3CC\uB9B0\uB2E4.`);
+  return DEFAULT_ADAPTER;
+}
+function normalizeVisibility(input, warn) {
+  if (input === void 0 || input === null) return "all";
+  if (typeof input === "function") return input;
+  if (VISIBILITY_KEYWORDS.includes(input)) return input;
+  warn("unknown-visibility", `\uBAA8\uB974\uB294 visibility "${String(input)}" \u2014 "all" \uB85C \uB418\uB3CC\uB9B0\uB2E4.`);
+  return "all";
+}
+function normalizeToken(input, warn) {
+  const token = typeof input === "string" ? input.trim() : "";
+  if (token === "") {
+    warn(
+      "missing-token",
+      "\uC218\uC9D1 \uD1A0\uD070\uC774 \uC5C6\uB2E4 \u2014 \uC81C\uBCF4\uB294 \uADF8\uB300\uB85C \uC804\uC1A1\uB418\uC9C0\uB9CC \uD504\uB85C\uC81D\uD2B8\uC5D0 \uADC0\uC18D\uB418\uC9C0 \uC54A\uB294\uB2E4."
+    );
+    return null;
+  }
+  if (looksUnsubstituted(token)) {
+    warn(
+      "unsubstituted-token",
+      `\uD1A0\uD070\uC774 \uD658\uACBD\uBCC0\uC218 \uCE58\uD658 \uC804 \uAC12\uC73C\uB85C \uBCF4\uC778\uB2E4("${token}"). \uD658\uACBD\uBCC0\uC218\uB294 \uBE4C\uB4DC \uD0C0\uC784\uC5D0 \uC778\uB77C\uC778\uB418\uBBC0\uB85C \uAC12\uC744 \uB123\uC740 \uB4A4 \uB2E4\uC2DC \uBE4C\uB4DC\uD574\uC57C \uD558\uACE0, \uC571\uC740 OTA \uB85C \uBC18\uC601\uB418\uC9C0 \uC54A\uB294\uB2E4.`
+    );
+    return null;
+  }
+  return token;
+}
+function resolveConfig(config = {}) {
+  const warnings = [];
+  const warn = (code, message) => {
+    const warning = { code, message };
+    warnings.push(warning);
+    try {
+      config.onWarn?.(warning);
+    } catch {
+    }
+  };
+  const endpoint = typeof config.endpoint === "string" && config.endpoint.trim() !== "" ? config.endpoint.trim() : ENDPOINT_FROM_ADAPTER;
+  return {
+    token: normalizeToken(config.token, warn),
+    endpoint,
+    adapter: normalizeAdapter(config.adapter, warn),
+    visibility: normalizeVisibility(config.visibility, warn),
+    captureScreenshot: config.captureScreenshot ?? true,
+    captureDiagnostics: config.captureDiagnostics ?? true,
+    position: normalizePosition(config.position, warn),
+    isInternal: typeof config.isInternal === "function" ? config.isInternal : null,
+    internalRoles: config.internalRoles ?? DEFAULT_INTERNAL_ROLES,
+    isDev: config.isDev ?? detectDevBuild(),
+    warnings
+  };
+}
+function isInternalUser(resolved, env) {
+  if (resolved.isInternal) return resolved.isInternal(env) === true;
+  const user = env.user;
+  if (!user) return false;
+  if (user.isGuest === true) return false;
+  const role = typeof user.role === "string" ? user.role.toLowerCase() : null;
+  if (role === null) return false;
+  return resolved.internalRoles.some((r) => r.toLowerCase() === role);
+}
+function shouldShowWidget(resolved, input = {}) {
+  const env = {
+    user: input.user ?? null,
+    isDev: input.isDev ?? resolved.isDev,
+    platform: input.platform ?? "unknown"
+  };
+  const visibility = resolved.visibility;
+  try {
+    if (typeof visibility === "function") return visibility(env) === true;
+    switch (visibility) {
+      case "all":
+        return true;
+      case "dev-only":
+        return env.isDev;
+      case "internal":
+        return isInternalUser(resolved, env);
+      default:
+        return true;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    resolved.warnings.push({
+      code: "visibility-threw",
+      message: `visibility \uD310\uC815 \uD568\uC218\uAC00 \uC2E4\uD328\uD574 \uC704\uC82F\uC744 \uC228\uAE34\uB2E4: ${message}`
+    });
+    return false;
+  }
+}
+function diagnosticsProviderFor(resolved, collector) {
+  if (!resolved.captureDiagnostics) return void 0;
+  collector.install();
+  return () => collector.snapshot();
+}
+
+// src/source-attr.ts
+var SOURCE_ATTR = "data-fk-source";
+function parseSourceAttr(value) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "") return null;
+  let rest = raw;
+  let line = null;
+  let column = null;
+  for (let i = 0; i < 2; i += 1) {
+    const at = rest.lastIndexOf(":");
+    if (at <= 0) break;
+    const tail = rest.slice(at + 1);
+    if (!/^\d+$/.test(tail)) break;
+    const n = Number.parseInt(tail, 10);
+    if (!Number.isFinite(n) || n <= 0) break;
+    rest = rest.slice(0, at);
+    if (line === null) line = n;
+    else {
+      column = line;
+      line = n;
+    }
+  }
+  if (line === null || rest === "" || rest.startsWith(":")) return null;
+  return { file: rest, line, column };
+}
+function sourceFromElement(element, base) {
+  const fallback = {
+    screenId: base?.screenId ?? null,
+    sourceFile: base?.sourceFile ?? null,
+    sourceLine: base?.sourceLine ?? null
+  };
+  const attrs = element?.attributes;
+  if (!attrs) return fallback;
+  const loc = parseSourceAttr(attrs[SOURCE_ATTR]);
+  if (!loc) return fallback;
+  return { screenId: fallback.screenId, sourceFile: loc.file, sourceLine: loc.line };
+}
+
+// src/widget/screenshot.ts
+var SCREENSHOT_MAX_BASE64_BYTES = 8 * 1024 * 1024;
+var SCREENSHOT_FAILED_MESSAGE = "\uCEA1\uCC98 \uC2E4\uD328 \u2014 \uD30C\uC77C\uB85C \uCCA8\uBD80\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4";
+var SCREENSHOT_QUALITY_STEPS = [0.7, 0.5, 0.3];
+function screenshotBytes(shot) {
+  if (!shot || typeof shot.base64 !== "string") return 0;
+  return shot.base64.length;
+}
+function failure() {
+  return {
+    screenshot: null,
+    failed: true,
+    message: SCREENSHOT_FAILED_MESSAGE,
+    reencoded: false
+  };
+}
+function usable(shot) {
+  return !!shot && typeof shot.base64 === "string" && shot.base64.length > 0;
+}
+async function captureWithinLimit(opts) {
+  const limit = opts.limitBytes ?? SCREENSHOT_MAX_BASE64_BYTES;
+  let shot = null;
+  try {
+    shot = await opts.capture() ?? null;
+  } catch {
+    shot = null;
+  }
+  if (!usable(shot)) return failure();
+  if (screenshotBytes(shot) <= limit) {
+    return { screenshot: shot, failed: false, message: null, reencoded: false };
+  }
+  const steps = opts.qualitySteps ?? SCREENSHOT_QUALITY_STEPS;
+  if (opts.reencode) {
+    for (const quality of steps) {
+      let next = null;
+      try {
+        next = await opts.reencode(shot, quality) ?? null;
+      } catch {
+        next = null;
+      }
+      if (usable(next) && screenshotBytes(next) <= limit) {
+        return { screenshot: next, failed: false, message: null, reencoded: true };
+      }
+    }
+  }
+  return failure();
+}
+
+// src/widget/pin.ts
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function normalizePin(point, size) {
+  const x = size.width > 0 ? point.x / size.width : 0;
+  const y = size.height > 0 ? point.y / size.height : 0;
+  return { x: clamp01(x), y: clamp01(y) };
+}
+function denormalizePin(pin, size) {
+  return { x: pin.x * size.width, y: pin.y * size.height };
+}
+var PinController = class {
+  constructor(initial = null) {
+    this.opened = false;
+    this.confirmedPin = initial;
+    this.draftPin = initial;
+  }
+  get isOpen() {
+    return this.opened;
+  }
+  get draft() {
+    return this.draftPin;
+  }
+  get confirmed() {
+    return this.confirmedPin;
+  }
+  /** 화면에 떠 있는 핀 개수. 단일 핀 규칙이라 0 아니면 1이다. */
+  get count() {
+    return this.draftPin ? 1 : 0;
+  }
+  open() {
+    this.draftPin = this.confirmedPin;
+    this.opened = true;
+  }
+  /** 탭한 자리에 핀을 찍는다. 기존 핀이 있으면 그 자리로 옮긴다(추가가 아니다). */
+  place(point, size) {
+    const pin = normalizePin(point, size);
+    this.draftPin = pin;
+    return pin;
+  }
+  /** 이미 상대 좌표를 갖고 있을 때 쓰는 경로. */
+  placeRelative(pin) {
+    const next = { x: clamp01(pin.x), y: clamp01(pin.y) };
+    this.draftPin = next;
+    return next;
+  }
+  confirm() {
+    this.confirmedPin = this.draftPin;
+    this.opened = false;
+    return this.confirmedPin;
+  }
+  /** 취소 — 이전에 확정한 좌표로 되돌린다. */
+  cancel() {
+    this.draftPin = this.confirmedPin;
+    this.opened = false;
+    return this.confirmedPin;
+  }
+  reset() {
+    this.confirmedPin = null;
+    this.draftPin = null;
+    this.opened = false;
+  }
+};
+
+// src/widget/focus.ts
+var FLOATING_BUTTON_ID = "feedback-kit-floating-button";
+var FocusRing = class {
+  constructor(items = []) {
+    this.items = [...items];
+    this.index = this.items.length > 0 ? 0 : -1;
+  }
+  get order() {
+    return this.items;
+  }
+  get current() {
+    return this.index >= 0 && this.index < this.items.length ? this.items[this.index] : null;
+  }
+  /**
+   * 항목 목록을 바꾼다. 지금 포커스된 항목이 새 목록에도 있으면 그 자리를 유지한다
+   * (스크린샷을 지웠다고 포커스가 처음으로 튀면 키보드 사용자가 길을 잃는다).
+   */
+  setItems(items) {
+    const focused = this.current;
+    this.items = [...items];
+    if (this.items.length === 0) {
+      this.index = -1;
+      return;
+    }
+    const keep = focused === null ? -1 : this.items.indexOf(focused);
+    this.index = keep >= 0 ? keep : 0;
+  }
+  focus(id) {
+    const at = this.items.indexOf(id);
+    if (at < 0) return false;
+    this.index = at;
+    return true;
+  }
+  next() {
+    if (this.items.length === 0) return null;
+    this.index = (this.index + 1) % this.items.length;
+    return this.current;
+  }
+  prev() {
+    if (this.items.length === 0) return null;
+    this.index = (this.index - 1 + this.items.length) % this.items.length;
+    return this.current;
+  }
+  contains(id) {
+    return this.items.includes(id);
+  }
+};
+
+// src/widget/modal.ts
+var COMMENT_MAX_CHARS = 4e3;
+var COMMENT_REQUIRED_MESSAGE = "\uC758\uACAC\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
+var COMMENT_TOO_LONG_MESSAGE = "4,000\uC790 \uC774\uD558\uB85C \uC785\uB825\uD574\uC8FC\uC138\uC694";
+var SUBMIT_DONE_MESSAGE = "\uBCF4\uB0C8\uC2B5\uB2C8\uB2E4";
+var SUBMIT_PENDING_MESSAGE = "\uB300\uAE30 \uC911";
+var SUBMIT_FAILED_MESSAGE = "\uBCF4\uB0B4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4";
+var MODAL_FIELD_COMMENT = "comment";
+var MODAL_FIELD_PRIORITY = "priority";
+var MODAL_ACTION_ATTACH = "attach";
+var MODAL_ACTION_REMOVE_SCREENSHOT = "remove-screenshot";
+var MODAL_ACTION_PIN = "pin";
+var MODAL_ACTION_PICK = "pick";
+var MODAL_ACTION_RETRY = "retry";
+var MODAL_ACTION_CANCEL = "cancel";
+var MODAL_ACTION_SEND = "send";
+var ReportModalController = class {
+  constructor(opts) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.ring = new FocusRing();
+    /** 사용자가 입력란을 건드렸는가. 열자마자 빨간 문구가 뜨는 걸 막으려고 둔다. */
+    this.touched = false;
+    this.submitAttempted = false;
+    this.lastReport = null;
+    /** 이전 open/recapture가 늦게 끝나 최신 상태를 덮지 못하게 하는 세대 번호. */
+    this.captureGeneration = 0;
+    this.state = {
+      open: false,
+      comment: "",
+      priority: "unset",
+      screenshot: null,
+      screenshotStatus: "none",
+      screenshotMessage: null,
+      pin: null,
+      submitStatus: "idle",
+      submitMessage: null,
+      commentError: null,
+      canSubmit: false,
+      canPin: false,
+      showRetry: false,
+      pending: 0,
+      closeConfirmVisible: false,
+      actions: [],
+      focusOrder: [],
+      focused: null,
+      restoreFocusTo: null
+    };
+    this.queue = opts.queue;
+    this.createReport = opts.createReport;
+    this.platform = opts.platform;
+    this.capture = opts.capture ?? null;
+    this.reencode = opts.reencode ?? null;
+    this.screenshotLimitBytes = opts.screenshotLimitBytes;
+    this.unsubscribeQueue = this.queue.subscribe((status) => {
+      this.patch({ pending: status.pending });
+      if (this.state.submitStatus !== "pending" || !this.lastReport) return;
+      const outcome = this.queue.getOutcome?.(this.lastReport.clientSubmissionId) ?? null;
+      const delivered = outcome?.delivered === true;
+      const rejected = outcome?.delivered === false;
+      const legacyDrained = !this.queue.getOutcome && status.pending === 0;
+      if (delivered || legacyDrained) {
+        this.patch({ submitStatus: "sent", submitMessage: SUBMIT_DONE_MESSAGE });
+        this.close({ keepResult: true });
+      } else if (rejected) {
+        this.patch({ submitStatus: "failed", submitMessage: SUBMIT_FAILED_MESSAGE });
+      }
+    });
+    this.recompute();
+  }
+  // ── 조회 ──────────────────────────────────────────────────────────────────
+  getState() {
+    return this.state;
+  }
+  /** 마지막으로 조립한 제보. 재시도가 같은 멱등키를 쓰는지 확인할 때 쓴다. */
+  getLastReport() {
+    return this.lastReport;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  dispose() {
+    this.unsubscribeQueue();
+    this.listeners.clear();
+  }
+  /** WidgetController가 소유한 큐 lifecycle을 함께 정리한다. */
+  stopQueue() {
+    this.queue.stop?.();
+  }
+  // ── 열기/닫기 ─────────────────────────────────────────────────────────────
+  async open() {
+    if (this.state.open) return;
+    const wasPending = this.state.submitStatus === "pending" && this.lastReport !== null;
+    const pendingReport = wasPending ? this.lastReport : null;
+    this.touched = false;
+    this.submitAttempted = false;
+    this.patch({
+      open: true,
+      comment: pendingReport?.comment ?? "",
+      priority: pendingReport?.priority ?? "unset",
+      screenshot: pendingReport?.screenshot ?? null,
+      screenshotStatus: "none",
+      screenshotMessage: null,
+      pin: pendingReport?.pin ?? null,
+      submitStatus: wasPending ? "pending" : "idle",
+      submitMessage: wasPending ? SUBMIT_PENDING_MESSAGE : null,
+      closeConfirmVisible: false,
+      restoreFocusTo: null
+    });
+    this.ring.focus(MODAL_FIELD_COMMENT);
+    this.patch({ focused: this.ring.current });
+    if (this.capture && !wasPending) await this.runCapture();
+  }
+  /**
+   * 닫기 요청. 쓰던 내용이 있으면 곧장 닫지 않고 확인을 받는다.
+   * @returns 실제로 닫혔으면 `"closed"`, 확인이 필요하면 `"confirm"`.
+   */
+  requestClose() {
+    if (this.state.comment.length >= 1) {
+      this.patch({ closeConfirmVisible: true });
+      return "confirm";
+    }
+    this.close();
+    return "closed";
+  }
+  /** 확인 대화에서 "닫기"를 고른 경우. */
+  confirmClose() {
+    this.close();
+  }
+  /** 확인 대화에서 "계속 쓰기"를 고른 경우. 입력은 그대로 남는다. */
+  cancelClose() {
+    this.patch({ closeConfirmVisible: false });
+  }
+  /** 확인 없이 닫는다(요소 지목 모드로 넘어갈 때처럼 흐름이 이어지는 경우). */
+  dismiss() {
+    this.close();
+  }
+  close(opts) {
+    this.captureGeneration += 1;
+    const keepDraft = opts?.keepResult || this.state.submitStatus === "pending";
+    const cleared = keepDraft ? {} : {
+      comment: "",
+      priority: "unset",
+      screenshot: null,
+      screenshotStatus: "none",
+      screenshotMessage: null,
+      pin: null,
+      submitStatus: "idle",
+      submitMessage: null
+    };
+    this.touched = false;
+    this.submitAttempted = false;
+    this.patch({
+      open: false,
+      closeConfirmVisible: false,
+      focused: null,
+      restoreFocusTo: FLOATING_BUTTON_ID,
+      ...cleared
+    });
+  }
+  // ── 입력 ──────────────────────────────────────────────────────────────────
+  /** 상한을 넘겨도 값을 자르지 않는다. 거부는 하되 사용자가 쓴 글은 보존한다. */
+  setComment(value) {
+    if (this.isDraftLocked()) return;
+    this.touched = true;
+    this.patch({ comment: value });
+  }
+  setPriority(priority) {
+    if (this.isDraftLocked()) return;
+    this.patch({ priority });
+  }
+  setPin(pin) {
+    if (this.isDraftLocked()) return;
+    this.patch({ pin });
+  }
+  /** 스크린샷 제거 — 핀은 스크린샷 위 좌표라 함께 사라진다. */
+  removeScreenshot() {
+    if (this.isDraftLocked()) return;
+    this.captureGeneration += 1;
+    this.patch({
+      screenshot: null,
+      screenshotStatus: "none",
+      screenshotMessage: null,
+      pin: null
+    });
+  }
+  async recapture() {
+    if (!this.capture || this.isDraftLocked()) return;
+    await this.runCapture();
+  }
+  /** 캡처가 실패했을 때의 대체 경로 — 사용자가 직접 고른 파일. */
+  async attachFile(shot) {
+    if (this.isDraftLocked()) return;
+    const generation = ++this.captureGeneration;
+    const outcome = await captureWithinLimit({
+      capture: () => shot,
+      reencode: this.reencode,
+      limitBytes: this.screenshotLimitBytes
+    });
+    if (generation === this.captureGeneration && this.state.open && !this.isDraftLocked()) {
+      this.applyScreenshot(outcome.screenshot, outcome.failed);
+    }
+  }
+  async runCapture() {
+    const generation = ++this.captureGeneration;
+    this.patch({ screenshotStatus: "capturing", screenshotMessage: null });
+    const outcome = await captureWithinLimit({
+      capture: this.capture,
+      reencode: this.reencode,
+      limitBytes: this.screenshotLimitBytes
+    });
+    if (generation === this.captureGeneration && this.state.open) {
+      this.applyScreenshot(outcome.screenshot, outcome.failed);
+    }
+  }
+  applyScreenshot(shot, failed) {
+    if (shot && !failed) {
+      this.patch({ screenshot: shot, screenshotStatus: "ready", screenshotMessage: null, pin: null });
+      return;
+    }
+    this.patch({
+      screenshot: null,
+      screenshotStatus: "failed",
+      screenshotMessage: SCREENSHOT_FAILED_MESSAGE,
+      pin: null
+    });
+  }
+  // ── 포커스 ────────────────────────────────────────────────────────────────
+  tabNext() {
+    const next = this.ring.next();
+    this.patch({ focused: next });
+    return next;
+  }
+  tabPrev() {
+    const prev = this.ring.prev();
+    this.patch({ focused: prev });
+    return prev;
+  }
+  focus(id) {
+    const ok = this.ring.focus(id);
+    if (ok) this.patch({ focused: this.ring.current });
+    return ok;
+  }
+  // ── 전송 ──────────────────────────────────────────────────────────────────
+  /**
+   * 제출. 실패해도 예외를 던지지 않는다 — 대기 큐에 남기고 입력을 보존한다.
+   * @returns 검증에 걸려 아무것도 보내지 않았으면 `null`.
+   */
+  async submit() {
+    this.submitAttempted = true;
+    if (this.state.submitStatus === "sending" || this.state.submitStatus === "pending") return null;
+    if (!this.isCommentValid()) {
+      this.recompute();
+      this.emit();
+      return null;
+    }
+    this.patch({ submitStatus: "sending", submitMessage: null });
+    const parts = {
+      kind: "report",
+      comment: this.state.comment,
+      priority: this.state.priority,
+      screenshot: this.state.screenshot,
+      pin: this.state.pin,
+      element: null
+    };
+    let outcome;
+    try {
+      const report = await this.createReport(parts);
+      this.lastReport = report;
+      outcome = await this.queue.submit(report);
+    } catch {
+      outcome = { delivered: false, id: null, queued: false };
+    }
+    if (outcome.delivered) {
+      this.patch({ submitStatus: "sent", submitMessage: SUBMIT_DONE_MESSAGE });
+      this.close({ keepResult: true });
+    } else if (outcome.queued) {
+      this.patch({ submitStatus: "pending", submitMessage: SUBMIT_PENDING_MESSAGE });
+    } else {
+      this.patch({ submitStatus: "failed", submitMessage: SUBMIT_FAILED_MESSAGE });
+    }
+    return outcome;
+  }
+  /** [다시 보내기]. 큐가 비면 완료로 넘어간다. */
+  async retry() {
+    if (this.state.submitStatus !== "pending" && this.state.pending === 0) return;
+    const retryingCurrent = this.state.submitStatus === "pending";
+    if (retryingCurrent) this.patch({ submitStatus: "sending", submitMessage: null });
+    try {
+      await this.queue.retryNow();
+    } catch {
+    }
+    const remaining = await this.queue.size();
+    if (!retryingCurrent) {
+      this.patch({ pending: remaining });
+    } else {
+      const outcome = this.lastReport ? this.queue.getOutcome?.(this.lastReport.clientSubmissionId) ?? null : null;
+      const delivered = outcome?.delivered === true;
+      const rejected = outcome?.delivered === false;
+      const legacyDrained = !this.queue.getOutcome && remaining === 0;
+      if (delivered || legacyDrained) {
+        this.patch({ submitStatus: "sent", submitMessage: SUBMIT_DONE_MESSAGE });
+        this.close({ keepResult: true });
+      } else if (rejected) {
+        this.patch({ submitStatus: "failed", submitMessage: SUBMIT_FAILED_MESSAGE });
+      } else {
+        this.patch({ submitStatus: "pending", submitMessage: SUBMIT_PENDING_MESSAGE });
+      }
+    }
+  }
+  // ── 내부 ──────────────────────────────────────────────────────────────────
+  isCommentValid() {
+    const value = this.state.comment;
+    return value.trim().length > 0 && value.length <= COMMENT_MAX_CHARS;
+  }
+  isDraftLocked() {
+    return this.state.submitStatus === "sending" || this.state.submitStatus === "pending";
+  }
+  commentErrorFor() {
+    const value = this.state.comment;
+    if (value.length > COMMENT_MAX_CHARS) return COMMENT_TOO_LONG_MESSAGE;
+    if (value.trim().length === 0) {
+      return this.touched || this.submitAttempted ? COMMENT_REQUIRED_MESSAGE : null;
+    }
+    return null;
+  }
+  actionsFor() {
+    return this.platform === "web" ? [MODAL_ACTION_PICK] : [MODAL_ACTION_PIN];
+  }
+  focusOrderFor() {
+    const order = [MODAL_FIELD_COMMENT, MODAL_FIELD_PRIORITY];
+    if (this.state.screenshot) order.push(MODAL_ACTION_REMOVE_SCREENSHOT);
+    else order.push(MODAL_ACTION_ATTACH);
+    order.push(...this.actionsFor());
+    if (this.state.submitStatus === "pending") order.push(MODAL_ACTION_RETRY);
+    order.push(MODAL_ACTION_CANCEL, MODAL_ACTION_SEND);
+    return order;
+  }
+  recompute() {
+    const commentError = this.commentErrorFor();
+    const canSubmit = this.isCommentValid() && this.state.screenshotStatus !== "capturing" && (this.state.submitStatus === "idle" || this.state.submitStatus === "failed");
+    const canPin = this.platform === "native" && this.state.screenshot !== null && this.state.screenshotStatus !== "capturing" && !this.isDraftLocked() && this.state.open;
+    const actions = this.actionsFor();
+    const focusOrder = this.state.open ? this.focusOrderFor() : [];
+    this.ring.setItems(focusOrder);
+    this.state = {
+      ...this.state,
+      commentError,
+      canSubmit,
+      canPin,
+      showRetry: this.state.submitStatus === "pending" || this.state.pending > 0,
+      actions,
+      focusOrder,
+      focused: this.state.open ? this.ring.current : null
+    };
+  }
+  patch(partial) {
+    this.state = { ...this.state, ...partial };
+    this.recompute();
+    this.emit();
+  }
+  emit() {
+    for (const listener of this.listeners) listener(this.state);
+  }
+};
+
+// src/widget/controller.ts
+var WidgetController = class {
+  constructor(opts) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.platform = opts.platform;
+    this.onPickingChange = opts.onPickingChange ?? null;
+    this.modal = new ReportModalController(opts);
+    this.pin = new PinController(null);
+    opts.queue.start?.();
+    this.picking = opts.initialPicking ?? false;
+    this.screen = this.picking ? "picking" : "button";
+    this.unsubscribeModal = this.modal.subscribe((state) => {
+      if (state.pin === null && this.pin.confirmed !== null) this.pin.reset();
+      if (!state.open && (this.screen === "modal" || this.screen === "pin")) {
+        this.screen = this.picking ? "picking" : "button";
+      }
+      this.emit();
+    });
+  }
+  // ── 조회 ──────────────────────────────────────────────────────────────────
+  getScreen() {
+    return this.screen;
+  }
+  getState() {
+    return {
+      screen: this.screen,
+      modal: this.modal.getState(),
+      pinDraft: this.pin.draft,
+      pinConfirmed: this.pin.confirmed,
+      pickingActive: this.picking
+    };
+  }
+  get isPicking() {
+    return this.picking;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.getState());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  dispose() {
+    this.unsubscribeModal();
+    this.modal.dispose();
+    this.modal.stopQueue();
+    this.listeners.clear();
+  }
+  // ── 플로팅 버튼 ↔ 모달 ────────────────────────────────────────────────────
+  async openReport() {
+    this.screen = "modal";
+    await this.modal.open();
+    this.emit();
+  }
+  /** 모달 닫기 요청. 쓰던 내용이 있으면 확인부터 받는다(화면은 그대로 모달). */
+  closeReport() {
+    const result = this.modal.requestClose();
+    if (result === "closed") {
+      this.pin.reset();
+      this.screen = this.picking ? "picking" : "button";
+    }
+    this.emit();
+    return result;
+  }
+  confirmCloseReport() {
+    this.modal.confirmClose();
+    this.pin.reset();
+    this.screen = this.picking ? "picking" : "button";
+    this.emit();
+  }
+  cancelCloseReport() {
+    this.modal.cancelClose();
+    this.emit();
+  }
+  async submitReport() {
+    const outcome = await this.modal.submit();
+    if (outcome?.delivered) this.pin.reset();
+    this.emit();
+    return outcome;
+  }
+  async retryReport() {
+    await this.modal.retry();
+    this.emit();
+  }
+  // ── 핀 지정 ───────────────────────────────────────────────────────────────
+  /**
+   * 핀 지정 화면 열기. 스크린샷이 없으면 좌표가 가리킬 대상이 없으므로 열지 않는다.
+   * @returns 열렸으면 true.
+   */
+  openPinScreen() {
+    if (!this.modal.getState().canPin) return false;
+    this.pin.open();
+    this.screen = "pin";
+    this.emit();
+    return true;
+  }
+  /** 핀 지정 화면에서 탭. 기존 핀이 있으면 그 자리로 옮긴다. */
+  placePin(point, size) {
+    if (this.screen !== "pin") return null;
+    const placed = this.pin.place(point, size);
+    this.emit();
+    return placed;
+  }
+  /** 확정 — 모달로 돌아가고 좌표가 제출에 실린다. */
+  confirmPin() {
+    if (this.screen !== "pin") return this.pin.confirmed;
+    const confirmed = this.pin.confirm();
+    this.modal.setPin(confirmed);
+    this.screen = "modal";
+    this.emit();
+    return confirmed;
+  }
+  /** 취소 — 이전 확정 좌표를 그대로 두고 모달로 돌아간다. */
+  cancelPin() {
+    if (this.screen !== "pin") return this.pin.confirmed;
+    const previous = this.pin.cancel();
+    this.modal.setPin(previous);
+    this.screen = "modal";
+    this.emit();
+    return previous;
+  }
+  // ── 요소 지목 (웹 전용) ───────────────────────────────────────────────────
+  /**
+   * 요소 지목 모드 시작. 모달에서 넘어오는 흐름이라 닫기 확인을 묻지 않는다
+   * (사용자가 이미 "지목하러 가겠다"고 밝힌 상태다).
+   */
+  startPicking() {
+    if (this.platform !== "web") return false;
+    this.modal.dismiss();
+    this.setPicking(true);
+    this.screen = "picking";
+    this.emit();
+    return true;
+  }
+  /** [지목 종료]. 플로팅 버튼 화면으로 돌아가고 저장된 모드 표시도 지운다. */
+  stopPicking() {
+    this.setPicking(false);
+    if (this.screen === "picking") this.screen = "button";
+    this.emit();
+  }
+  setPicking(active) {
+    if (this.picking === active) return;
+    this.picking = active;
+    this.onPickingChange?.(active);
+  }
+  emit() {
+    const state = this.getState();
+    for (const listener of this.listeners) listener(state);
+  }
+};
+
+// src/adapters/body.ts
+var DETAILS_OPEN = "<details>";
+var DETAILS_SUMMARY = "<summary>\uC9C4\uB2E8 \uC815\uBCF4</summary>";
+var DETAILS_CLOSE = "</details>";
+var TITLE_MAX_CHARS = 80;
+var KIND_LABEL = {
+  report: "\uC81C\uBCF4",
+  annotation: "\uC694\uC18C \uC8FC\uC11D"
+};
+var PRIORITY_LABEL = {
+  unset: "\uBBF8\uC9C0\uC815",
+  normal: "\uBCF4\uD1B5",
+  high: "\uB192\uC74C",
+  urgent: "\uAE34\uAE09"
+};
+function inline(value) {
+  return value.replace(/</g, "&lt;").replace(/[\r\n\t]+/g, " ").trim();
+}
+function kv(label, value) {
+  if (value === null || value === void 0) return null;
+  const text = inline(value);
+  return text.length > 0 ? `- ${label}: ${text}` : null;
+}
+function json(value) {
+  try {
+    const text = JSON.stringify(value);
+    return text === void 0 || text === "{}" ? null : text;
+  } catch {
+    return "(\uC9C1\uB82C\uD654 \uBD88\uAC00)";
+  }
+}
+function approxBytesOfBase64(b64) {
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(b64.length * 3 / 4) - padding);
+}
+function humanBytes(n) {
+  return n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`;
+}
+function formatSource(s) {
+  const file = s.sourceFile;
+  const line = typeof s.sourceLine === "number" ? s.sourceLine : null;
+  const filePart = file ? line === null ? file : `${file}:${line}` : null;
+  if (filePart && s.screenId) return `${filePart} (\uD654\uBA74 ${s.screenId})`;
+  if (filePart) return filePart;
+  return s.screenId ? `\uD654\uBA74 ${s.screenId}` : null;
+}
+function formatUser(u) {
+  if (!u) return null;
+  const bits = [u.id ?? "(\uBBF8\uC0C1)"];
+  if (u.name) bits.push(u.name);
+  if (u.email) bits.push(u.email);
+  if (u.role) bits.push(`\uC5ED\uD560 ${u.role}`);
+  if (u.isGuest) bits.push("\uAC8C\uC2A4\uD2B8");
+  return bits.join(" \xB7 ");
+}
+function elementSelector(el) {
+  if (el.selector) return el.selector;
+  let out = el.tag;
+  if (el.id) out += `#${el.id}`;
+  if (el.className) {
+    for (const cls of el.className.split(/\s+/)) {
+      if (cls) out += `.${cls}`;
+    }
+  }
+  return out;
+}
+function formatAppInfo(a) {
+  const bits = [];
+  if (a.version) bits.push(a.version);
+  if (a.channel) bits.push(`\uCC44\uB110 ${a.channel}`);
+  if (a.runtimeVersion) bits.push(`\uB7F0\uD0C0\uC784 ${a.runtimeVersion}`);
+  if (a.updateId) bits.push(`\uC5C5\uB370\uC774\uD2B8 ${a.updateId}`);
+  return bits.length > 0 ? bits.join(" \xB7 ") : null;
+}
+function formatDevice(d) {
+  const bits = [];
+  if (d.model) bits.push(d.model);
+  if (d.osName || d.osVersion) bits.push([d.osName, d.osVersion].filter(Boolean).join(" "));
+  if (d.deviceType) bits.push(d.deviceType);
+  return bits.length > 0 ? bits.join(" \xB7 ") : null;
+}
+function formatDisplay(d) {
+  const bits = [];
+  if (d.width !== null && d.height !== null) bits.push(`${d.width}\xD7${d.height}`);
+  if (d.pixelRatio !== null) bits.push(`@${d.pixelRatio}x`);
+  if (d.fontScale !== null) bits.push(`\uAE00\uAF34 \uBC30\uC728 ${d.fontScale}`);
+  return bits.length > 0 ? bits.join(" \xB7 ") : null;
+}
+function formatViewport(v) {
+  const bits = [];
+  if (v.width !== null && v.height !== null) bits.push(`${v.width}\xD7${v.height}`);
+  if (v.devicePixelRatio !== null) bits.push(`@${v.devicePixelRatio}x`);
+  return bits.length > 0 ? bits.join(" \xB7 ") : null;
+}
+function detailLines(report) {
+  const c = report.context;
+  const out = [];
+  out.push(kv("\uC885\uB958", KIND_LABEL[report.kind]));
+  out.push(kv("\uC6B0\uC120\uC21C\uC704", PRIORITY_LABEL[report.priority]));
+  out.push(kv("\uC81C\uCD9C ID", report.clientSubmissionId));
+  out.push(kv("\uC791\uC131 \uC2DC\uAC01", report.createdAt));
+  out.push(kv("\uC571", c.app));
+  out.push(kv("\uD50C\uB7AB\uD3FC", c.platform));
+  out.push(kv("\uD654\uBA74", c.screen));
+  out.push(kv("URL", c.url));
+  out.push(kv("\uC18C\uC2A4", formatSource(c.source)));
+  out.push(kv("\uC0AC\uC6A9\uC790", formatUser(c.user)));
+  out.push(kv("\uC138\uC158", c.sessionId));
+  out.push(
+    kv("\uC218\uC9D1 \uC2DC\uAC01", c.timezone ? `${c.clientTimestamp} (${c.timezone})` : c.clientTimestamp)
+  );
+  if (report.element) {
+    const el = report.element;
+    out.push(kv("\uC694\uC18C", elementSelector(el)));
+    out.push(kv("\uC694\uC18C CSS \uACBD\uB85C", el.selector ?? null));
+    out.push(kv("\uC694\uC18C \uC18C\uC2A4", formatSource(sourceFromElement(el))));
+    out.push(kv("\uC694\uC18C \uD14D\uC2A4\uD2B8", el.text));
+    if (el.boundingBox) {
+      const b = el.boundingBox;
+      out.push(
+        kv(
+          "\uC694\uC18C \uC704\uCE58",
+          `x ${Math.round(b.x)} \xB7 y ${Math.round(b.y)} \xB7 ${Math.round(b.width)}\xD7${Math.round(
+            b.height
+          )}`
+        )
+      );
+    }
+    out.push(kv("\uC694\uC18C \uC18D\uC131", json(el.attributes)));
+  }
+  if (report.pin) {
+    out.push(kv("\uD540", `x ${report.pin.x.toFixed(3)} \xB7 y ${report.pin.y.toFixed(3)} (0~1 \uC815\uADDC\uD654)`));
+  }
+  if (report.screenshot) {
+    const bytes = approxBytesOfBase64(report.screenshot.base64);
+    out.push(kv("\uC2A4\uD06C\uB9B0\uC0F7", `${report.screenshot.contentType} \xB7 \uC57D ${humanBytes(bytes)}`));
+  }
+  if (c.native) {
+    const n = c.native;
+    out.push(kv("\uD654\uBA74 \uACBD\uB85C", n.screenPath));
+    out.push(kv("\uB0B4\uBE44 \uC2A4\uD0DD", n.navPath.length > 0 ? n.navPath.join(" \u203A ") : null));
+    out.push(kv("\uB77C\uC6B0\uD2B8 \uD30C\uB77C\uBBF8\uD130", n.routeParams ? json(n.routeParams) : null));
+    out.push(kv("\uC571 \uBC84\uC804", formatAppInfo(n.appInfo)));
+    out.push(kv("\uAE30\uAE30", formatDevice(n.device)));
+    out.push(kv("\uB514\uC2A4\uD50C\uB808\uC774", formatDisplay(n.display)));
+  }
+  if (c.web) {
+    out.push(kv("\uBDF0\uD3EC\uD2B8", formatViewport(c.web.viewport)));
+    out.push(kv("UA", c.web.userAgent));
+  }
+  const extra = json(c.extra);
+  out.push(kv("\uCD94\uAC00", extra));
+  if (c.diagnostics === null) {
+    out.push("- \uC9C4\uB2E8: \uC218\uC9D1\uD558\uC9C0 \uC54A\uC74C");
+  } else {
+    const { network, logs } = c.diagnostics;
+    out.push(`- \uC9C4\uB2E8 \uB124\uD2B8\uC6CC\uD06C (${network.length}\uAC74)`);
+    for (const e of network) {
+      const status = e.status === null ? "\uC2E4\uD328" : String(e.status);
+      out.push(`  - ${inline(`${e.method} ${e.url}`)} \u2192 ${status} \xB7 ${e.durationMs}ms \xB7 ${e.at}`);
+    }
+    out.push(`- \uC9C4\uB2E8 \uB85C\uADF8 (${logs.length}\uAC74)`);
+    for (const e of logs) {
+      out.push(`  - [${e.level}] ${inline(e.message)} \xB7 ${e.at}`);
+    }
+  }
+  return out.filter((line) => line !== null);
+}
+function renderReportBody(report) {
+  const comment = report.comment.trim().length > 0 ? report.comment.trimEnd() : "(\uCF54\uBA58\uD2B8 \uC5C6\uC74C)";
+  return [
+    comment,
+    "",
+    DETAILS_OPEN,
+    DETAILS_SUMMARY,
+    "",
+    ...detailLines(report),
+    "",
+    DETAILS_CLOSE
+  ].join("\n");
+}
+function buildTitle(report) {
+  const firstLine = report.comment.split("\n").find((l) => l.trim().length > 0);
+  const fallback = `${KIND_LABEL[report.kind]} \u2014 ${report.context.screen ?? report.context.url ?? report.context.app}`;
+  const base = inline(firstLine ?? fallback) || fallback;
+  return base.length > TITLE_MAX_CHARS ? `${base.slice(0, TITLE_MAX_CHARS - 1)}\u2026` : base;
+}
+
+// src/adapters/linear.ts
+function buildLinearIssue(report) {
+  return {
+    title: buildTitle(report),
+    description: renderReportBody(report)
+  };
+}
+
+// src/adapters/notion.ts
+function buildNotionPage(report) {
+  return {
+    title: buildTitle(report),
+    content: renderReportBody(report)
+  };
+}
+
+// src/adapters/lasso.ts
+var LASSO_DEFAULT_ENDPOINT = "/api/feedback";
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+function resolveFetch(injected) {
+  if (injected) return injected;
+  const g = globalThis;
+  return typeof g.fetch === "function" ? g.fetch : null;
+}
+function absoluteEndpoint(endpoint) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(endpoint)) return endpoint;
+  const origin = globalThis.location?.origin;
+  if (typeof origin !== "string" || origin.length === 0) return null;
+  return endpoint.startsWith("/") ? `${origin}${endpoint}` : `${origin}/${endpoint}`;
+}
+function parseRetryAfterMs(res) {
+  const raw = res.headers?.get("Retry-After") ?? null;
+  if (raw === null) return null;
+  const seconds = Number(raw.trim());
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : null;
+}
+function fail(retryable, extra) {
+  return { ok: false, id: null, retryable, retryAfterMs: null, ...extra };
+}
+function idFrom(parsed) {
+  const annotationId = parsed.annotationId;
+  if (typeof annotationId === "string" && annotationId.length > 0) return annotationId;
+  const direct = parsed.id;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  const data = parsed.data;
+  if (data && typeof data === "object") {
+    const nested = data.id;
+    if (typeof nested === "string" && nested.length > 0) return nested;
+  }
+  return null;
+}
+function buildLassoEnvelope(report) {
+  const c = report.context;
+  const clientType = c.platform === "native" ? "app" : "web";
+  const parsed = Date.parse(report.createdAt);
+  const timestamp = Number.isFinite(parsed) ? parsed : 0;
+  const el = report.element;
+  if (report.kind === "annotation") {
+    return {
+      clientSubmissionId: report.clientSubmissionId,
+      clientType,
+      event: "annotation.add",
+      timestamp,
+      url: c.url ?? "",
+      priority: report.priority,
+      annotation: {
+        id: report.clientSubmissionId,
+        comment: renderReportBody(report),
+        x: report.pin?.x ?? null,
+        y: report.pin?.y ?? null,
+        element: el ? el.tag : null,
+        elementPath: el?.attributes["data-feedback-source"] ?? null,
+        selectedText: el?.text ?? null,
+        boundingBox: el?.boundingBox ?? null,
+        timestamp
+      }
+    };
+  }
+  return {
+    clientSubmissionId: report.clientSubmissionId,
+    clientType,
+    event: "report.create",
+    timestamp,
+    // 앱에는 URL 이 없다 — 화면 이름을 app:// 경로로 싣는다(서버가 그대로 저장한다).
+    url: c.url ?? (clientType === "app" ? `app://${c.screen ?? "unknown"}` : ""),
+    priority: report.priority,
+    report: {
+      comment: renderReportBody(report),
+      pin: report.pin ? { x: report.pin.x, y: report.pin.y } : null,
+      sourceFile: el?.attributes["data-feedback-source"] ?? null,
+      screenshotBase64: report.screenshot?.base64 ?? null,
+      screenshotContentType: report.screenshot?.contentType ?? null,
+      // 서버가 없으면 빈 배열로 취급하지만, 미연동과 "없었음"을 구분해 보낸다.
+      network: report.context.diagnostics?.network ?? [],
+      logs: report.context.diagnostics?.logs ?? []
+    }
+  };
+}
+function createLassoAdapter(opts = {}) {
+  const token = opts.token ?? null;
+  const endpoint = opts.endpoint && opts.endpoint.trim().length > 0 ? opts.endpoint.trim() : LASSO_DEFAULT_ENDPOINT;
+  const warn = opts.warn ?? null;
+  const emit = (message) => {
+    if (!warn) return;
+    try {
+      warn(message);
+    } catch {
+    }
+  };
+  return {
+    async submit(report) {
+      const url = absoluteEndpoint(endpoint);
+      if (url === null) {
+        emit(
+          `feedback-kit: endpoint "${endpoint}" \uB97C \uC808\uB300 URL \uB85C \uB9CC\uB4E4 \uC218 \uC5C6\uB2E4(\uC624\uB9AC\uC9C4 \uC5C6\uC74C). \uC571\uC5D0\uC11C\uB294 endpoint \uB97C \uC808\uB300 URL \uB85C \uC9C0\uC815\uD574\uC57C \uD55C\uB2E4.`
+        );
+        return fail(false);
+      }
+      const sender = resolveFetch(opts.fetch);
+      if (sender === null) {
+        emit("feedback-kit: fetch \uB97C \uCC3E\uC9C0 \uBABB\uD588\uB2E4(\uC804\uC1A1\uC744 \uBBF8\uB8EC\uB2E4).");
+        return fail(true);
+      }
+      const body = JSON.stringify(buildLassoEnvelope(report));
+      const headers = {
+        "Content-Type": "application/json",
+        // 재시도가 중복 제보가 되지 않게. 코어가 같은 항목을 다시 보내도 키는 그대로다.
+        "Idempotency-Key": report.clientSubmissionId
+      };
+      if (token !== null) headers.Authorization = `Bearer ${token}`;
+      let res;
+      try {
+        res = await sender(url, {
+          method: "POST",
+          headers,
+          body,
+          // 페이지를 즉시 이탈해도 전송이 끝나게. 본문이 한도를 넘으면 브라우저가
+          // 요청 자체를 거절하므로 크기를 보고 켠다.
+          keepalive: canUseKeepalive(byteLengthOf(body))
+        });
+      } catch {
+        emit("feedback-kit: \uC804\uC1A1\uC5D0 \uC2E4\uD328\uD588\uB2E4(\uB124\uD2B8\uC6CC\uD06C). \uD050\uC5D0 \uB0A8\uACA8 \uB2E4\uC2DC \uC2DC\uB3C4\uD55C\uB2E4.");
+        return fail(true);
+      }
+      const status = res.status;
+      if (status < 200 || status >= 300) {
+        if (status === 429) {
+          emit("feedback-kit: \uC218\uC9D1 \uD55C\uB3C4\uC5D0 \uAC78\uB838\uB2E4(429). \uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD55C\uB2E4.");
+          return fail(true, { retryAfterMs: parseRetryAfterMs(res), rateLimited: true });
+        }
+        const retryable = RETRYABLE_STATUS.has(status);
+        emit(
+          `feedback-kit: \uC218\uC9D1 \uC751\uB2F5 ${status}${retryable ? " (\uB2E4\uC2DC \uC2DC\uB3C4\uD55C\uB2E4)" : " (\uC7AC\uC2DC\uB3C4\uD558\uC9C0 \uC54A\uB294\uB2E4)"}`
+        );
+        return fail(retryable, { retryAfterMs: retryable ? parseRetryAfterMs(res) : null });
+      }
+      let parsed;
+      try {
+        const text = await res.text();
+        const value = JSON.parse(text);
+        if (value === null || typeof value !== "object") throw new Error("\uAC1D\uCCB4\uAC00 \uC544\uB2D8");
+        parsed = value;
+      } catch {
+        emit(`feedback-kit: \uC218\uC9D1 \uC751\uB2F5 ${status} \uC758 \uBCF8\uBB38\uC744 \uC77D\uC9C0 \uBABB\uD588\uB2E4. \uB2E4\uC2DC \uC2DC\uB3C4\uD55C\uB2E4.`);
+        return fail(true);
+      }
+      if (parsed.ok !== true) {
+        emit(`feedback-kit: \uC218\uC9D1 \uC11C\uBC84\uAC00 \uC81C\uBCF4\uB97C \uAC70\uC808\uD588\uB2E4(${status}). \uC7AC\uC2DC\uB3C4\uD558\uC9C0 \uC54A\uB294\uB2E4.`);
+        return fail(false);
+      }
+      return { ok: true, id: idFrom(parsed), retryable: false, retryAfterMs: null };
+    }
+  };
+}
+export {
+  BACKOFF_BASE_MS,
+  BACKOFF_MAX_MS,
+  COMMENT_MAX_CHARS,
+  COMMENT_REQUIRED_MESSAGE,
+  COMMENT_TOO_LONG_MESSAGE,
+  DEFAULT_ADAPTER,
+  DEFAULT_INTERNAL_ROLES,
+  DEFAULT_POSITION,
+  DiagnosticsCollector,
+  ENDPOINT_FROM_ADAPTER,
+  FLOATING_BUTTON_ID,
+  FeedbackQueue,
+  FocusRing,
+  KEEPALIVE_BODY_LIMIT_BYTES,
+  LASSO_DEFAULT_ENDPOINT,
+  LOG_BUFFER_LIMIT,
+  MAX_LOG_MESSAGE_CHARS,
+  MAX_QUEUE_AGE_MS,
+  MAX_QUEUE_ITEMS,
+  MODAL_ACTION_ATTACH,
+  MODAL_ACTION_CANCEL,
+  MODAL_ACTION_PICK,
+  MODAL_ACTION_PIN,
+  MODAL_ACTION_REMOVE_SCREENSHOT,
+  MODAL_ACTION_RETRY,
+  MODAL_ACTION_SEND,
+  MODAL_FIELD_COMMENT,
+  MODAL_FIELD_PRIORITY,
+  NETWORK_BUFFER_LIMIT,
+  PinController,
+  RATE_LIMIT_MIN_DELAY_MS,
+  REDACTED,
+  ReportModalController,
+  RingBuffer,
+  SCREENSHOT_FAILED_MESSAGE,
+  SCREENSHOT_MAX_BASE64_BYTES,
+  SCREENSHOT_QUALITY_STEPS,
+  SOURCE_ATTR,
+  SUBMIT_DONE_MESSAGE,
+  SUBMIT_FAILED_MESSAGE,
+  SUBMIT_PENDING_MESSAGE,
+  TITLE_MAX_CHARS,
+  WidgetController,
+  buildContext,
+  buildLassoEnvelope,
+  buildLinearIssue,
+  buildNotionPage,
+  buildReport,
+  buildTitle,
+  byteLengthOf,
+  canUseKeepalive,
+  captureWithinLimit,
+  createLassoAdapter,
+  defaultBackoff,
+  denormalizePin,
+  detectDevBuild,
+  diagnosticsProviderFor,
+  getOrCreateGuestId,
+  guestUser,
+  isInternalUser,
+  normalizePin,
+  normalizeUser,
+  parseSourceAttr,
+  renderReportBody,
+  resolveConfig,
+  resolveContextUser,
+  sanitizeUrl,
+  screenshotBytes,
+  sharedDiagnostics,
+  shouldShowWidget,
+  sourceFromElement,
+  uuidv4
+};
+//# sourceMappingURL=index.js.map