issue-sticker 0.10.0 → 0.12.0

package/dist/{externalUserPayload-DNGAp9bP.js → externalUserPayload-DWcXyz2U.js}

@@ -1,7 +1,7 @@
-import { t as getCanvasSource, v as onCanvasSourceRegistered, C as CANVAS_INTERACTION_TAG, w as gzip_1, R as REPLAY_EVENT_TYPE, x as record, a as cn, p as useCallbackRef$1, i as useComposedRefs, f as Primitive, P as Presence, j as Portal$1, g as composeEventHandlers, k as createContextScope, l as createSlot, D as DismissableLayer, y as Content, z as createPopperScope, m as useControllableState, A as Root2$1, n as useId, B as Anchor, E as Arrow, d as usePortalContainer, e as OVERLAY_LAYER, s as stopEscapePropagation, o as useLayoutEffect2, V as VISUALLY_HIDDEN_STYLES, c as createLucideIcon, F as clsx, S as Slot$2, O as OVERLAY_LAYER_INDEX, M as MousePointer2 } from "./three-_bdgDAmI.js";
+import { t as getCanvasSource, v as onCanvasSourceRegistered, C as CANVAS_INTERACTION_TAG, w as gzip_1, R as REPLAY_EVENT_TYPE, x as record, a as cn, p as useCallbackRef$1, k as useComposedRefs, h as Primitive, P as Presence, l as Portal$1, i as composeEventHandlers, m as createContextScope, n as createSlot, D as DismissableLayer, y as Content, z as createPopperScope, A as Anchor, f as useControllableState, B as Root2$1, g as useId, E as Arrow, d as usePortalContainer, e as OVERLAY_LAYER, s as stopEscapePropagation, o as useLayoutEffect2, V as VISUALLY_HIDDEN_STYLES, c as createLucideIcon, F as clsx, S as Slot$2, O as OVERLAY_LAYER_INDEX, M as MousePointer2 } from "./three-B228j4M6.js";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import * as React from "react";
-import React__default, { useState, createContext, useContext, useCallback, useRef, useLayoutEffect, useEffect, useMemo } from "react";
+import React__default, { useState, useRef, useEffect, useCallback, createContext, useContext, useLayoutEffect, useMemo } from "react";
 import * as ReactDOM from "react-dom";
 const DEFAULT_MAX_DURATION_MS = 12e4;
 const MIME_TYPE_CANDIDATES = ["video/webm;codecs=vp9", "video/webm"];
@@ -83,7 +83,8 @@ class ScreenRecordingController {
       const mimeType = chooseMimeType(this.isTypeSupported);
       const mediaRecorder = this.createMediaRecorder(stream, {
         mimeType,
-        videoBitsPerSecond: 25e5
+        // 실측(VP9, 2배율, 계속 스크롤): 1.5Mbps 에서 12px 글자 손상 없음, 1.0Mbps 는 잔상.
+        videoBitsPerSecond: 15e5
       });
       this.mediaRecorder = mediaRecorder;
       mediaRecorder.ondataavailable = (event) => {
@@ -894,7 +895,7 @@ function settleFrame() {
 async function resolveNodeId(canvas) {
   var _a;
   try {
-    const { record: record2 } = await import("./three-_bdgDAmI.js").then((n) => n.I);
+    const { record: record2 } = await import("./three-B228j4M6.js").then((n) => n.I);
     const id = (_a = record2.mirror) == null ? void 0 : _a.getId(canvas);
     return typeof id === "number" && id > 0 ? id : null;
   } catch {
@@ -913,7 +914,7 @@ function startCanvasInteractionTracking(options = {}) {
   const lastSnapshot = /* @__PURE__ */ new WeakMap();
   let pending = null;
   const emit2 = options.emit ?? ((tag, payload) => {
-    void import("./three-_bdgDAmI.js").then((n) => n.I).then(({ addCustomEvent }) => addCustomEvent(tag, payload));
+    void import("./three-B228j4M6.js").then((n) => n.I).then(({ addCustomEvent }) => addCustomEvent(tag, payload));
   });
   const pointerOf = (started, rect) => [
     (started.x - rect.left) / rect.width * 2 - 1,
@@ -1184,10 +1185,6 @@ function dropEventsAfter(segments, cutoff) {
   return segments.map((s2) => ({ events: s2.events.filter((e2) => e2.timestamp <= cutoff) })).filter((s2) => s2.events.length > 0);
 }
 const REPLAY_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
-async function sha256Hex$1(bytes) {
-  const digest = await crypto.subtle.digest("SHA-256", bytes.buffer);
-  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
 async function serializeSnapshot(input) {
   const redact = input.redactEvents ?? ((e2) => e2);
   const maxBytes = input.maxBytes ?? REPLAY_SNAPSHOT_MAX_BYTES;
@@ -1201,10 +1198,8 @@ async function serializeSnapshot(input) {
     segments = segments.slice(1);
     ({ events, payload } = compress2(segments));
   }
-  const checksumSha256 = await sha256Hex$1(payload);
   return {
     payload,
-    checksumSha256,
     windowSeconds: spanSeconds(segments),
     eventCount: events.length,
     sizeBytes: payload.byteLength,
@@ -2065,8 +2060,8 @@ class WebSocketCollector {
 }
 const LOG_BACKUP_SESSION_KEY = "__issueStickerLogSession";
 const DB_NAME$1 = "issue-sticker-logs";
-const DB_VERSION$1 = 1;
-const STORE_NAME$1 = "sessions";
+const DB_VERSION$2 = 1;
+const STORE_NAME$2 = "sessions";
 const LOG_BACKUP_TTL_MS = 24 * 60 * 60 * 1e3;
 const LOG_BACKUP_BUDGET_BYTES = 8 * 1024 * 1024;
 function jsonLength(value) {
@@ -2147,12 +2142,12 @@ function requestToPromise$1(request) {
     request.onerror = () => reject(request.error);
   });
 }
-function openDatabase$1() {
+function openDatabase$2() {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME$1, DB_VERSION$1);
+    const request = indexedDB.open(DB_NAME$1, DB_VERSION$2);
     request.onupgradeneeded = () => {
-      if (!request.result.objectStoreNames.contains(STORE_NAME$1)) {
-        request.result.createObjectStore(STORE_NAME$1, { keyPath: "sessionId" });
+      if (!request.result.objectStoreNames.contains(STORE_NAME$2)) {
+        request.result.createObjectStore(STORE_NAME$2, { keyPath: "sessionId" });
       }
     };
     request.onsuccess = () => {
@@ -2167,10 +2162,10 @@ function openDatabase$1() {
 function createIndexedDbLogBackup() {
   return {
     async load(sessionId) {
-      const db = await openDatabase$1();
+      const db = await openDatabase$2();
       try {
         const record2 = await requestToPromise$1(
-          db.transaction(STORE_NAME$1, "readonly").objectStore(STORE_NAME$1).get(sessionId)
+          db.transaction(STORE_NAME$2, "readonly").objectStore(STORE_NAME$2).get(sessionId)
         );
         if (!record2) return null;
         if (record2.expiresAt <= Date.now()) return null;
@@ -2180,7 +2175,7 @@ function createIndexedDbLogBackup() {
       }
     },
     async save(sessionId, payload) {
-      const db = await openDatabase$1();
+      const db = await openDatabase$2();
       try {
         const record2 = {
           sessionId,
@@ -2188,16 +2183,16 @@ function createIndexedDbLogBackup() {
           expiresAt: Date.now() + LOG_BACKUP_TTL_MS
         };
         await requestToPromise$1(
-          db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1).put(record2)
+          db.transaction(STORE_NAME$2, "readwrite").objectStore(STORE_NAME$2).put(record2)
         );
       } finally {
         db.close();
       }
     },
     async prune() {
-      const db = await openDatabase$1();
+      const db = await openDatabase$2();
       try {
-        const store = db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1);
+        const store = db.transaction(STORE_NAME$2, "readwrite").objectStore(STORE_NAME$2);
         const records = await requestToPromise$1(store.getAll());
         const now = Date.now();
         const expired = records.filter((record2) => record2.expiresAt <= now);
@@ -2210,10 +2205,10 @@ function createIndexedDbLogBackup() {
       }
     },
     async clear(sessionId) {
-      const db = await openDatabase$1();
+      const db = await openDatabase$2();
       try {
         await requestToPromise$1(
-          db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1).delete(sessionId)
+          db.transaction(STORE_NAME$2, "readwrite").objectStore(STORE_NAME$2).delete(sessionId)
         );
       } finally {
         db.close();
@@ -2283,8 +2278,8 @@ function createSafeLogBackup(store) {
   };
 }
 const DB_NAME = "issue-sticker-replay";
-const DB_VERSION = 1;
-const STORE_NAME = "segments";
+const DB_VERSION$1 = 1;
+const STORE_NAME$1 = "segments";
 const REPLAY_BACKUP_TTL_MS = 24 * 60 * 60 * 1e3;
 const REPLAY_BACKUP_SIZE_BUDGET = 32 * 1024 * 1024;
 const eventSizes = /* @__PURE__ */ new WeakMap();
@@ -2336,12 +2331,12 @@ function requestToPromise(request) {
     request.onerror = () => reject(request.error);
   });
 }
-function openDatabase() {
+function openDatabase$1() {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    const request = indexedDB.open(DB_NAME, DB_VERSION$1);
     request.onupgradeneeded = () => {
-      if (!request.result.objectStoreNames.contains(STORE_NAME)) {
-        request.result.createObjectStore(STORE_NAME, { keyPath: "sessionId" });
+      if (!request.result.objectStoreNames.contains(STORE_NAME$1)) {
+        request.result.createObjectStore(STORE_NAME$1, { keyPath: "sessionId" });
       }
     };
     request.onsuccess = () => {
@@ -2356,10 +2351,10 @@ function openDatabase() {
 function createIndexedDbReplayBackup() {
   return {
     async load(sessionId) {
-      const db = await openDatabase();
+      const db = await openDatabase$1();
       try {
         const record2 = await requestToPromise(
-          db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(sessionId)
+          db.transaction(STORE_NAME$1, "readonly").objectStore(STORE_NAME$1).get(sessionId)
         );
         if (!record2) return null;
         if (record2.expiresAt <= Date.now()) return null;
@@ -2369,7 +2364,7 @@ function createIndexedDbReplayBackup() {
       }
     },
     async save(sessionId, segments) {
-      const db = await openDatabase();
+      const db = await openDatabase$1();
       try {
         const record2 = {
           sessionId,
@@ -2377,16 +2372,16 @@ function createIndexedDbReplayBackup() {
           expiresAt: Date.now() + REPLAY_BACKUP_TTL_MS
         };
         await requestToPromise(
-          db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(record2)
+          db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1).put(record2)
         );
       } finally {
         db.close();
       }
     },
     async prune() {
-      const db = await openDatabase();
+      const db = await openDatabase$1();
       try {
-        const store = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME);
+        const store = db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1);
         const records = await requestToPromise(store.getAll());
         const now = Date.now();
         const expired = records.filter((record2) => record2.expiresAt <= now);
@@ -2399,10 +2394,10 @@ function createIndexedDbReplayBackup() {
       }
     },
     async clear(sessionId) {
-      const db = await openDatabase();
+      const db = await openDatabase$1();
       try {
         await requestToPromise(
-          db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(sessionId)
+          db.transaction(STORE_NAME$1, "readwrite").objectStore(STORE_NAME$1).delete(sessionId)
         );
       } finally {
         db.close();
@@ -2546,6 +2541,26 @@ function createReplaySession(options = {}) {
     }
   };
 }
+function readReleaseMarker() {
+  try {
+    const g = globalThis.__ISSUE_STICKER_RELEASE__;
+    if (g && typeof g.id === "string" && g.id.length > 0) {
+      return {
+        release: g.id,
+        release_source: typeof g.source === "string" && g.source.length > 0 ? g.source : "global"
+      };
+    }
+    if (typeof document !== "undefined") {
+      const meta = document.querySelector('meta[name="issue-sticker:release"]');
+      const content = meta == null ? void 0 : meta.getAttribute("content");
+      if (content && content.length > 0) {
+        return { release: content, release_source: "meta" };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 function createInitialSnapshot() {
   return {
     available: false,
@@ -2651,6 +2666,24 @@ class SessionReplayCaptureController {
     this.listeners.forEach((listener) => listener(this.snapshot));
   }
 }
+function dataUrlToBlob(dataUrl) {
+  var _a;
+  const comma = dataUrl.indexOf(",");
+  const header = dataUrl.slice(0, comma);
+  const mime = ((_a = /^data:([^;,]+)/.exec(header)) == null ? void 0 : _a[1]) ?? "application/octet-stream";
+  const binary = atob(dataUrl.slice(comma + 1));
+  const bytes = new Uint8Array(binary.length);
+  for (let i2 = 0; i2 < binary.length; i2 += 1) bytes[i2] = binary.charCodeAt(i2);
+  return new Blob([bytes], { type: mime });
+}
+function blobToDataUrl(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error ?? new Error("스크린샷을 dataUrl 로 변환하지 못했습니다."));
+    reader.readAsDataURL(blob);
+  });
+}
 const SCREENSHOT_DATA_URL_QUALITY = 0.95;
 let nextCaptureRunId = 0;
 function createCaptureAttributeNames() {
@@ -2861,14 +2894,6 @@ function createModernStickySnapshot(root, attributeNames) {
     }
   };
 }
-function blobToDataUrl(blob) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(String(reader.result));
-    reader.onerror = () => reject(reader.error ?? new Error("스크린샷을 dataUrl 로 변환하지 못했습니다."));
-    reader.readAsDataURL(blob);
-  });
-}
 function captureOrigin(element) {
   if (element === document.documentElement || element === document.body) {
     return { x: 0, y: 0 };
@@ -2926,162 +2951,1023 @@ async function captureWithModernScreenshot(options) {
     stickySnapshot.cleanup();
   }
 }
-const ISSUE_STICKER_INTERNAL_LOG_PREFIX = "__ISSUE_STICKER_INTERNAL_DEBUG__";
-function isInternalDebugLog$1(message2) {
-  return Boolean(message2 == null ? void 0 : message2.includes(ISSUE_STICKER_INTERNAL_LOG_PREFIX));
-}
-function isIssueStickerInternalConsoleLog$1(log) {
-  return isInternalDebugLog$1(log.message);
+const ELEMENT_CROP_PADDING_PX = 8;
+const ELEMENT_CROP_QUALITY = 0.95;
+function measureElementCropTarget(element) {
+  var _a;
+  if (element.ownerDocument !== document) return null;
+  if (element === document.documentElement || element === document.body) return null;
+  if ((((_a = window.visualViewport) == null ? void 0 : _a.scale) ?? 1) !== 1) return null;
+  const rect = element.getBoundingClientRect();
+  return {
+    rect: { left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom },
+    viewport: { width: window.innerWidth, height: window.innerHeight }
+  };
 }
-const __vite_import_meta_env__ = { "DEV": false };
-function isDevLoggingEnabled() {
-  const env = __vite_import_meta_env__;
-  {
-    return env.DEV;
+function computeElementCropRect(rect, viewport, image, padding = ELEMENT_CROP_PADDING_PX) {
+  if (viewport.width <= 0 || viewport.height <= 0 || image.width <= 0 || image.height <= 0) {
+    return null;
+  }
+  const visibleWidth = Math.min(rect.right, viewport.width) - Math.max(rect.left, 0);
+  const visibleHeight = Math.min(rect.bottom, viewport.height) - Math.max(rect.top, 0);
+  if (visibleWidth < 1 || visibleHeight < 1) return null;
+  const left = Math.max(rect.left - padding, 0);
+  const top = Math.max(rect.top - padding, 0);
+  const right = Math.min(rect.right + padding, viewport.width);
+  const bottom = Math.min(rect.bottom + padding, viewport.height);
+  const kx = image.width / viewport.width;
+  const ky = image.height / viewport.height;
+  const sx = Math.round(left * kx);
+  const sy = Math.round(top * ky);
+  const sw = Math.min(Math.round(right * kx), image.width) - sx;
+  const sh = Math.min(Math.round(bottom * ky), image.height) - sy;
+  return sw >= 1 && sh >= 1 ? { sx, sy, sw, sh } : null;
+}
+async function cropElementFromViewportCapture(viewportDataUrl, target) {
+  const bitmap = await createImageBitmap(dataUrlToBlob(viewportDataUrl));
+  try {
+    const crop = computeElementCropRect(target.rect, target.viewport, {
+      width: bitmap.width,
+      height: bitmap.height
+    });
+    if (!crop) return void 0;
+    const canvas = new OffscreenCanvas(crop.sw, crop.sh);
+    const context = canvas.getContext("2d");
+    if (!context) return void 0;
+    context.drawImage(bitmap, crop.sx, crop.sy, crop.sw, crop.sh, 0, 0, crop.sw, crop.sh);
+    return await blobToDataUrl(
+      await canvas.convertToBlob({ type: "image/webp", quality: ELEMENT_CROP_QUALITY })
+    );
+  } finally {
+    bitmap.close();
   }
 }
-function isInternalDebugLog(message2) {
-  return Boolean(message2 == null ? void 0 : message2.includes(ISSUE_STICKER_INTERNAL_LOG_PREFIX));
+async function captureViewportWithElementCrop({
+  element,
+  excludeSelectors = []
+}) {
+  const target = measureElementCropTarget(element);
+  const fullDataUrl = await captureWithModernScreenshot({
+    element: document.documentElement,
+    excludeSelectors,
+    width: window.innerWidth,
+    height: window.innerHeight
+  }).catch(() => void 0);
+  if (!fullDataUrl || !target) return { fullDataUrl };
+  const elementDataUrl = await cropElementFromViewportCapture(fullDataUrl, target).catch(
+    () => void 0
+  );
+  return { fullDataUrl, elementDataUrl };
 }
-function write(method, scope, args) {
-  if (!isDevLoggingEnabled()) {
-    return;
-  }
-  const log = console[method];
-  log(ISSUE_STICKER_INTERNAL_LOG_PREFIX, `[${scope}]`, ...args);
+const UPLOAD_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+const TUS_CHUNK_SIZE = 6 * 1024 * 1024;
+const TUS_RETRY_DELAYS = [0, 3e3, 5e3, 1e4, 2e4];
+class PermanentUploadError extends Error {
 }
-const devLogger = {
-  log(scope, ...args) {
-    write("log", scope, args);
-  },
-  info(scope, ...args) {
-    write("info", scope, args);
-  },
-  warn(scope, ...args) {
-    write("warn", scope, args);
-  },
-  error(scope, ...args) {
-    write("error", scope, args);
-  },
-  debug(scope, ...args) {
-    write("debug", scope, args);
-  }
-};
-class DirectUploadError extends Error {
-  constructor(message2, status, data) {
-    super(message2);
-    this.status = status;
-    this.data = data;
-    this.name = "DirectUploadError";
+class UploadStoppedError extends Error {
+}
+const RETRYABLE_CLIENT_STATUSES = /* @__PURE__ */ new Set([401, 408, 423, 429]);
+function readStatus(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const status = error.status;
+  if (typeof status === "number") return status;
+  const response = error.originalResponse;
+  return typeof (response == null ? void 0 : response.getStatus) === "function" ? response.getStatus() : void 0;
+}
+function isPermanentStatus(status) {
+  return status !== void 0 && status >= 400 && status < 500 && !RETRYABLE_CLIENT_STATUSES.has(status);
+}
+function toApiFailure(error) {
+  return isPermanentStatus(readStatus(error)) ? new PermanentUploadError(error instanceof Error ? error.message : String(error)) : error;
+}
+const SIGNATURE_STATUSES = /* @__PURE__ */ new Set([400, 401, 403]);
+function toTusFailure(error) {
+  if (error instanceof UploadStoppedError) return error;
+  const status = readStatus(error);
+  if (status !== void 0 && SIGNATURE_STATUSES.has(status)) {
+    return new PermanentUploadError(`tus ${status}`);
   }
+  if (status === 409) return error;
+  return isPermanentStatus(status) ? new PermanentUploadError(`tus ${status}`) : error;
 }
-const uploadIdByUrl = /* @__PURE__ */ new Map();
-function bytesToHex(bytes) {
-  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+function stripMimeParameters(mimeType) {
+  return mimeType.split(";", 1)[0].trim().toLowerCase();
 }
-async function readFileArrayBuffer(file) {
-  if (typeof file.arrayBuffer === "function") {
-    return file.arrayBuffer();
+function callSafely(call) {
+  try {
+    call();
+  } catch {
   }
+}
+function readBlob(blob) {
+  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
-    reader.onload = () => {
-      if (reader.result instanceof ArrayBuffer) {
-        resolve(reader.result);
-      } else {
-        reject(new Error("파일 내용을 ArrayBuffer로 읽지 못했습니다."));
-      }
-    };
-    reader.onerror = () => reject(reader.error ?? new Error("파일 읽기에 실패했습니다."));
-    reader.readAsArrayBuffer(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error ?? new Error("업로드 파일을 읽지 못했습니다."));
+    reader.readAsArrayBuffer(blob);
   });
 }
-async function calculateSha256Hex(file) {
+function lockName(recordId) {
+  return `issue-sticker-upload:${recordId}`;
+}
+function lockManager() {
+  return typeof navigator !== "undefined" ? navigator.locks : void 0;
+}
+async function heldLockNames() {
   var _a;
-  if (!((_a = globalThis.crypto) == null ? void 0 : _a.subtle)) {
-    throw new Error("Web Crypto SHA-256 API를 사용할 수 없어 signed upload를 시작할 수 없습니다.");
+  try {
+    const snapshot = await ((_a = lockManager()) == null ? void 0 : _a.query());
+    return new Set(((snapshot == null ? void 0 : snapshot.held) ?? []).flatMap((lock) => lock.name ? [lock.name] : []));
+  } catch {
+    return /* @__PURE__ */ new Set();
   }
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", await readFileArrayBuffer(file));
-  return bytesToHex(new Uint8Array(digest));
 }
-function normalizeUploadMimeType(mimeType, mediaType) {
-  var _a;
-  const fallback = mediaType === "screenshot" ? "image/webp" : mediaType === "replay" || mediaType === "socket" ? "application/gzip" : "video/webm";
-  const normalized = (_a = (mimeType || fallback).split(";", 1)[0]) == null ? void 0 : _a.trim().toLowerCase();
-  return normalized && normalized.length > 0 ? normalized : fallback;
+async function sha256Hex(blob) {
+  const digest = await crypto.subtle.digest("SHA-256", await readBlob(blob));
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-async function directUploadToSignedUrl(signedUrl, file, contentType) {
-  const response = await fetch(signedUrl, {
-    method: "PUT",
-    headers: {
-      "Content-Type": contentType
-    },
-    body: file
-  });
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new DirectUploadError(
-      `스토리지 업로드 실패: ${response.status}${body ? ` ${body}` : ""}`,
-      response.status,
-      body || void 0
+class MediaUploadQueue {
+  constructor(deps) {
+    this.deps = deps;
+    this.records = /* @__PURE__ */ new Map();
+    this.states = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.running = false;
+    this.stopped = false;
+    this.cancelCurrent = null;
+    this.finished = /* @__PURE__ */ new Set();
+    this.failureNotified = /* @__PURE__ */ new Set();
+    this.persisted = /* @__PURE__ */ new Set();
+    this.held = /* @__PURE__ */ new Set();
+    this.resolveStopped = () => void 0;
+    this.handleOnline = () => this.requeueFailed();
+    this.now = deps.now ?? Date.now;
+    this.whenStopped = new Promise((resolve) => {
+      this.resolveStopped = resolve;
+    });
+    if (typeof window !== "undefined") window.addEventListener("online", this.handleOnline);
+  }
+  /**
+   * 저장소에 넣은 뒤 resolve 한다. 저장이 실패하면 메모리로만 진행한다.
+   * reject 하지 않는다 — 이슈는 이미 생성됐다. 기록조차 만들지 못하면 이슈 id 로 abort 해
+   * 서버가 이슈를 바로 failed 로 내리게 한다.
+   * 기록은 호출한 틱에 생긴다(첫 await 전). 같은 이슈의 다른 업로드와 함께 넣을 때 이 순서에 기댄다.
+   */
+  async enqueue(input) {
+    let record2;
+    try {
+      record2 = {
+        id: crypto.randomUUID(),
+        ...input,
+        mimeType: stripMimeParameters(input.mimeType),
+        createdAt: this.now()
+      };
+    } catch {
+      await this.deps.api.abortUpload({ uploadId: null, issueId: input.issueId, mediaType: input.mediaType }).catch(() => void 0);
+      this.emit({ type: "aborted", issueId: input.issueId, mediaType: input.mediaType });
+      return;
+    }
+    this.records.set(record2.id, record2);
+    this.setState(record2, "queued", 0);
+    await this.persist(record2);
+    this.kick();
+  }
+  /**
+   * 저장소의 이 프로젝트 기록을 메모리로 가져와 붙잡아 둔다. 이미 돌고 있는 처리가 있어도
+   * requeueFailed 가 이 프로젝트를 풀 때까지 가져온 기록은 시작하지 않는다. 새로 enqueue 한
+   * 기록은 붙잡지 않는다.
+   * 다른 탭이 잠금을 쥐고 올리는 기록은 가져오지도 세지도 않는다.
+   * 새로 읽어 온 기록 중 만료되지 않은 수를 돌려준다.
+   * 이어 올리기는 두 저장소를 모두 읽은 뒤 시작하는 `IssueUploadQueues.resume` 으로 한다.
+   */
+  async load(projectKey) {
+    const held = await heldLockNames();
+    const stored = await this.deps.store.list().catch(() => []);
+    let resumable = 0;
+    for (const record2 of stored) {
+      if (record2.projectKey !== projectKey || this.records.has(record2.id) || this.finished.has(record2.id) || held.has(lockName(record2.id))) {
+        continue;
+      }
+      this.persisted.add(record2.id);
+      const normalized = { ...record2, mediaType: record2.mediaType ?? "video" };
+      this.records.set(normalized.id, normalized);
+      this.held.add(normalized.id);
+      this.setState(normalized, "queued", 0);
+      if (!this.isExpired(normalized)) resumable += 1;
+    }
+    return resumable;
+  }
+  /**
+   * 모든 프로젝트·워크스페이스의 만료 기록을 저장소에서 지운다. 서버에는 알리지 않는다 —
+   * 생성 24시간이 지난 업로드 중 이슈는 서버 cron 이 failed 로 내린다. 이 대기열이 들고 있는
+   * 기록은 처리 순서에서 abort 하므로 건드리지 않는다. 지운 수를 돌려준다.
+   */
+  async pruneExpired() {
+    const stored = await this.deps.store.list().catch(() => []);
+    const expired = stored.filter(
+      (record2) => this.isExpired(record2) && !this.records.has(record2.id) && !this.finished.has(record2.id)
     );
+    await Promise.all(
+      expired.map((record2) => this.deps.store.delete(record2.id).catch(() => void 0))
+    );
+    return expired.length;
   }
-}
-function getRegisteredUploadId(publicUrl, mediaType) {
-  const record2 = uploadIdByUrl.get(publicUrl);
-  return (record2 == null ? void 0 : record2.mediaType) === mediaType ? record2.id : void 0;
-}
-async function uploadSignedMediaWithApi(api, file, mediaType, options = {}) {
-  const checksumSha256 = await calculateSha256Hex(file);
-  const contentType = normalizeUploadMimeType(file.type, mediaType);
-  const init = await api.post("/api/media/uploads/init", {
-    files: [
-      {
-        mediaType,
-        mimeType: contentType,
-        sizeBytes: file.size,
-        checksumSha256,
-        issueId: options.issueId
+  /** 그 이슈의 실패 기록을 전부 다시 올린다. 첨부 대기열은 한 이슈에 리플레이·소켓 두 기록을 둔다. */
+  retry(issueId) {
+    var _a;
+    let requeued = false;
+    for (const record2 of this.records.values()) {
+      if (record2.issueId !== issueId || ((_a = this.states.get(record2.id)) == null ? void 0 : _a.status) !== "failed") continue;
+      this.failureNotified.delete(record2.id);
+      this.setState(record2, "queued", 0);
+      requeued = true;
+    }
+    if (requeued) this.kick();
+  }
+  /** 그 이슈에 아직 처리할(queued·uploading) 기록이 있는가. 실패로 멈춘 기록은 세지 않는다. */
+  isPending(issueId) {
+    return [...this.records.values()].some(
+      (record2) => {
+        var _a;
+        return record2.issueId === issueId && ((_a = this.states.get(record2.id)) == null ? void 0 : _a.status) !== "failed";
       }
-    ]
-  });
-  const upload = init.uploads[0];
-  if (!(upload == null ? void 0 : upload.id) || !upload.signedUrl) {
-    throw new Error("signed upload URL 발급 응답이 올바르지 않습니다.");
+    );
   }
-  if (file.size > upload.maxSizeBytes) {
-    throw new Error(`${mediaType} 파일 크기가 허용 한도를 초과했습니다.`);
+  subscribe(listener) {
+    this.listeners.add(listener);
+    callSafely(() => listener(this.snapshot()));
+    return () => {
+      this.listeners.delete(listener);
+    };
   }
-  await api.directUpload(upload.signedUrl, file, contentType);
-  const complete = await api.post("/api/media/uploads/complete", {
-    uploadIds: [upload.id],
-    issueId: options.issueId
-  });
-  const completed = complete.uploads[0];
-  const publicUrl = (completed == null ? void 0 : completed.publicUrl) || upload.publicUrl;
-  const uploadId = (completed == null ? void 0 : completed.id) || upload.id;
-  uploadIdByUrl.set(publicUrl, { id: uploadId, mediaType });
-  return {
-    id: uploadId,
-    url: publicUrl
-  };
-}
-function _mergeNamespaces$1(e2, t2) {
-  return t2.forEach((function(t3) {
-    t3 && "string" != typeof t3 && !Array.isArray(t3) && Object.keys(t3).forEach((function(r2) {
-      if ("default" !== r2 && !(r2 in e2)) {
-        var i2 = Object.getOwnPropertyDescriptor(t3, r2);
-        Object.defineProperty(e2, r2, i2.get ? i2 : { enumerable: true, get: function() {
-          return t3[r2];
-        } });
+  hasActiveUploads() {
+    return [...this.states.values()].some((state) => state.status !== "failed");
+  }
+  stop() {
+    var _a;
+    this.stopped = true;
+    this.resolveStopped();
+    if (typeof window !== "undefined") window.removeEventListener("online", this.handleOnline);
+    (_a = this.cancelCurrent) == null ? void 0 : _a.call(this);
+    this.listeners.clear();
+  }
+  /**
+   * 기록을(projectKey 를 주면 그 프로젝트만) 처리 대상으로 돌린다. load 가 붙잡아 둔 기록을 풀고,
+   * failed 로 멈춘 기록은 다시 대기시킨 뒤 처리를 시작한다.
+   */
+  requeueFailed(projectKey) {
+    var _a;
+    for (const record2 of this.records.values()) {
+      if (projectKey !== void 0 && record2.projectKey !== projectKey) continue;
+      this.held.delete(record2.id);
+      if (((_a = this.states.get(record2.id)) == null ? void 0 : _a.status) === "failed") this.setState(record2, "queued", 0);
+    }
+    this.kick();
+  }
+  kick() {
+    if (this.running || this.stopped) return;
+    this.running = true;
+    void this.drain().finally(() => {
+      this.running = false;
+      if (this.nextQueued()) this.kick();
+    });
+  }
+  nextQueued() {
+    return [...this.records.values()].find(
+      (record2) => {
+        var _a;
+        return !this.held.has(record2.id) && ((_a = this.states.get(record2.id)) == null ? void 0 : _a.status) === "queued";
       }
-    }));
-  })), Object.freeze(e2);
-}
-function copyExifWithoutOrientation(e2, t2) {
-  return new Promise((function(r2, i2) {
-    let o2;
-    return getApp1Segment(e2).then((function(e3) {
+    );
+  }
+  async drain() {
+    for (let record2 = this.nextQueued(); record2 && !this.stopped; record2 = this.nextQueued()) {
+      await this.process(record2);
+    }
+  }
+  /**
+   * 저장소는 같은 사이트의 모든 탭이 함께 쓴다. 탭마다 resume 하면 같은 기록을 두 탭이 동시에
+   * 올리게 되므로 기록 id 잠금을 쥔 탭만 처리한다. 잠금을 못 얻으면 이 탭 메모리에서만 내려놓고
+   * 저장소 기록은 그대로 둔다. 탭이 닫히면 잠금이 풀리므로 다음 resume 에서 다시 가져간다.
+   * navigator.locks 가 없거나 요청이 거절되는 환경(비보안 컨텍스트 등)은 잠금 없이 처리한다.
+   */
+  async process(record2) {
+    const locks = lockManager();
+    if (!locks) return this.processRecord(record2);
+    let entered = false;
+    try {
+      await locks.request(lockName(record2.id), { ifAvailable: true }, async (lock) => {
+        entered = true;
+        if (!lock || !await this.refresh(record2)) {
+          this.release(record2);
+          return;
+        }
+        await Promise.race([this.processRecord(record2), this.whenStopped]);
+      });
+    } catch {
+      if (!entered) await this.processRecord(record2);
+    }
+  }
+  /**
+   * 이 탭이 기록을 읽은 뒤 잠금을 얻기까지 다른 탭이 그 기록을 처리했을 수 있다. 저장소에서
+   * 사라졌으면 다른 탭이 끝낸 것이라 false, 남아 있으면 그 탭이 받은 uploadId·이어 올릴 URL 을
+   * 가져온다. 저장하지 못해 메모리에만 있는 기록과 저장소를 읽지 못한 경우는 그대로 진행한다.
+   */
+  async refresh(record2) {
+    if (!this.persisted.has(record2.id)) return true;
+    const fresh = await this.deps.store.load(record2.id).catch(() => void 0);
+    if (fresh === null) return false;
+    if (fresh) Object.assign(record2, fresh, { mediaType: fresh.mediaType ?? record2.mediaType });
+    return true;
+  }
+  /** 다른 탭이 맡은 기록을 이 대기열에서만 뺀다. 알림·서버 호출·저장소 삭제는 하지 않는다. */
+  release(record2) {
+    this.failureNotified.delete(record2.id);
+    this.persisted.delete(record2.id);
+    this.records.delete(record2.id);
+    this.states.delete(record2.id);
+    this.notify();
+  }
+  async processRecord(record2) {
+    var _a;
+    if (this.isExpired(record2)) {
+      await this.discard(record2);
+      return;
+    }
+    this.setState(record2, "uploading", 0);
+    try {
+      await this.ensureInitialized(record2);
+      await this.uploadWithResign(record2);
+      this.throwIfStopped();
+      await this.complete(record2);
+    } catch (error) {
+      if (this.stopped) return;
+      if (error instanceof PermanentUploadError) {
+        await this.discard(record2);
+        return;
+      }
+      this.setState(record2, "failed", ((_a = this.states.get(record2.id)) == null ? void 0 : _a.bytesSent) ?? 0);
+      if (typeof navigator !== "undefined" && navigator.onLine === false) return;
+      if (!this.failureNotified.has(record2.id)) {
+        this.failureNotified.add(record2.id);
+        this.emit({ type: "failed", issueId: record2.issueId, mediaType: record2.mediaType });
+      }
+      return;
+    }
+    if (this.stopped) return;
+    await this.finish(record2, "completed");
+  }
+  async ensureInitialized(record2) {
+    if (record2.uploadId) return;
+    const checksumSha256 = await sha256Hex(record2.blob).catch((error) => {
+      throw new PermanentUploadError(error instanceof Error ? error.message : String(error));
+    });
+    this.throwIfStopped();
+    const init = await this.callApi(
+      () => this.deps.api.initUpload({
+        mediaType: record2.mediaType,
+        issueId: record2.issueId,
+        mimeType: record2.mimeType,
+        sizeBytes: record2.blob.size,
+        checksumSha256
+      })
+    );
+    Object.assign(record2, init);
+    await this.persistProgress(record2);
+  }
+  /**
+   * complete 의 409 는 다른 요청(같은 기록을 이어 올린 다른 탭 등)이 먼저 연결해 상태가 바뀐 경우다.
+   * 이미 이슈에 붙었으므로 완료로 본다.
+   */
+  async complete(record2) {
+    try {
+      await this.deps.api.completeUpload({
+        uploadId: record2.uploadId,
+        issueId: record2.issueId,
+        mediaType: record2.mediaType,
+        replayMeta: record2.replayMeta
+      });
+    } catch (error) {
+      if (readStatus(error) === 409) return;
+      throw toApiFailure(error);
+    }
+  }
+  /** stop() 뒤에는 진행 중이던 처리도 서버를 더 부르지 않는다. 기록은 저장소에 남겨 다음 resume 에 맡긴다. */
+  throwIfStopped() {
+    if (this.stopped) throw new UploadStoppedError();
+  }
+  async callApi(call) {
+    try {
+      return await call();
+    } catch (error) {
+      throw toApiFailure(error);
+    }
+  }
+  /** 업로드 토큰은 2시간이면 만료된다. 400·401·403 이면 같은 path 로 다시 서명받아 한 번만 이어 간다. */
+  async uploadWithResign(record2) {
+    try {
+      await this.runTus(record2);
+      return;
+    } catch (error) {
+      const status = readStatus(error);
+      if (status === void 0 || !SIGNATURE_STATUSES.has(status)) throw toTusFailure(error);
+    }
+    let token;
+    try {
+      ({ token } = await this.deps.api.resignUpload(record2.uploadId));
+    } catch (error) {
+      if (readStatus(error) === 409) return;
+      throw toApiFailure(error);
+    }
+    record2.token = token;
+    await this.persistProgress(record2);
+    try {
+      await this.runTus(record2);
+    } catch (error) {
+      throw toTusFailure(error);
+    }
+  }
+  async runTus(record2) {
+    const { Upload } = await this.deps.loadTus();
+    this.throwIfStopped();
+    await new Promise((resolve, reject) => {
+      const upload = new Upload(record2.blob, {
+        endpoint: record2.resumableUrl,
+        uploadUrl: record2.tusUploadUrl ?? null,
+        chunkSize: TUS_CHUNK_SIZE,
+        retryDelays: TUS_RETRY_DELAYS,
+        // 이어 올릴 URL 은 우리 기록에 둔다. tus 의 localStorage 저장은 쓰지 않는다.
+        storeFingerprintForResuming: false,
+        headers: { "x-signature": record2.token ?? "", "x-client-info": this.deps.clientInfo },
+        metadata: {
+          bucketName: record2.bucket ?? "",
+          objectName: record2.path ?? "",
+          contentType: record2.mimeType,
+          cacheControl: "3600"
+        },
+        onUploadUrlAvailable: () => {
+          record2.tusUploadUrl = upload.url ?? void 0;
+          void this.persistProgress(record2);
+        },
+        onProgress: (bytesSent, bytesTotal) => this.setState(record2, "uploading", bytesSent, bytesTotal),
+        onSuccess: () => resolve(),
+        onError: (error) => reject(error)
+      });
+      this.cancelCurrent = () => {
+        void upload.abort(false);
+        reject(new UploadStoppedError());
+      };
+      upload.start();
+    }).finally(() => {
+      this.cancelCurrent = null;
+    });
+  }
+  async discard(record2) {
+    await this.deps.api.abortUpload({
+      uploadId: record2.uploadId ?? null,
+      issueId: record2.issueId,
+      mediaType: record2.mediaType
+    }).catch(() => void 0);
+    await this.finish(record2, "aborted");
+  }
+  /**
+   * 끝낸 기록을 저장소에서 지운 뒤 메모리에서 빼고 알린다. 메모리에서 빼는 것과 알림 사이에
+   * await 를 두지 않는다 — 알리미는 두 대기열의 메모리 기록으로 그 이슈가 끝났는지 보므로, 그
+   * 사이 다른 대기열이 끝나면 양쪽이 서로 끝난 것으로 보고 따로 알린다.
+   */
+  async finish(record2, type) {
+    this.finished.add(record2.id);
+    await this.deps.store.delete(record2.id).catch(() => void 0);
+    this.persisted.delete(record2.id);
+    this.failureNotified.delete(record2.id);
+    this.records.delete(record2.id);
+    this.states.delete(record2.id);
+    this.notify();
+    this.emit({ type, issueId: record2.issueId, mediaType: record2.mediaType });
+  }
+  async persist(record2) {
+    await this.deps.store.save(record2).then(
+      () => this.persisted.add(record2.id),
+      () => void 0
+    );
+  }
+  /**
+   * 처리 중에 받은 결과(init·재서명·이어 올릴 URL)를 저장한다. stop() 뒤에는 쓰지 않는다 —
+   * 잠금을 넘겨받은 새 대기열이 저장한 내용을 덮어쓰지 않게 한다.
+   */
+  async persistProgress(record2) {
+    if (this.stopped) return;
+    await this.persist(record2);
+  }
+  isExpired(record2) {
+    return this.now() - record2.createdAt >= UPLOAD_MAX_AGE_MS;
+  }
+  setState(record2, status, bytesSent, bytesTotal = record2.blob.size) {
+    this.states.set(record2.id, {
+      issueId: record2.issueId,
+      mediaType: record2.mediaType,
+      status,
+      bytesSent,
+      bytesTotal
+    });
+    this.notify();
+  }
+  snapshot() {
+    return [...this.records.keys()].flatMap((id) => {
+      const state = this.states.get(id);
+      return state ? [state] : [];
+    });
+  }
+  notify() {
+    const states = this.snapshot();
+    this.listeners.forEach((listener) => callSafely(() => listener(states)));
+  }
+  emit(event) {
+    callSafely(() => {
+      var _a, _b;
+      return (_b = (_a = this.deps).onEvent) == null ? void 0 : _b.call(_a, event);
+    });
+  }
+}
+const VIDEO_UPLOAD_DB_NAME = "issue-sticker-video-uploads";
+const ATTACHMENT_UPLOAD_DB_NAME = "issue-sticker-attachment-uploads";
+const DB_VERSION = 1;
+const STORE_NAME = "uploads";
+function openDatabase(dbName) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, DB_VERSION);
+    request.onupgradeneeded = () => {
+      if (!request.result.objectStoreNames.contains(STORE_NAME)) {
+        request.result.createObjectStore(STORE_NAME, { keyPath: "id" });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => db.close();
+      resolve(db);
+    };
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => reject(new Error("indexedDB open blocked"));
+  });
+}
+async function withStore(dbName, mode, run) {
+  const db = await openDatabase(dbName);
+  try {
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, mode);
+      const request = run(tx.objectStore(STORE_NAME));
+      tx.oncomplete = () => resolve(request.result);
+      tx.onabort = () => reject(tx.error ?? request.error ?? new Error("indexedDB aborted"));
+      tx.onerror = () => reject(tx.error ?? request.error);
+    });
+  } finally {
+    db.close();
+  }
+}
+function createIndexedDbPendingUploadStore(dbName) {
+  return {
+    async load(id) {
+      const found = await withStore(
+        dbName,
+        "readonly",
+        (store) => store.get(id)
+      );
+      return found ?? null;
+    },
+    async save(record2) {
+      await withStore(dbName, "readwrite", (store) => store.put(record2));
+    },
+    async delete(id) {
+      await withStore(dbName, "readwrite", (store) => store.delete(id));
+    },
+    async list() {
+      const all = await withStore(dbName, "readonly", (store) => store.getAll());
+      return all.sort((a2, b) => a2.createdAt - b.createdAt);
+    }
+  };
+}
+const loadTusClient = () => import("./index-DA6SoSp7.js");
+class IssueUploadNotifier {
+  constructor(deps) {
+    this.deps = deps;
+    this.outcomes = /* @__PURE__ */ new Map();
+  }
+  handle(event) {
+    const notice = this.outcomes.get(event.issueId) ?? {
+      issueId: event.issueId,
+      completed: [],
+      failed: [],
+      aborted: []
+    };
+    notice[event.type].push(event.mediaType);
+    this.outcomes.set(event.issueId, notice);
+    if (this.deps.isPending(event.issueId)) return;
+    this.outcomes.delete(event.issueId);
+    try {
+      this.deps.onNotice(notice);
+    } catch {
+    }
+  }
+}
+function createIssueUploadQueues(deps) {
+  const { onEvent, onNotice } = deps;
+  const notifier = onNotice ? new IssueUploadNotifier({ isPending: (issueId) => isPending(issueId), onNotice }) : null;
+  const create = (store) => new MediaUploadQueue({
+    api: deps.api,
+    store,
+    loadTus: deps.loadTus,
+    clientInfo: deps.clientInfo,
+    onEvent: (event) => {
+      onEvent == null ? void 0 : onEvent(event);
+      notifier == null ? void 0 : notifier.handle(event);
+    }
+  });
+  const video = create(deps.videoStore);
+  const attachments = create(deps.attachmentStore);
+  const isPending = (issueId) => video.isPending(issueId) || attachments.isPending(issueId);
+  return {
+    video,
+    attachments,
+    async resume(projectKeys) {
+      const [videoCounts] = await Promise.all([
+        Promise.all(projectKeys.map((key) => video.load(key))),
+        Promise.all(projectKeys.map((key) => attachments.load(key)))
+      ]);
+      for (const key of projectKeys) {
+        video.requeueFailed(key);
+        attachments.requeueFailed(key);
+      }
+      return videoCounts.reduce((sum, count2) => sum + count2, 0);
+    },
+    retry(issueId) {
+      video.retry(issueId);
+      attachments.retry(issueId);
+    },
+    stop() {
+      video.stop();
+      attachments.stop();
+    },
+    isPending
+  };
+}
+let nextId = 0;
+let toasts = [];
+const listeners = /* @__PURE__ */ new Set();
+function emit() {
+  listeners.forEach((l2) => l2());
+}
+function addToast(message2, type, options) {
+  const id = `toast-${++nextId}`;
+  const t2 = {
+    id,
+    message: message2,
+    type,
+    title: options == null ? void 0 : options.title,
+    action: options == null ? void 0 : options.action,
+    duration: (options == null ? void 0 : options.duration) ?? 2e3,
+    createdAt: Date.now()
+  };
+  toasts = [...toasts, t2];
+  emit();
+  return id;
+}
+function dismiss(id) {
+  toasts = toasts.filter((t2) => t2.id !== id);
+  emit();
+}
+function dismissAll() {
+  toasts = [];
+  emit();
+}
+function toast(message2, options) {
+  return addToast(message2, "default", options);
+}
+toast.success = (message2, options) => addToast(message2, "success", options);
+toast.warning = (message2, options) => addToast(message2, "warning", options);
+toast.error = (message2, options) => addToast(message2, "error", options);
+toast.info = (message2, options) => addToast(message2, "info", options);
+toast.dismiss = dismiss;
+toast.dismissAll = dismissAll;
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function getSnapshot() {
+  return toasts;
+}
+function dropOldestFrames(connections, bytesToDrop) {
+  const order = connections.flatMap(
+    (connection, index) => connection.frames.map((frame) => {
+      var _a;
+      return { index, t: frame.t, bytes: ((_a = frame.data) == null ? void 0 : _a.length) ?? 0 };
+    })
+  ).sort((a2, b) => a2.t - b.t);
+  const dropCount = connections.map(() => 0);
+  const dropBytes = connections.map(() => 0);
+  let removed = 0;
+  for (const entry of order) {
+    if (removed >= bytesToDrop) break;
+    dropCount[entry.index] += 1;
+    dropBytes[entry.index] += entry.bytes;
+    removed += entry.bytes;
+  }
+  return connections.map((connection, index) => {
+    const count2 = dropCount[index];
+    if (count2 === 0) return connection;
+    return {
+      ...connection,
+      frames: connection.frames.slice(count2),
+      droppedFrames: connection.droppedFrames + count2,
+      droppedBytes: connection.droppedBytes + dropBytes[index]
+    };
+  });
+}
+const FIT_ATTEMPTS = 6;
+async function serializeSocketTranscript(connections, maxBytes = SOCKET_TRANSCRIPT_MAX_BYTES) {
+  const frameCount = connections.reduce(
+    (sum, connection) => sum + connection.frames.length + connection.droppedFrames,
+    0
+  );
+  if (connections.length === 0 || frameCount === 0) return null;
+  let current = connections;
+  let payload = gzip_1(JSON.stringify({ connections: current }));
+  for (let attempt = 0; attempt < FIT_ATTEMPTS && payload.byteLength > maxBytes; attempt += 1) {
+    const storedBytes = current.reduce(
+      (sum, connection) => sum + storedFrameBytes(connection.frames),
+      0
+    );
+    if (storedBytes === 0) break;
+    const overRatio = 1 - maxBytes / payload.byteLength;
+    current = dropOldestFrames(current, storedBytes * Math.min(1, overRatio + 0.1));
+    payload = gzip_1(JSON.stringify({ connections: current }));
+  }
+  return {
+    payload,
+    sizeBytes: payload.byteLength,
+    connectionCount: connections.length,
+    frameCount
+  };
+}
+const ATTACHMENT_MIME_TYPE = "application/gzip";
+function toSessionReplayMeta(replay) {
+  const marker = readReleaseMarker();
+  return {
+    window_seconds: replay.windowSeconds,
+    event_count: replay.eventCount,
+    size_bytes: replay.sizeBytes,
+    rrweb_version: replay.rrwebVersion,
+    privacy_config_version: replay.privacyConfigVersion,
+    ...marker ? { release: marker.release, release_source: marker.release_source } : {}
+  };
+}
+function toAttachmentUploads(input) {
+  const uploads = [];
+  const { replay, socket } = input;
+  if (replay && replay.eventCount > 0) {
+    uploads.push({
+      mediaType: "replay",
+      bytes: replay.payload,
+      mimeType: ATTACHMENT_MIME_TYPE,
+      replayMeta: toSessionReplayMeta(replay)
+    });
+  }
+  if (socket && socket.sizeBytes <= SOCKET_TRANSCRIPT_MAX_BYTES) {
+    uploads.push({ mediaType: "socket", bytes: socket.payload, mimeType: ATTACHMENT_MIME_TYPE });
+  }
+  return uploads;
+}
+async function collectAttachmentUploads(input) {
+  const { takeReplay, getConnections, onError } = input;
+  const attempt = (kind, run) => Promise.resolve().then(run).catch((error) => {
+    onError == null ? void 0 : onError(kind, error);
+    return null;
+  });
+  const replay = takeReplay ? await attempt("replay", takeReplay) : null;
+  const socket = await attempt(
+    "socket",
+    async () => serializeSocketTranscript(await getConnections())
+  );
+  return toAttachmentUploads({ replay, socket });
+}
+function hasReplayUpload(uploads) {
+  return uploads.some((upload) => upload.mediaType === "replay");
+}
+async function enqueueIssueUploads(input) {
+  const { issueId, projectKey } = input;
+  const pending = [];
+  if (input.video) {
+    pending.push(
+      input.videoQueue.enqueue({ issueId, projectKey, mediaType: "video", ...input.video })
+    );
+  }
+  for (const attachment of input.attachments) {
+    pending.push(
+      input.attachmentQueue.enqueue({
+        issueId,
+        projectKey,
+        mediaType: attachment.mediaType,
+        blob: new Blob([attachment.bytes], { type: attachment.mimeType }),
+        mimeType: attachment.mimeType,
+        replayMeta: attachment.replayMeta
+      })
+    );
+  }
+  await Promise.all(pending);
+}
+class DirectUploadError extends Error {
+  constructor(message2, status, data) {
+    super(message2);
+    this.status = status;
+    this.data = data;
+    this.name = "DirectUploadError";
+  }
+}
+const uploadIdByUrl = /* @__PURE__ */ new Map();
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function readFileArrayBuffer(file) {
+  if (typeof file.arrayBuffer === "function") {
+    return file.arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (reader.result instanceof ArrayBuffer) {
+        resolve(reader.result);
+      } else {
+        reject(new Error("파일 내용을 ArrayBuffer로 읽지 못했습니다."));
+      }
+    };
+    reader.onerror = () => reject(reader.error ?? new Error("파일 읽기에 실패했습니다."));
+    reader.readAsArrayBuffer(file);
+  });
+}
+async function calculateSha256Hex(file) {
+  var _a;
+  if (!((_a = globalThis.crypto) == null ? void 0 : _a.subtle)) {
+    throw new Error("Web Crypto SHA-256 API를 사용할 수 없어 signed upload를 시작할 수 없습니다.");
+  }
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", await readFileArrayBuffer(file));
+  return bytesToHex(new Uint8Array(digest));
+}
+function normalizeUploadMimeType(mimeType, mediaType) {
+  var _a;
+  const fallback = mediaType === "screenshot" ? "image/webp" : mediaType === "replay" || mediaType === "socket" ? "application/gzip" : "video/webm";
+  const normalized = (_a = (mimeType || fallback).split(";", 1)[0]) == null ? void 0 : _a.trim().toLowerCase();
+  return normalized && normalized.length > 0 ? normalized : fallback;
+}
+async function directUploadToSignedUrl(signedUrl, file, contentType) {
+  const response = await fetch(signedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": contentType,
+      "x-client-info": "issue-sticker-sdk"
+    },
+    body: file
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new DirectUploadError(
+      `스토리지 업로드 실패: ${response.status}${body ? ` ${body}` : ""}`,
+      response.status,
+      body || void 0
+    );
+  }
+}
+function getRegisteredUploadId(publicUrl, mediaType) {
+  const record2 = uploadIdByUrl.get(publicUrl);
+  return (record2 == null ? void 0 : record2.mediaType) === mediaType ? record2.id : void 0;
+}
+async function uploadSignedMediaWithApi(api, file, mediaType, options = {}) {
+  const checksumSha256 = await calculateSha256Hex(file);
+  const contentType = normalizeUploadMimeType(file.type, mediaType);
+  const init = await api.post("/api/media/uploads/init", {
+    files: [
+      {
+        mediaType,
+        mimeType: contentType,
+        sizeBytes: file.size,
+        checksumSha256,
+        issueId: options.issueId
+      }
+    ]
+  });
+  const upload = init.uploads[0];
+  if (!(upload == null ? void 0 : upload.id) || !upload.signedUrl) {
+    throw new Error("signed upload URL 발급 응답이 올바르지 않습니다.");
+  }
+  if (file.size > upload.maxSizeBytes) {
+    throw new Error(`${mediaType} 파일 크기가 허용 한도를 초과했습니다.`);
+  }
+  await api.directUpload(upload.signedUrl, file, contentType);
+  const complete = await api.post("/api/media/uploads/complete", {
+    uploadIds: [upload.id],
+    issueId: options.issueId
+  });
+  const completed = complete.uploads[0];
+  const publicUrl = (completed == null ? void 0 : completed.publicUrl) || upload.publicUrl;
+  const uploadId = (completed == null ? void 0 : completed.id) || upload.id;
+  uploadIdByUrl.set(publicUrl, { id: uploadId, mediaType });
+  return {
+    id: uploadId,
+    url: publicUrl
+  };
+}
+function createMediaUploadApi(api) {
+  return {
+    async initUpload({ mediaType, issueId, mimeType, sizeBytes, checksumSha256 }) {
+      const { uploads } = await api.post(
+        "/api/media/uploads/init",
+        { files: [{ mediaType, mimeType, sizeBytes, checksumSha256, issueId }] }
+      );
+      const upload = uploads[0];
+      if (!(upload == null ? void 0 : upload.id) || !upload.resumableUrl) {
+        throw new Error("업로드 URL 발급 응답이 올바르지 않습니다.");
+      }
+      return {
+        uploadId: upload.id,
+        bucket: upload.bucket,
+        path: upload.path,
+        token: upload.token,
+        resumableUrl: upload.resumableUrl
+      };
+    },
+    resignUpload: (uploadId) => api.post(`/api/media/uploads/${encodeURIComponent(uploadId)}/resign`),
+    async completeUpload({ uploadId, issueId, replayMeta }) {
+      await api.post("/api/media/uploads/complete", {
+        uploadIds: [uploadId],
+        issueId,
+        ...replayMeta ? { replayMeta } : {}
+      });
+    },
+    async abortUpload({ uploadId, issueId, mediaType }) {
+      await api.post("/api/media/uploads/abort", {
+        issueId,
+        mediaType,
+        ...uploadId ? { uploadId } : {}
+      });
+    }
+  };
+}
+const ISSUE_STICKER_INTERNAL_LOG_PREFIX = "__ISSUE_STICKER_INTERNAL_DEBUG__";
+function isInternalDebugLog$1(message2) {
+  return Boolean(message2 == null ? void 0 : message2.includes(ISSUE_STICKER_INTERNAL_LOG_PREFIX));
+}
+function isIssueStickerInternalConsoleLog$1(log) {
+  return isInternalDebugLog$1(log.message);
+}
+const __vite_import_meta_env__ = { "DEV": false };
+function isDevLoggingEnabled() {
+  const env = __vite_import_meta_env__;
+  {
+    return env.DEV;
+  }
+}
+function isInternalDebugLog(message2) {
+  return Boolean(message2 == null ? void 0 : message2.includes(ISSUE_STICKER_INTERNAL_LOG_PREFIX));
+}
+function write(method, scope, args) {
+  if (!isDevLoggingEnabled()) {
+    return;
+  }
+  const log = console[method];
+  log(ISSUE_STICKER_INTERNAL_LOG_PREFIX, `[${scope}]`, ...args);
+}
+const devLogger = {
+  log(scope, ...args) {
+    write("log", scope, args);
+  },
+  info(scope, ...args) {
+    write("info", scope, args);
+  },
+  warn(scope, ...args) {
+    write("warn", scope, args);
+  },
+  error(scope, ...args) {
+    write("error", scope, args);
+  },
+  debug(scope, ...args) {
+    write("debug", scope, args);
+  }
+};
+function _mergeNamespaces$1(e2, t2) {
+  return t2.forEach((function(t3) {
+    t3 && "string" != typeof t3 && !Array.isArray(t3) && Object.keys(t3).forEach((function(r2) {
+      if ("default" !== r2 && !(r2 in e2)) {
+        var i2 = Object.getOwnPropertyDescriptor(t3, r2);
+        Object.defineProperty(e2, r2, i2.get ? i2 : { enumerable: true, get: function() {
+          return t3[r2];
+        } });
+      }
+    }));
+  })), Object.freeze(e2);
+}
+function copyExifWithoutOrientation(e2, t2) {
+  return new Promise((function(r2, i2) {
+    let o2;
+    return getApp1Segment(e2).then((function(e3) {
       try {
         return o2 = e3, r2(new Blob([t2.slice(0, 2), o2, t2.slice(2)], { type: "image/jpeg" }));
       } catch (e4) {
@@ -5435,6 +6321,7 @@ class NetworkCollector {
     var _a;
     if (!this.running) return;
     if (this.isServiceRequest(log.url)) return;
+    if (hasSelfTrafficHeader(log.requestHeaders)) return;
     this.logs.push(log);
     if (this.logs.length > NETWORK_LOG_CLIENT_BUFFER_SIZE) {
       this.logs = this.logs.slice(-NETWORK_LOG_CLIENT_BUFFER_SIZE);
@@ -5622,90 +6509,32 @@ class NetworkCollector {
    * 무조건 되돌리면 우리 뒤에 붙은 계측(Sentry 등)의 래퍼가 통째로 사라진다 — 고객의 에러
    * 추적이 조용히 죽는다. 남의 것이 위에 있으면 우리 래퍼는 체인에 남겨 두고 수집만 멈춘다.
    */
-  restoreFetch() {
-    if (!this.originalFetch) return;
-    if (window.fetch === this.patchedFetch) {
-      window.fetch = this.originalFetch;
-    }
-    this.originalFetch = null;
-    this.patchedFetch = null;
-    clearPristineFetch();
-  }
-  /** fetch 와 같은 규칙 — 우리 래퍼가 아직 걸려 있을 때만 되돌린다. */
-  restoreXHR() {
-    const patched = this.patchedXHR;
-    if (this.originalXHROpen && (!patched || XMLHttpRequest.prototype.open === patched.open)) {
-      XMLHttpRequest.prototype.open = this.originalXHROpen;
-    }
-    if (this.originalXHRSend && (!patched || XMLHttpRequest.prototype.send === patched.send)) {
-      XMLHttpRequest.prototype.send = this.originalXHRSend;
-    }
-    if (this.originalXHRSetRequestHeader && (!patched || XMLHttpRequest.prototype.setRequestHeader === patched.setRequestHeader)) {
-      XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
-    }
-    this.originalXHROpen = null;
-    this.originalXHRSend = null;
-    this.originalXHRSetRequestHeader = null;
-    this.patchedXHR = null;
-  }
-}
-async function sha256Hex(bytes) {
-  const digest = await crypto.subtle.digest("SHA-256", bytes.buffer);
-  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function dropOldestFrames(connections, bytesToDrop) {
-  const order = connections.flatMap(
-    (connection, index) => connection.frames.map((frame) => {
-      var _a;
-      return { index, t: frame.t, bytes: ((_a = frame.data) == null ? void 0 : _a.length) ?? 0 };
-    })
-  ).sort((a2, b) => a2.t - b.t);
-  const dropCount = connections.map(() => 0);
-  const dropBytes = connections.map(() => 0);
-  let removed = 0;
-  for (const entry of order) {
-    if (removed >= bytesToDrop) break;
-    dropCount[entry.index] += 1;
-    dropBytes[entry.index] += entry.bytes;
-    removed += entry.bytes;
-  }
-  return connections.map((connection, index) => {
-    const count2 = dropCount[index];
-    if (count2 === 0) return connection;
-    return {
-      ...connection,
-      frames: connection.frames.slice(count2),
-      droppedFrames: connection.droppedFrames + count2,
-      droppedBytes: connection.droppedBytes + dropBytes[index]
-    };
-  });
-}
-const FIT_ATTEMPTS = 6;
-async function serializeSocketTranscript(connections, maxBytes = SOCKET_TRANSCRIPT_MAX_BYTES) {
-  const frameCount = connections.reduce(
-    (sum, connection) => sum + connection.frames.length + connection.droppedFrames,
-    0
-  );
-  if (connections.length === 0 || frameCount === 0) return null;
-  let current = connections;
-  let payload = gzip_1(JSON.stringify({ connections: current }));
-  for (let attempt = 0; attempt < FIT_ATTEMPTS && payload.byteLength > maxBytes; attempt += 1) {
-    const storedBytes = current.reduce(
-      (sum, connection) => sum + storedFrameBytes(connection.frames),
-      0
-    );
-    if (storedBytes === 0) break;
-    const overRatio = 1 - maxBytes / payload.byteLength;
-    current = dropOldestFrames(current, storedBytes * Math.min(1, overRatio + 0.1));
-    payload = gzip_1(JSON.stringify({ connections: current }));
+  restoreFetch() {
+    if (!this.originalFetch) return;
+    if (window.fetch === this.patchedFetch) {
+      window.fetch = this.originalFetch;
+    }
+    this.originalFetch = null;
+    this.patchedFetch = null;
+    clearPristineFetch();
+  }
+  /** fetch 와 같은 규칙 — 우리 래퍼가 아직 걸려 있을 때만 되돌린다. */
+  restoreXHR() {
+    const patched = this.patchedXHR;
+    if (this.originalXHROpen && (!patched || XMLHttpRequest.prototype.open === patched.open)) {
+      XMLHttpRequest.prototype.open = this.originalXHROpen;
+    }
+    if (this.originalXHRSend && (!patched || XMLHttpRequest.prototype.send === patched.send)) {
+      XMLHttpRequest.prototype.send = this.originalXHRSend;
+    }
+    if (this.originalXHRSetRequestHeader && (!patched || XMLHttpRequest.prototype.setRequestHeader === patched.setRequestHeader)) {
+      XMLHttpRequest.prototype.setRequestHeader = this.originalXHRSetRequestHeader;
+    }
+    this.originalXHROpen = null;
+    this.originalXHRSend = null;
+    this.originalXHRSetRequestHeader = null;
+    this.patchedXHR = null;
   }
-  return {
-    payload,
-    checksumSha256: await sha256Hex(payload),
-    sizeBytes: payload.byteLength,
-    connectionCount: connections.length,
-    frameCount
-  };
 }
 var NetworkLogType = /* @__PURE__ */ ((NetworkLogType2) => {
   NetworkLogType2["MAIN_FRAME"] = "main_frame";
@@ -6108,75 +6937,905 @@ function appendCustomFieldFilterGroups(groups, customFields) {
       options
     });
   }
-}
-function appendJiraFieldFilterGroups(groups, exposedFieldIds, fields) {
-  for (const field of fields) {
-    const normalizedFieldId = normalizeJiraFieldId(field.id);
-    if (!exposedFieldIds.has(normalizedFieldId) || !JIRA_FILTERABLE_FIELD_IDS.has(normalizedFieldId)) {
-      continue;
+}
+function appendJiraFieldFilterGroups(groups, exposedFieldIds, fields) {
+  for (const field of fields) {
+    const normalizedFieldId = normalizeJiraFieldId(field.id);
+    if (!exposedFieldIds.has(normalizedFieldId) || !JIRA_FILTERABLE_FIELD_IDS.has(normalizedFieldId)) {
+      continue;
+    }
+    const options = getJiraFieldFilterOptions(field);
+    if (!options.length) continue;
+    upsertFilterGroup(groups, {
+      kind: "jira",
+      id: `jira:${normalizedFieldId}`,
+      fieldName: normalizedFieldId,
+      label: field.name,
+      options
+    });
+  }
+}
+function appendNotionFieldFilterGroups(groups, selectedFields, fields) {
+  for (const field of fields) {
+    if (!selectedFields.has(field.id) && !selectedFields.has(field.name)) continue;
+    if (!NOTION_FILTERABLE_FIELD_TYPES.has(field.type)) continue;
+    const options = getNotionFieldFilterOptions(field);
+    if (!options.length) continue;
+    upsertFilterGroup(groups, {
+      kind: "notion",
+      id: `notion:${field.id}`,
+      fieldName: field.name,
+      label: field.name,
+      options
+    });
+  }
+}
+function composeIssueFilterGroups(integrations, customFields) {
+  const groups = /* @__PURE__ */ new Map();
+  const jiraIntegration = integrations.find((integration) => {
+    const config = getJiraConfig(integration);
+    return integration.is_active !== false && config;
+  });
+  appendCustomFieldFilterGroups(groups, customFields);
+  const jiraConfig = jiraIntegration ? getJiraConfig(jiraIntegration) : null;
+  const configExposedFields = getExposedFields(jiraConfig);
+  if (configExposedFields.length) {
+    appendJiraFieldFilterGroups(
+      groups,
+      new Set(configExposedFields),
+      getLastKnownJiraFields(jiraConfig)
+    );
+  }
+  for (const integration of integrations) {
+    if (integration.is_active === false) continue;
+    const notionConfig = getNotionConfig(integration);
+    if (!notionConfig) continue;
+    appendNotionFieldFilterGroups(
+      groups,
+      new Set(getSelectedNotionFields(notionConfig)),
+      getLastKnownNotionFields(notionConfig)
+    );
+  }
+  return Array.from(groups.values()).sort((a2, b) => a2.label.localeCompare(b.label));
+}
+const IGNORED_NAME = /^(Primitive\.|Slot|Presence|Portal|Fragment|Suspense|StrictMode)|(Provider|Context|Consumer)$/;
+const MAX_DEPTH = 300;
+function fiberOf(element) {
+  for (const key of Object.keys(element)) {
+    if (key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")) {
+      return element[key] ?? null;
+    }
+  }
+  return null;
+}
+function nameOf(type) {
+  if (typeof type === "function") {
+    const fn = type;
+    return fn.displayName ?? fn.name ?? null;
+  }
+  if (type && typeof type === "object") {
+    const wrapper = type;
+    return wrapper.displayName ?? nameOf(wrapper.render) ?? nameOf(wrapper.type);
+  }
+  return null;
+}
+const reactAdapter = {
+  framework: "react",
+  collect(element) {
+    let fiber = fiberOf(element);
+    if (!fiber) return null;
+    const names = [];
+    for (let depth = 0; fiber && depth < MAX_DEPTH; depth += 1) {
+      const name = nameOf(fiber.type);
+      if (typeof name === "string" && name && !IGNORED_NAME.test(name)) names.unshift(name);
+      fiber = fiber.return;
+    }
+    return names;
+  }
+};
+const ADAPTERS = [reactAdapter];
+const MIN_NAME_LENGTH = 3;
+const MAX_NAME_LENGTH = 60;
+function cleanPath(names) {
+  if (!names) return [];
+  const kept = names.filter((name) => typeof name === "string").map(
+    (name) => name.replace(/\s+/g, " ").trim().slice(0, MAX_NAME_LENGTH).replace(/[\uD800-\uDBFF]$/, "")
+  ).filter((name) => name.length >= MIN_NAME_LENGTH);
+  const deduped = kept.filter((name, index) => name !== kept[index - 1]);
+  return deduped.slice(-8);
+}
+function collectComponentPath(element, adapters = ADAPTERS) {
+  for (const adapter of adapters) {
+    let path = [];
+    try {
+      path = cleanPath(adapter.collect(element));
+    } catch {
+      path = [];
+    }
+    if (path.length) return { framework: adapter.framework, path };
+  }
+  return null;
+}
+var toStr = Object.prototype.toString;
+function isCallable(fn) {
+  return typeof fn === "function" || toStr.call(fn) === "[object Function]";
+}
+function toInteger(value) {
+  var number = Number(value);
+  if (isNaN(number)) {
+    return 0;
+  }
+  if (number === 0 || !isFinite(number)) {
+    return number;
+  }
+  return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+}
+var maxSafeInteger = Math.pow(2, 53) - 1;
+function toLength(value) {
+  var len = toInteger(value);
+  return Math.min(Math.max(len, 0), maxSafeInteger);
+}
+function arrayFrom(arrayLike, mapFn) {
+  var C = Array;
+  var items = Object(arrayLike);
+  if (arrayLike == null) {
+    throw new TypeError("Array.from requires an array-like object - not null or undefined");
+  }
+  var len = toLength(items.length);
+  var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+  var k = 0;
+  var kValue;
+  while (k < len) {
+    kValue = items[k];
+    {
+      A[k] = kValue;
+    }
+    k += 1;
+  }
+  A.length = len;
+  return A;
+}
+function _typeof(o2) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o3) {
+    return typeof o3;
+  } : function(o3) {
+    return o3 && "function" == typeof Symbol && o3.constructor === Symbol && o3 !== Symbol.prototype ? "symbol" : typeof o3;
+  }, _typeof(o2);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i2 = 0; i2 < props.length; i2++) {
+    var descriptor = props[i2];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t2) {
+  var i2 = _toPrimitive(t2, "string");
+  return "symbol" == _typeof(i2) ? i2 : i2 + "";
+}
+function _toPrimitive(t2, r2) {
+  if ("object" != _typeof(t2) || !t2) return t2;
+  var e2 = t2[Symbol.toPrimitive];
+  if (void 0 !== e2) {
+    var i2 = e2.call(t2, r2);
+    if ("object" != _typeof(i2)) return i2;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t2);
+}
+var SetLike = /* @__PURE__ */ (function() {
+  function SetLike2() {
+    var items = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    _classCallCheck(this, SetLike2);
+    _defineProperty(this, "items", void 0);
+    this.items = items;
+  }
+  return _createClass(SetLike2, [{
+    key: "add",
+    value: function add(value) {
+      if (this.has(value) === false) {
+        this.items.push(value);
+      }
+      return this;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.items = [];
+    }
+  }, {
+    key: "delete",
+    value: function _delete(value) {
+      var previousLength = this.items.length;
+      this.items = this.items.filter(function(item) {
+        return item !== value;
+      });
+      return previousLength !== this.items.length;
+    }
+  }, {
+    key: "forEach",
+    value: function forEach(callbackfn) {
+      var _this = this;
+      this.items.forEach(function(item) {
+        callbackfn(item, item, _this);
+      });
+    }
+  }, {
+    key: "has",
+    value: function has(value) {
+      return this.items.indexOf(value) !== -1;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this.items.length;
+    }
+  }]);
+})();
+const SetLike$1 = typeof Set === "undefined" ? Set : SetLike;
+function getLocalName(element) {
+  var _element$localName;
+  return (
+    // eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
+    (_element$localName = element.localName) !== null && _element$localName !== void 0 ? _element$localName : (
+      // eslint-disable-next-line no-restricted-properties -- required for the fallback
+      element.tagName.toLowerCase()
+    )
+  );
+}
+var localNameToRoleMappings = {
+  article: "article",
+  aside: "complementary",
+  button: "button",
+  datalist: "listbox",
+  dd: "definition",
+  details: "group",
+  dialog: "dialog",
+  dt: "term",
+  fieldset: "group",
+  figure: "figure",
+  // WARNING: Only with an accessible name
+  form: "form",
+  footer: "contentinfo",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  header: "banner",
+  hr: "separator",
+  html: "document",
+  legend: "legend",
+  li: "listitem",
+  math: "math",
+  main: "main",
+  menu: "list",
+  nav: "navigation",
+  ol: "list",
+  optgroup: "group",
+  // WARNING: Only in certain context
+  option: "option",
+  output: "status",
+  progress: "progressbar",
+  // WARNING: Only with an accessible name
+  section: "region",
+  summary: "button",
+  table: "table",
+  tbody: "rowgroup",
+  textarea: "textbox",
+  tfoot: "rowgroup",
+  // WARNING: Only in certain context
+  td: "cell",
+  th: "columnheader",
+  thead: "rowgroup",
+  tr: "row",
+  ul: "list"
+};
+var prohibitedAttributes = {
+  caption: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  code: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  deletion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  emphasis: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  generic: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
+  insertion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  none: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  paragraph: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  presentation: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  strong: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  subscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+  superscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"])
+};
+function hasGlobalAriaAttributes(element, role) {
+  return [
+    "aria-atomic",
+    "aria-busy",
+    "aria-controls",
+    "aria-current",
+    "aria-description",
+    "aria-describedby",
+    "aria-details",
+    // "disabled",
+    "aria-dropeffect",
+    // "errormessage",
+    "aria-flowto",
+    "aria-grabbed",
+    // "haspopup",
+    "aria-hidden",
+    // "invalid",
+    "aria-keyshortcuts",
+    "aria-label",
+    "aria-labelledby",
+    "aria-live",
+    "aria-owns",
+    "aria-relevant",
+    "aria-roledescription"
+  ].some(function(attributeName) {
+    var _prohibitedAttributes;
+    return element.hasAttribute(attributeName) && !((_prohibitedAttributes = prohibitedAttributes[role]) !== null && _prohibitedAttributes !== void 0 && _prohibitedAttributes.has(attributeName));
+  });
+}
+function ignorePresentationalRole(element, implicitRole) {
+  return hasGlobalAriaAttributes(element, implicitRole);
+}
+function getRole(element) {
+  var explicitRole = getExplicitRole(element);
+  if (explicitRole === null || presentationRoles.indexOf(explicitRole) !== -1) {
+    var implicitRole = getImplicitRole(element);
+    if (presentationRoles.indexOf(explicitRole || "") === -1 || ignorePresentationalRole(element, implicitRole || "")) {
+      return implicitRole;
+    }
+  }
+  return explicitRole;
+}
+function getImplicitRole(element) {
+  var mappedByTag = localNameToRoleMappings[getLocalName(element)];
+  if (mappedByTag !== void 0) {
+    return mappedByTag;
+  }
+  switch (getLocalName(element)) {
+    case "a":
+    case "area":
+    case "link":
+      if (element.hasAttribute("href")) {
+        return "link";
+      }
+      break;
+    case "img":
+      if (element.getAttribute("alt") === "" && !ignorePresentationalRole(element, "img")) {
+        return "presentation";
+      }
+      return "img";
+    case "input": {
+      var _ref = element, type = _ref.type;
+      switch (type) {
+        case "button":
+        case "image":
+        case "reset":
+        case "submit":
+          return "button";
+        case "checkbox":
+        case "radio":
+          return type;
+        case "range":
+          return "slider";
+        case "email":
+        case "tel":
+        case "text":
+        case "url":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "textbox";
+        case "search":
+          if (element.hasAttribute("list")) {
+            return "combobox";
+          }
+          return "searchbox";
+        case "number":
+          return "spinbutton";
+        default:
+          return null;
+      }
+    }
+    case "select":
+      if (element.hasAttribute("multiple") || element.size > 1) {
+        return "listbox";
+      }
+      return "combobox";
+  }
+  return null;
+}
+function getExplicitRole(element) {
+  var role = element.getAttribute("role");
+  if (role !== null) {
+    var explicitRole = role.trim().split(" ")[0];
+    if (explicitRole.length > 0) {
+      return explicitRole;
+    }
+  }
+  return null;
+}
+var presentationRoles = ["presentation", "none"];
+function isElement(node) {
+  return node !== null && node.nodeType === node.ELEMENT_NODE;
+}
+function isHTMLTableCaptionElement(node) {
+  return isElement(node) && getLocalName(node) === "caption";
+}
+function isHTMLInputElement(node) {
+  return isElement(node) && getLocalName(node) === "input";
+}
+function isHTMLOptGroupElement(node) {
+  return isElement(node) && getLocalName(node) === "optgroup";
+}
+function isHTMLSelectElement(node) {
+  return isElement(node) && getLocalName(node) === "select";
+}
+function isHTMLTableElement(node) {
+  return isElement(node) && getLocalName(node) === "table";
+}
+function isHTMLTextAreaElement(node) {
+  return isElement(node) && getLocalName(node) === "textarea";
+}
+function safeWindow(node) {
+  var _ref = node.ownerDocument === null ? node : node.ownerDocument, defaultView = _ref.defaultView;
+  if (defaultView === null) {
+    throw new TypeError("no window available");
+  }
+  return defaultView;
+}
+function isHTMLFieldSetElement(node) {
+  return isElement(node) && getLocalName(node) === "fieldset";
+}
+function isHTMLLegendElement(node) {
+  return isElement(node) && getLocalName(node) === "legend";
+}
+function isHTMLSlotElement(node) {
+  return isElement(node) && getLocalName(node) === "slot";
+}
+function isSVGElement(node) {
+  return isElement(node) && node.ownerSVGElement !== void 0;
+}
+function isSVGSVGElement(node) {
+  return isElement(node) && getLocalName(node) === "svg";
+}
+function isSVGTitleElement(node) {
+  return isSVGElement(node) && getLocalName(node) === "title";
+}
+function queryIdRefs(node, attributeName) {
+  if (isElement(node) && node.hasAttribute(attributeName)) {
+    var ids = node.getAttribute(attributeName).split(" ");
+    var root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
+    return ids.map(function(id) {
+      return root.getElementById(id);
+    }).filter(
+      function(element) {
+        return element !== null;
+      }
+      // TODO: why does this not narrow?
+    );
+  }
+  return [];
+}
+function hasAnyConcreteRoles(node, roles) {
+  if (isElement(node)) {
+    return roles.indexOf(getRole(node)) !== -1;
+  }
+  return false;
+}
+function asFlatString(s2) {
+  return s2.trim().replace(/\s\s+/g, " ");
+}
+function isHidden$1(node, getComputedStyleImplementation) {
+  if (!isElement(node)) {
+    return false;
+  }
+  if (node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true") {
+    return true;
+  }
+  var style = getComputedStyleImplementation(node);
+  return style.getPropertyValue("display") === "none" || style.getPropertyValue("visibility") === "hidden";
+}
+function isControl(node) {
+  return hasAnyConcreteRoles(node, ["button", "combobox", "listbox", "textbox"]) || hasAbstractRole(node, "range");
+}
+function hasAbstractRole(node, role) {
+  if (!isElement(node)) {
+    return false;
+  }
+  switch (role) {
+    case "range":
+      return hasAnyConcreteRoles(node, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
+    default:
+      throw new TypeError("No knowledge about abstract role '".concat(role, "'. This is likely a bug :("));
+  }
+}
+function querySelectorAllSubtree(element, selectors) {
+  var elements = arrayFrom(element.querySelectorAll(selectors));
+  queryIdRefs(element, "aria-owns").forEach(function(root) {
+    elements.push.apply(elements, arrayFrom(root.querySelectorAll(selectors)));
+  });
+  return elements;
+}
+function querySelectedOptions(listbox) {
+  if (isHTMLSelectElement(listbox)) {
+    return listbox.selectedOptions || querySelectorAllSubtree(listbox, "[selected]");
+  }
+  return querySelectorAllSubtree(listbox, '[aria-selected="true"]');
+}
+function isMarkedPresentational(node) {
+  return hasAnyConcreteRoles(node, presentationRoles);
+}
+function isNativeHostLanguageTextAlternativeElement(node) {
+  return isHTMLTableCaptionElement(node);
+}
+function allowsNameFromContent(node) {
+  return hasAnyConcreteRoles(node, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
+}
+function isDescendantOfNativeHostLanguageTextAlternativeElement(node) {
+  return false;
+}
+function getValueOfTextbox(element) {
+  if (isHTMLInputElement(element) || isHTMLTextAreaElement(element)) {
+    return element.value;
+  }
+  return element.textContent || "";
+}
+function getTextualContent(declaration) {
+  var content = declaration.getPropertyValue("content");
+  if (/^["'].*["']$/.test(content)) {
+    return content.slice(1, -1);
+  }
+  return "";
+}
+function isLabelableElement(element) {
+  var localName = getLocalName(element);
+  return localName === "button" || localName === "input" && element.getAttribute("type") !== "hidden" || localName === "meter" || localName === "output" || localName === "progress" || localName === "select" || localName === "textarea";
+}
+function findLabelableElement(element) {
+  if (isLabelableElement(element)) {
+    return element;
+  }
+  var labelableElement = null;
+  element.childNodes.forEach(function(childNode) {
+    if (labelableElement === null && isElement(childNode)) {
+      var descendantLabelableElement = findLabelableElement(childNode);
+      if (descendantLabelableElement !== null) {
+        labelableElement = descendantLabelableElement;
+      }
+    }
+  });
+  return labelableElement;
+}
+function getControlOfLabel(label) {
+  if (label.control !== void 0) {
+    return label.control;
+  }
+  var htmlFor = label.getAttribute("for");
+  if (htmlFor !== null) {
+    return label.ownerDocument.getElementById(htmlFor);
+  }
+  return findLabelableElement(label);
+}
+function getLabels$1(element) {
+  var labelsProperty = element.labels;
+  if (labelsProperty === null) {
+    return labelsProperty;
+  }
+  if (labelsProperty !== void 0) {
+    return arrayFrom(labelsProperty);
+  }
+  if (!isLabelableElement(element)) {
+    return null;
+  }
+  var document2 = element.ownerDocument;
+  return arrayFrom(document2.querySelectorAll("label")).filter(function(label) {
+    return getControlOfLabel(label) === element;
+  });
+}
+function getSlotContents(slot) {
+  var assignedNodes = slot.assignedNodes();
+  if (assignedNodes.length === 0) {
+    return arrayFrom(slot.childNodes);
+  }
+  return assignedNodes;
+}
+function computeTextAlternative(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var consultedNodes = new SetLike$1();
+  var computedStyles = typeof Map === "undefined" ? void 0 : /* @__PURE__ */ new Map();
+  var window2 = safeWindow(root);
+  var _options$compute = options.compute, compute = _options$compute === void 0 ? "name" : _options$compute, _options$computedStyl = options.computedStyleSupportsPseudoElements, computedStyleSupportsPseudoElements = _options$computedStyl === void 0 ? options.getComputedStyle !== void 0 : _options$computedStyl, _options$getComputedS = options.getComputedStyle, uncachedGetComputedStyle = _options$getComputedS === void 0 ? window2.getComputedStyle.bind(window2) : _options$getComputedS, _options$hidden = options.hidden, hidden = _options$hidden === void 0 ? false : _options$hidden;
+  var getComputedStyle2 = function getComputedStyle3(el, pseudoElement) {
+    if (pseudoElement !== void 0) {
+      throw new Error("use uncachedGetComputedStyle directly for pseudo elements");
+    }
+    if (computedStyles === void 0) {
+      return uncachedGetComputedStyle(el);
+    }
+    var cachedStyles = computedStyles.get(el);
+    if (cachedStyles) {
+      return cachedStyles;
+    }
+    var style = uncachedGetComputedStyle(el, pseudoElement);
+    computedStyles.set(el, style);
+    return style;
+  };
+  function computeMiscTextAlternative(node, context) {
+    var accumulatedText = "";
+    if (isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoBefore = uncachedGetComputedStyle(node, "::before");
+      var beforeContent = getTextualContent(pseudoBefore);
+      accumulatedText = "".concat(beforeContent, " ").concat(accumulatedText);
+    }
+    var childNodes = isHTMLSlotElement(node) ? getSlotContents(node) : arrayFrom(node.childNodes).concat(queryIdRefs(node, "aria-owns"));
+    childNodes.forEach(function(child) {
+      var result = computeTextAlternative2(child, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel,
+        isReferenced: false,
+        recursion: true
+      });
+      var display = isElement(child) ? getComputedStyle2(child).getPropertyValue("display") : "inline";
+      var separator = display !== "inline" ? " " : "";
+      accumulatedText += "".concat(separator).concat(result).concat(separator);
+    });
+    if (isElement(node) && computedStyleSupportsPseudoElements) {
+      var pseudoAfter = uncachedGetComputedStyle(node, "::after");
+      var afterContent = getTextualContent(pseudoAfter);
+      accumulatedText = "".concat(accumulatedText, " ").concat(afterContent);
+    }
+    return accumulatedText.trim();
+  }
+  function useAttribute(element, attributeName) {
+    var attribute = element.getAttributeNode(attributeName);
+    if (attribute !== null && !consultedNodes.has(attribute) && attribute.value.trim() !== "") {
+      consultedNodes.add(attribute);
+      return attribute.value;
+    }
+    return null;
+  }
+  function computeTooltipAttributeValue(node) {
+    if (!isElement(node)) {
+      return null;
+    }
+    return useAttribute(node, "title");
+  }
+  function computeElementTextAlternative(node) {
+    if (!isElement(node)) {
+      return null;
+    }
+    if (isHTMLFieldSetElement(node)) {
+      consultedNodes.add(node);
+      var children = arrayFrom(node.childNodes);
+      for (var i2 = 0; i2 < children.length; i2 += 1) {
+        var child = children[i2];
+        if (isHTMLLegendElement(child)) {
+          return computeTextAlternative2(child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (isHTMLTableElement(node)) {
+      consultedNodes.add(node);
+      var _children = arrayFrom(node.childNodes);
+      for (var _i = 0; _i < _children.length; _i += 1) {
+        var _child = _children[_i];
+        if (isHTMLTableCaptionElement(_child)) {
+          return computeTextAlternative2(_child, {
+            isEmbeddedInLabel: false,
+            isReferenced: false,
+            recursion: false
+          });
+        }
+      }
+    } else if (isSVGSVGElement(node)) {
+      consultedNodes.add(node);
+      var _children2 = arrayFrom(node.childNodes);
+      for (var _i2 = 0; _i2 < _children2.length; _i2 += 1) {
+        var _child2 = _children2[_i2];
+        if (isSVGTitleElement(_child2)) {
+          return _child2.textContent;
+        }
+      }
+      return null;
+    } else if (getLocalName(node) === "img" || getLocalName(node) === "area") {
+      var nameFromAlt = useAttribute(node, "alt");
+      if (nameFromAlt !== null) {
+        return nameFromAlt;
+      }
+    } else if (isHTMLOptGroupElement(node)) {
+      var nameFromLabel = useAttribute(node, "label");
+      if (nameFromLabel !== null) {
+        return nameFromLabel;
+      }
+    }
+    if (isHTMLInputElement(node) && (node.type === "button" || node.type === "submit" || node.type === "reset")) {
+      var nameFromValue = useAttribute(node, "value");
+      if (nameFromValue !== null) {
+        return nameFromValue;
+      }
+      if (node.type === "submit") {
+        return "Submit";
+      }
+      if (node.type === "reset") {
+        return "Reset";
+      }
+    }
+    var labels = getLabels$1(node);
+    if (labels !== null && labels.length !== 0) {
+      consultedNodes.add(node);
+      return arrayFrom(labels).map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: true,
+          isReferenced: false,
+          recursion: true
+        });
+      }).filter(function(label) {
+        return label.length > 0;
+      }).join(" ");
+    }
+    if (isHTMLInputElement(node) && node.type === "image") {
+      var _nameFromAlt = useAttribute(node, "alt");
+      if (_nameFromAlt !== null) {
+        return _nameFromAlt;
+      }
+      var nameFromTitle = useAttribute(node, "title");
+      if (nameFromTitle !== null) {
+        return nameFromTitle;
+      }
+      return "Submit Query";
+    }
+    if (hasAnyConcreteRoles(node, ["button"])) {
+      var nameFromSubTree = computeMiscTextAlternative(node, {
+        isEmbeddedInLabel: false
+      });
+      if (nameFromSubTree !== "") {
+        return nameFromSubTree;
+      }
+    }
+    return null;
+  }
+  function computeTextAlternative2(current, context) {
+    if (consultedNodes.has(current)) {
+      return "";
+    }
+    if (!hidden && isHidden$1(current, getComputedStyle2) && !context.isReferenced) {
+      consultedNodes.add(current);
+      return "";
+    }
+    var labelAttributeNode = isElement(current) ? current.getAttributeNode("aria-labelledby") : null;
+    var labelElements = labelAttributeNode !== null && !consultedNodes.has(labelAttributeNode) ? queryIdRefs(current, "aria-labelledby") : [];
+    if (compute === "name" && !context.isReferenced && labelElements.length > 0) {
+      consultedNodes.add(labelAttributeNode);
+      return labelElements.map(function(element) {
+        return computeTextAlternative2(element, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: true,
+          // this isn't recursion as specified, otherwise we would skip
+          // `aria-label` in
+          // <input id="myself" aria-label="foo" aria-labelledby="myself"
+          recursion: false
+        });
+      }).join(" ");
+    }
+    var skipToStep2E = context.recursion && isControl(current) && compute === "name";
+    if (!skipToStep2E) {
+      var ariaLabel = (isElement(current) && current.getAttribute("aria-label") || "").trim();
+      if (ariaLabel !== "" && compute === "name") {
+        consultedNodes.add(current);
+        return ariaLabel;
+      }
+      if (!isMarkedPresentational(current)) {
+        var elementTextAlternative = computeElementTextAlternative(current);
+        if (elementTextAlternative !== null) {
+          consultedNodes.add(current);
+          return elementTextAlternative;
+        }
+      }
     }
-    const options = getJiraFieldFilterOptions(field);
-    if (!options.length) continue;
-    upsertFilterGroup(groups, {
-      kind: "jira",
-      id: `jira:${normalizedFieldId}`,
-      fieldName: normalizedFieldId,
-      label: field.name,
-      options
-    });
+    if (hasAnyConcreteRoles(current, ["menu"])) {
+      consultedNodes.add(current);
+      return "";
+    }
+    if (skipToStep2E || context.isEmbeddedInLabel || context.isReferenced) {
+      if (hasAnyConcreteRoles(current, ["combobox", "listbox"])) {
+        consultedNodes.add(current);
+        var selectedOptions = querySelectedOptions(current);
+        if (selectedOptions.length === 0) {
+          return isHTMLInputElement(current) ? current.value : "";
+        }
+        return arrayFrom(selectedOptions).map(function(selectedOption) {
+          return computeTextAlternative2(selectedOption, {
+            isEmbeddedInLabel: context.isEmbeddedInLabel,
+            isReferenced: false,
+            recursion: true
+          });
+        }).join(" ");
+      }
+      if (hasAbstractRole(current, "range")) {
+        consultedNodes.add(current);
+        if (current.hasAttribute("aria-valuetext")) {
+          return current.getAttribute("aria-valuetext");
+        }
+        if (current.hasAttribute("aria-valuenow")) {
+          return current.getAttribute("aria-valuenow");
+        }
+        return current.getAttribute("value") || "";
+      }
+      if (hasAnyConcreteRoles(current, ["textbox"])) {
+        consultedNodes.add(current);
+        return getValueOfTextbox(current);
+      }
+    }
+    if (allowsNameFromContent(current) || isElement(current) && context.isReferenced || isNativeHostLanguageTextAlternativeElement(current) || isDescendantOfNativeHostLanguageTextAlternativeElement()) {
+      var accumulatedText2F = computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+      if (accumulatedText2F !== "") {
+        consultedNodes.add(current);
+        return accumulatedText2F;
+      }
+    }
+    if (current.nodeType === current.TEXT_NODE) {
+      consultedNodes.add(current);
+      return current.textContent || "";
+    }
+    if (context.recursion) {
+      consultedNodes.add(current);
+      return computeMiscTextAlternative(current, {
+        isEmbeddedInLabel: context.isEmbeddedInLabel
+      });
+    }
+    var tooltipAttributeValue = computeTooltipAttributeValue(current);
+    if (tooltipAttributeValue !== null) {
+      consultedNodes.add(current);
+      return tooltipAttributeValue;
+    }
+    consultedNodes.add(current);
+    return "";
   }
+  return asFlatString(computeTextAlternative2(root, {
+    isEmbeddedInLabel: false,
+    // by spec computeAccessibleDescription starts with the referenced elements as roots
+    isReferenced: compute === "description",
+    recursion: false
+  }));
 }
-function appendNotionFieldFilterGroups(groups, selectedFields, fields) {
-  for (const field of fields) {
-    if (!selectedFields.has(field.id) && !selectedFields.has(field.name)) continue;
-    if (!NOTION_FILTERABLE_FIELD_TYPES.has(field.type)) continue;
-    const options = getNotionFieldFilterOptions(field);
-    if (!options.length) continue;
-    upsertFilterGroup(groups, {
-      kind: "notion",
-      id: `notion:${field.id}`,
-      fieldName: field.name,
-      label: field.name,
-      options
-    });
-  }
+function prohibitsNaming(node) {
+  return hasAnyConcreteRoles(node, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "none", "paragraph", "presentation", "strong", "subscript", "superscript"]);
 }
-function composeIssueFilterGroups(integrations, customFields) {
-  const groups = /* @__PURE__ */ new Map();
-  const jiraIntegration = integrations.find((integration) => {
-    const config = getJiraConfig(integration);
-    return integration.is_active !== false && config;
-  });
-  appendCustomFieldFilterGroups(groups, customFields);
-  const jiraConfig = jiraIntegration ? getJiraConfig(jiraIntegration) : null;
-  const configExposedFields = getExposedFields(jiraConfig);
-  if (configExposedFields.length) {
-    appendJiraFieldFilterGroups(
-      groups,
-      new Set(configExposedFields),
-      getLastKnownJiraFields(jiraConfig)
-    );
-  }
-  for (const integration of integrations) {
-    if (integration.is_active === false) continue;
-    const notionConfig = getNotionConfig(integration);
-    if (!notionConfig) continue;
-    appendNotionFieldFilterGroups(
-      groups,
-      new Set(getSelectedNotionFields(notionConfig)),
-      getLastKnownNotionFields(notionConfig)
-    );
+function computeAccessibleName(root) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  if (prohibitsNaming(root)) {
+    return "";
   }
-  return Array.from(groups.values()).sort((a2, b) => a2.label.localeCompare(b.label));
+  return computeTextAlternative(root, options);
 }
-const STABLE_ATTR_KEYS = [
-  "data-testid",
-  "data-test",
-  "data-qa",
-  "data-cy",
-  "name",
-  "aria-label"
-];
 const STATE_CLASS_RE = /^(is-|has-|js-)|^(active|open|selected|disabled|focus|hover|show|hidden|loading|dragging)$/i;
 function looksHashed(segment) {
   if (segment.includes("-")) return false;
@@ -6188,17 +7847,35 @@ function looksHashed(segment) {
   }
   return false;
 }
+const GENERATED_CLASS_PATTERNS = [
+  /^css-[a-z0-9]+(-|$)/i,
+  // emotion / MUI. 라벨이 붙으면 css-1e6y48t-MuiButtonBase-root
+  /^sc-[a-z0-9]+$/i,
+  // styled-components
+  /^makeStyles-.+-\d+$/,
+  // JSS makeStyles
+  /^jss\d+$/,
+  // JSS 기본 생성기
+  /^ng-tns-c\d+-\d+$/,
+  // Angular 애니메이션
+  /^_[\w-]+_[a-z0-9]{5}_\d+$/
+  // Vite CSS Modules 기본값: _로컬_해시(base36 5자)_줄번호
+];
+function hasCssModulesHash(token) {
+  const index = token.lastIndexOf("__");
+  if (index <= 0) return false;
+  const suffix = token.slice(index + 2);
+  return suffix.length === 5 && /^[\w-]+$/.test(suffix) && /[A-Z0-9_-]/.test(suffix);
+}
 function isUnstableToken(token) {
   if (!token) return true;
   if (token.includes(":") || token.includes("/")) return true;
   if (token.includes("--")) return true;
-  if (/^css-[a-z0-9]+$/i.test(token)) return true;
-  if (/^sc-[a-z0-9]+$/i.test(token)) return true;
   if (STATE_CLASS_RE.test(token)) return true;
-  const segments = token.split("__");
-  if (segments.length > 1 && looksHashed(segments[segments.length - 1] ?? "")) return true;
+  if (GENERATED_CLASS_PATTERNS.some((pattern) => pattern.test(token))) return true;
+  if (hasCssModulesHash(token)) return true;
   if (looksHashed(token)) return true;
-  return false;
+  return token.split(/[-_]+/).some(looksHashed);
 }
 function isStableClassName(cls) {
   return !isUnstableToken(cls);
@@ -6211,6 +7888,297 @@ function isUnstableId(id) {
   if (looksHashed(id)) return true;
   return false;
 }
+function intersection(firstArr, secondArr) {
+  const secondSet = new Set(secondArr);
+  return firstArr.filter((item) => secondSet.has(item));
+}
+function uniq(arr) {
+  return [...new Set(arr)];
+}
+function union(arr1, arr2) {
+  return uniq(arr1.concat(arr2));
+}
+const LOCATOR_TEXT_MAX = 80;
+const RAW_SLICE_FACTOR = 8;
+const LOCATOR_RAW_TEXT_MAX = LOCATOR_TEXT_MAX * RAW_SLICE_FACTOR;
+function dropTrailingLoneSurrogate(value) {
+  return /[\uD800-\uDBFF]$/.test(value) ? value.slice(0, -1) : value;
+}
+function cleanLocatorText(value, max2 = LOCATOR_TEXT_MAX) {
+  if (!value) return void 0;
+  const bounded = value.slice(0, max2 * RAW_SLICE_FACTOR);
+  const cleaned = dropTrailingLoneSurrogate(
+    redactSensitiveValues(bounded.replace(/\s+/g, " ").trim()).slice(0, max2)
+  ).trim();
+  return cleaned || void 0;
+}
+function normalizeForCompare(value) {
+  return value.toLowerCase().replace(/\d+/g, "#");
+}
+function jaccard(a2, b) {
+  const all = union(uniq(a2), uniq(b));
+  if (all.length === 0) return 0;
+  return intersection(uniq(a2), uniq(b)).length / all.length;
+}
+function textSimilarity(a2, b) {
+  const left = normalizeForCompare(a2);
+  const right = normalizeForCompare(b);
+  if (left === right) return 1;
+  const [shorter, longer] = left.length <= right.length ? [left, right] : [right, left];
+  const containment = shorter && longer.startsWith(shorter) ? shorter.length / longer.length : 0;
+  return Math.max(jaccard(left.split(" "), right.split(" ")), containment);
+}
+function labelSimilarity(stored, observed) {
+  const storedWords = new Set(normalizeForCompare(stored).split(" "));
+  const observedWords = new Set(normalizeForCompare(observed).split(" "));
+  const [smaller, larger] = storedWords.size <= observedWords.size ? [storedWords, observedWords] : [observedWords, storedWords];
+  const isStrictSubset = larger.size > smaller.size && [...smaller].every((w) => larger.has(w));
+  return isStrictSubset ? 0 : textSimilarity(stored, observed);
+}
+function digitGroups(value) {
+  return (value.match(/\d+/g) ?? []).join(" ");
+}
+function sameDigitGroups(a2, b) {
+  return digitGroups(a2) === digitGroups(b);
+}
+function labelSimilarityKeepingDigits(stored, observed) {
+  const left = stored.replace(/\s+/g, " ").trim();
+  const right = observed.replace(/\s+/g, " ").trim();
+  return sameDigitGroups(left, right) ? labelSimilarity(left, right) : 0;
+}
+const TEST_ATTR_KEYS = ["data-testid", "data-test", "data-qa", "data-cy"];
+const OTHER_ATTR_KEYS = ["name", "type", "placeholder", "alt", "title", "href", "src"];
+const URL_ATTR_KEYS = /* @__PURE__ */ new Set(["href", "src"]);
+const ATTR_VALUE_MAX = 120;
+const CLASS_LIMIT = 5;
+const LOCATOR_SIZE_MAX = 1024;
+const CONTAINER_ROLES = /* @__PURE__ */ new Set(["dialog", "alertdialog", "menu", "listbox", "tooltip"]);
+const CONTAINER_SELECTOR = 'dialog, [role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"], [role="tooltip"]';
+const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+  "banner",
+  "navigation",
+  "main",
+  "complementary",
+  "contentinfo",
+  "region",
+  "form",
+  "search"
+]);
+const NAMED_ONLY_LANDMARKS = /* @__PURE__ */ new Set(["region", "form"]);
+const ROW_SELECTOR = 'li, tr, [role="row"], [role="listitem"], [role="option"]';
+const HEADING_SELECTOR = 'h1, h2, h3, h4, h5, h6, [role="heading"]';
+function safeRole(element) {
+  try {
+    return getRole(element) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function safeAccessibleName(element) {
+  try {
+    return cleanLocatorText(computeAccessibleName(element));
+  } catch {
+    return void 0;
+  }
+}
+function landmarkRole(node) {
+  const role = safeRole(node);
+  if (role === void 0 || !LANDMARK_ROLES.has(role)) return void 0;
+  if (NAMED_ONLY_LANDMARKS.has(role) && !safeAccessibleName(node)) return void 0;
+  return role;
+}
+function collectHeadings(doc) {
+  return Array.from(doc.querySelectorAll(HEADING_SELECTOR));
+}
+function matchesMask(element) {
+  try {
+    return element.matches(SESSION_REPLAY_FULL_MASK_SELECTOR);
+  } catch {
+    return true;
+  }
+}
+function hasMaskedDescendant(root) {
+  try {
+    return root.querySelector(SESSION_REPLAY_FULL_MASK_SELECTOR) !== null;
+  } catch {
+    return true;
+  }
+}
+function visibleText(root) {
+  if (!hasMaskedDescendant(root)) return root.textContent ?? "";
+  const walker = root.ownerDocument.createTreeWalker(
+    root,
+    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
+    (node) => node.nodeType === Node.ELEMENT_NODE && matchesMask(node) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT
+  );
+  let text = "";
+  for (let node = walker.nextNode(); node && text.length < LOCATOR_RAW_TEXT_MAX; ) {
+    if (node.nodeType === Node.TEXT_NODE) text += node.nodeValue ?? "";
+    node = walker.nextNode();
+  }
+  return text;
+}
+function closestAncestor(element, matches) {
+  let current = element.parentElement;
+  while (current) {
+    if (matches(current)) return current;
+    current = current.parentElement;
+  }
+  return null;
+}
+function nearestPrecedingHeading(element, headings) {
+  let found = null;
+  for (const heading of headings) {
+    if (heading === element || heading.contains(element)) continue;
+    if (heading.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING) {
+      found = heading;
+    } else {
+      break;
+    }
+  }
+  return found;
+}
+function rowTextOf(element) {
+  const row = element.closest(ROW_SELECTOR);
+  if (!row) return void 0;
+  const label = Array.from(row.children).find(
+    (cell) => !cell.contains(element) && visibleText(cell).trim()
+  );
+  const source = label ?? row;
+  if (isElementFullyMasked(source)) return void 0;
+  return cleanLocatorText(visibleText(source));
+}
+function urlPath(value, doc) {
+  try {
+    const url = new URL(value, doc.baseURI);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.pathname : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function attrValue(element, key) {
+  const raw = element.getAttribute(key);
+  if (!raw) return void 0;
+  return cleanLocatorText(
+    URL_ATTR_KEYS.has(key) ? urlPath(raw, element.ownerDocument) : raw,
+    ATTR_VALUE_MAX
+  );
+}
+function sharesUrlPath(element, key, value) {
+  return Array.from(element.ownerDocument.getElementsByTagName(element.tagName)).some(
+    (other) => other !== element && attrValue(other, key) === value
+  );
+}
+function collectAttrs(element, masked, uniqueUrlAttrs) {
+  const attrs = {};
+  const keys = masked ? TEST_ATTR_KEYS : [...TEST_ATTR_KEYS, ...OTHER_ATTR_KEYS];
+  for (const key of keys) {
+    const value = attrValue(element, key);
+    if (!value) continue;
+    if (uniqueUrlAttrs && URL_ATTR_KEYS.has(key) && sharesUrlPath(element, key, value)) continue;
+    attrs[key] = value;
+  }
+  return Object.keys(attrs).length ? attrs : void 0;
+}
+function collectClasses(element) {
+  const classes = Array.from(element.classList).filter(isStableClassName).slice(0, CLASS_LIMIT);
+  return classes.length ? classes : void 0;
+}
+function tagIndex(element, scope) {
+  return Array.from(scope.getElementsByTagName(element.tagName)).indexOf(element);
+}
+function labelSources(element) {
+  var _a;
+  const doc = element.ownerDocument;
+  const ids = ((_a = element.getAttribute("aria-labelledby")) == null ? void 0 : _a.split(/\s+/).filter(Boolean)) ?? [];
+  const sources = ids.map((id) => doc.getElementById(id)).filter((node) => node !== null);
+  const labels = element.labels;
+  if (labels) sources.push(...Array.from(labels));
+  const wrapping = element.closest("label");
+  if (wrapping) sources.push(wrapping);
+  return sources;
+}
+function labelSourceMasked(element) {
+  return labelSources(element).some(
+    (node) => isElementFullyMasked(node) || hasMaskedDescendant(node)
+  );
+}
+function capSize(locator) {
+  const size = () => JSON.stringify(locator).length;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.classes;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  if (locator.context) delete locator.context.heading;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  if (locator.attrs) {
+    for (const key of OTHER_ATTR_KEYS) delete locator.attrs[key];
+  }
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.context;
+  if (size() <= LOCATOR_SIZE_MAX) return locator;
+  delete locator.text;
+  return locator;
+}
+function buildElementLocator(element, options = {}) {
+  try {
+    return buildLocatorUnsafe(element, options);
+  } catch {
+    return { v: 1, tag: element.localName || element.tagName.toLowerCase() };
+  }
+}
+function buildLocatorUnsafe(element, options) {
+  const doc = element.ownerDocument;
+  const masked = isElementFullyMasked(element);
+  const locator = { v: 1, tag: element.tagName.toLowerCase() };
+  const role = safeRole(element);
+  if (role) locator.role = role;
+  if (!masked) {
+    const nameMasked = hasMaskedDescendant(element) || labelSourceMasked(element);
+    if (options.includeName !== false && !nameMasked) {
+      const name = safeAccessibleName(element);
+      if (name) locator.name = name;
+    }
+    const text = cleanLocatorText(visibleText(element));
+    if (text) locator.text = text;
+  }
+  const attrs = collectAttrs(element, masked, options.uniqueUrlAttrs !== false);
+  if (attrs) locator.attrs = attrs;
+  const classes = collectClasses(element);
+  if (classes) locator.classes = classes;
+  const container = closestAncestor(element, (node) => {
+    const nodeRole = safeRole(node);
+    return nodeRole !== void 0 && CONTAINER_ROLES.has(nodeRole);
+  });
+  const landmark = closestAncestor(element, (node) => landmarkRole(node) !== void 0);
+  const heading = nearestPrecedingHeading(element, options.headings ?? collectHeadings(doc));
+  const rowText = masked ? void 0 : rowTextOf(element);
+  const context = {};
+  if (container) {
+    const containerName = isElementFullyMasked(container) || hasMaskedDescendant(container) || labelSourceMasked(container) ? void 0 : safeAccessibleName(container);
+    context.container = {
+      role: safeRole(container),
+      ...containerName ? { name: containerName } : {}
+    };
+  }
+  if (landmark) context.landmark = landmarkRole(landmark);
+  const headingText = heading && !isElementFullyMasked(heading) ? cleanLocatorText(visibleText(heading)) : void 0;
+  if (headingText) context.heading = headingText;
+  if (rowText) context.rowText = rowText;
+  if (Object.keys(context).length) locator.context = context;
+  if (options.includeRoleIndex !== false) {
+    const index = tagIndex(element, container ?? doc);
+    if (index >= 0) locator.roleIndex = index;
+  }
+  return capSize(locator);
+}
+const STABLE_ATTR_KEYS = [
+  "data-testid",
+  "data-test",
+  "data-qa",
+  "data-cy",
+  "name",
+  "aria-label"
+];
 function cssAttrValue(value) {
   return value.replace(/(["\\])/g, "\\$1");
 }
@@ -6279,8 +8247,8 @@ function getElementSelector(element) {
   const segments = [];
   let current = element;
   let depth = 0;
-  const MAX_DEPTH = 5;
-  while (current && current.nodeType === Node.ELEMENT_NODE && depth < MAX_DEPTH) {
+  const MAX_DEPTH2 = 5;
+  while (current && current.nodeType === Node.ELEMENT_NODE && depth < MAX_DEPTH2) {
     segments.unshift(structuralSegment(current));
     const candidate = segments.join(" > ");
     if (matchesUniquely(candidate, element)) return candidate;
@@ -6320,9 +8288,15 @@ function getXPath(element) {
   }
   return parts.length ? `/html/body/${parts.join("/")}` : "/html/body";
 }
-function getElementPosition(element, event) {
+function getElementPosition(element, event, options = {}) {
   const rect = element.getBoundingClientRect();
   const scroll = getScrollPosition();
+  let component = null;
+  try {
+    component = (options.collectComponent ?? collectComponentPath)(element);
+  } catch {
+    component = null;
+  }
   return {
     x: event ? event.clientX + scroll.x : rect.left + scroll.x,
     y: event ? event.clientY + scroll.y : rect.top + scroll.y,
@@ -6334,7 +8308,9 @@ function getElementPosition(element, event) {
       top: rect.top + scroll.y,
       width: rect.width,
       height: rect.height
-    }
+    },
+    locator: buildElementLocator(element),
+    ...component ? { component } : {}
   };
 }
 function findElementByXPath(xpath) {
@@ -7964,15 +9940,133 @@ var Anchor2 = PopoverAnchor$1;
 var Trigger = PopoverTrigger$1;
 var Portal = PopoverPortal;
 var Content2 = PopoverContent$1;
-const Popover = Root2;
+const FLOATING_LAYER_SELECTOR = "[data-radix-popper-content-wrapper]";
+const OUTSIDE_EVENTS = ["pointerdown", "focusin"];
+const roots = /* @__PURE__ */ new Map();
+function isInsideLayer(path, content) {
+  return path.some((node) => {
+    if (!(node instanceof Element)) return false;
+    if (node === content) return true;
+    if (content.id && node.getAttribute("aria-controls") === content.id) return true;
+    return node.matches(FLOATING_LAYER_SELECTOR) && !node.contains(content);
+  });
+}
+function dismissTopLayer(root, event) {
+  var _a;
+  const layers = (_a = roots.get(root)) == null ? void 0 : _a.layers;
+  const top = layers == null ? void 0 : layers[layers.length - 1];
+  if (!top) return;
+  if (event.type === "focusin" && !top.focusOutside) return;
+  if (isInsideLayer(event.composedPath(), top.content)) return;
+  top.dismiss();
+}
+function listen(root) {
+  const doc = root.ownerDocument;
+  const onRoot = (event) => dismissTopLayer(root, event);
+  const onDocument = (event) => {
+    if (!event.composedPath().includes(root)) dismissTopLayer(root, event);
+  };
+  OUTSIDE_EVENTS.forEach((type) => {
+    root.addEventListener(type, onRoot);
+    doc.addEventListener(type, onDocument);
+  });
+  return () => OUTSIDE_EVENTS.forEach((type) => {
+    root.removeEventListener(type, onRoot);
+    doc.removeEventListener(type, onDocument);
+  });
+}
+function registerLayer(root, layer) {
+  let entry = roots.get(root);
+  if (!entry) {
+    entry = { layers: [], detach: listen(root) };
+    roots.set(root, entry);
+  }
+  entry.layers.push(layer);
+  return () => {
+    const current = roots.get(root);
+    if (!current) return;
+    current.layers = current.layers.filter((item) => item !== layer);
+    if (current.layers.length === 0) {
+      current.detach();
+      roots.delete(root);
+    }
+  };
+}
+function useShadowOutsideDismiss(onDismiss, { focusOutside = true } = {}) {
+  const onDismissRef = useRef(onDismiss);
+  const detachRef = useRef(null);
+  useEffect(() => {
+    onDismissRef.current = onDismiss;
+  }, [onDismiss]);
+  useEffect(() => () => {
+    var _a;
+    return (_a = detachRef.current) == null ? void 0 : _a.call(detachRef);
+  }, []);
+  return useCallback(
+    (content) => {
+      var _a;
+      (_a = detachRef.current) == null ? void 0 : _a.call(detachRef);
+      detachRef.current = null;
+      if (!content) return;
+      const root = content.getRootNode();
+      if (!(root instanceof ShadowRoot)) return;
+      detachRef.current = registerLayer(root, {
+        content,
+        focusOutside,
+        dismiss: () => {
+          var _a2;
+          return (_a2 = onDismissRef.current) == null ? void 0 : _a2.call(onDismissRef);
+        }
+      });
+    },
+    [focusOutside]
+  );
+}
+function createShadowDismissRoot(Root3, options) {
+  const DismissContext = React.createContext(void 0);
+  function ShadowDismissRoot({ open, defaultOpen = false, onOpenChange, ...rest }) {
+    const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen);
+    const isControlled = open !== void 0;
+    const setOpen = React.useCallback(
+      (next) => {
+        if (!isControlled) setUncontrolledOpen(next);
+        onOpenChange == null ? void 0 : onOpenChange(next);
+      },
+      [isControlled, onOpenChange]
+    );
+    const dismiss2 = React.useCallback(() => setOpen(false), [setOpen]);
+    return /* @__PURE__ */ jsx(DismissContext.Provider, { value: dismiss2, children: /* @__PURE__ */ jsx(
+      Root3,
+      {
+        ...rest,
+        open: isControlled ? open : uncontrolledOpen,
+        onOpenChange: setOpen
+      }
+    ) });
+  }
+  function useContentDismissRef(forwardedRef) {
+    const dismissRef = useShadowOutsideDismiss(React.useContext(DismissContext), options);
+    return React.useCallback(
+      (node) => {
+        dismissRef(node);
+        if (typeof forwardedRef === "function") forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+      },
+      [dismissRef, forwardedRef]
+    );
+  }
+  return [ShadowDismissRoot, useContentDismissRef];
+}
+const [Popover, usePopoverContentDismissRef] = createShadowDismissRoot(Root2);
 const PopoverTrigger = Trigger;
 const PopoverAnchor = Anchor2;
 const PopoverContent = React.forwardRef(({ className, align = "center", sideOffset = 6, onEscapeKeyDown, ...props }, ref) => {
   const portalContainer = usePortalContainer();
+  const contentRef = usePopoverContentDismissRef(ref);
   return /* @__PURE__ */ jsx(Portal, { container: portalContainer, children: /* @__PURE__ */ jsx(
     Content2,
     {
-      ref,
+      ref: contentRef,
       align,
       sideOffset,
       onEscapeKeyDown: stopEscapePropagation(onEscapeKeyDown),
@@ -9354,7 +11448,9 @@ const X = createLucideIcon("X", [
   ["path", { d: "M18 6 6 18", key: "1bl5f8" }],
   ["path", { d: "m6 6 12 12", key: "d8bk6v" }]
 ]);
-const Select$1 = Select$2;
+const [Select$1, useSelectContentDismissRef] = createShadowDismissRoot(Select$2, {
+  focusOutside: false
+});
 const SelectValue = SelectValue$1;
 const SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs(
   SelectTrigger$1,
@@ -9406,10 +11502,11 @@ const SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) =
 SelectScrollDownButton.displayName = SelectScrollDownButton$1.displayName;
 const SelectContent = React.forwardRef(({ className, children, position = "popper", onEscapeKeyDown, ...props }, ref) => {
   const portalContainer = usePortalContainer();
+  const contentRef = useSelectContentDismissRef(ref);
   return /* @__PURE__ */ jsx(SelectPortal, { container: portalContainer, children: /* @__PURE__ */ jsxs(
     SelectContent$1,
     {
-      ref,
+      ref: contentRef,
       "data-testid": "select-content",
       sideOffset: 6,
       onEscapeKeyDown: stopEscapePropagation(onEscapeKeyDown),
@@ -13977,6 +16074,7 @@ function DatePicker({
   };
   const showClear = clearable && Boolean(value) && !disabled;
   const selectedDate = fromIso(value);
+  const dismissRef = useShadowOutsideDismiss(React.useCallback(() => setOpen(false), []));
   return /* @__PURE__ */ jsxs(Root2, { open, onOpenChange: setOpen, children: [
     /* @__PURE__ */ jsx(
       DatePickerTriggerField,
@@ -13994,6 +16092,7 @@ function DatePicker({
     /* @__PURE__ */ jsx(Portal, { container: portalContainer, children: /* @__PURE__ */ jsx(
       Content2,
       {
+        ref: dismissRef,
         align,
         side: "bottom",
         sideOffset: 6,
@@ -15109,50 +17208,6 @@ function useOnboardingFlow() {
     [context]
   );
 }
-let nextId = 0;
-let toasts = [];
-const listeners = /* @__PURE__ */ new Set();
-function emit() {
-  listeners.forEach((l2) => l2());
-}
-function addToast(message2, type, options) {
-  const id = `toast-${++nextId}`;
-  const t2 = {
-    id,
-    message: message2,
-    type,
-    action: options == null ? void 0 : options.action,
-    duration: (options == null ? void 0 : options.duration) ?? 2e3,
-    createdAt: Date.now()
-  };
-  toasts = [...toasts, t2];
-  emit();
-  return id;
-}
-function dismiss(id) {
-  toasts = toasts.filter((t2) => t2.id !== id);
-  emit();
-}
-function dismissAll() {
-  toasts = [];
-  emit();
-}
-function toast(message2, options) {
-  return addToast(message2, "default", options);
-}
-toast.success = (message2, options) => addToast(message2, "success", options);
-toast.warning = (message2, options) => addToast(message2, "warning", options);
-toast.error = (message2, options) => addToast(message2, "error", options);
-toast.info = (message2, options) => addToast(message2, "info", options);
-toast.dismiss = dismiss;
-toast.dismissAll = dismissAll;
-function subscribe(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-function getSnapshot() {
-  return toasts;
-}
 ({
   type: [NetworkLogType.XMLHTTPREQUEST, NetworkLogType.FETCH]
 });
@@ -15294,20 +17349,6 @@ function filterExcludeServiceRelatedConsoleLogs(consoleLogs) {
     return !isIssueStickerInternalConsoleLog(log) && !isIssueStickerServiceConsoleLog(log);
   });
 }
-const TRANSCRIPT_CONTENT_TYPE = "application/gzip";
-async function uploadSocketTranscript(api, snapshot, options = {}) {
-  if (snapshot.sizeBytes > SOCKET_TRANSCRIPT_MAX_BYTES) return null;
-  try {
-    const file = new File([snapshot.payload], "socket-transcript.json.gz", {
-      type: TRANSCRIPT_CONTENT_TYPE
-    });
-    const uploaded = await uploadSignedMediaWithApi(api, file, "socket", options);
-    return { uploadId: uploaded.id };
-  } catch (error) {
-    devLogger.error("socketTranscriptUpload", "소켓 전사 업로드 실패:", error);
-    return null;
-  }
-}
 function buildExternalUserPayload(user) {
   if (!user) return {};
   return {
@@ -15316,91 +17357,115 @@ function buildExternalUserPayload(user) {
   };
 }
 export {
-  Portal as $,
-  trimLogBackupPayload as A,
-  createSafeLogBackup as B,
+  SelectValue as $,
+  SessionReplayCaptureController as A,
+  preloadModernScreenshot as B,
   ConsoleCollector as C,
-  getLogBackupSessionId as D,
-  createIndexedDbLogBackup as E,
-  PopoverTrigger as F,
-  Input as G,
-  PopoverContent as H,
+  enqueueIssueUploads as D,
+  normalizeUploadMimeType as E,
+  toSessionReplayMeta as F,
+  loadTusClient as G,
+  createIndexedDbPendingUploadStore as H,
   ISSUE_STICKER_INTERNAL_LOG_PREFIX as I,
-  Select$1 as J,
-  SelectTrigger as K,
-  Label as L,
-  SelectValue as M,
+  ATTACHMENT_UPLOAD_DB_NAME as J,
+  createMediaUploadApi as K,
+  toast as L,
+  trimLogBackupPayload as M,
   NetworkCollector as N,
-  SelectContent as O,
-  Popover as P,
-  SelectItem as Q,
-  JIRA_ISSUE_TYPE_VALUE_KEY as R,
+  createSafeLogBackup as O,
+  getLogBackupSessionId as P,
+  createIndexedDbLogBackup as Q,
+  Popover as R,
   ScreenRecordingController as S,
-  getJiraMetadata as T,
-  buildJiraIssueFields as U,
-  getJiraIssueTypeLabel as V,
+  PopoverTrigger as T,
+  Input as U,
+  VIDEO_UPLOAD_DB_NAME as V,
   WebSocketCollector as W,
-  Button$1 as X,
-  Root2 as Y,
-  Trigger as Z,
-  ChevronDown as _,
+  PopoverContent as X,
+  Label as Y,
+  Select$1 as Z,
+  SelectTrigger as _,
   uploadSignedMediaWithApi as a,
-  Content2 as a0,
-  Check as a1,
-  X as a2,
-  DatePicker as a3,
-  getNotionPageMetadata as a4,
-  buildNotionFieldViews as a5,
-  DirectUploadError as a6,
-  toast as a7,
-  getSnapshot as a8,
-  subscribe as a9,
-  getRegisteredUploadId as aa,
-  ChevronRight as ab,
-  ReactRemoveScroll as ac,
-  hideOthers as ad,
-  useFocusGuards as ae,
-  FocusScope as af,
-  getExposedJiraFields as ag,
-  isJiraFieldExposed as ah,
-  normalizeExposedJiraFields as ai,
-  resolveJiraIssueTypeId as aj,
-  pickJiraIssueTypeFields as ak,
-  switchJiraIssueType as al,
-  getPrimaryJiraMapping as am,
-  createCollection as an,
-  useDirection as ao,
-  getPrimaryNotionMapping as ap,
-  buttonVariants as aq,
-  findElementBySelector as ar,
-  findElementByXPath as as,
-  OnboardingProvider as at,
-  useOnboardingTarget as au,
-  useOnboardingFlow as av,
-  PopoverAnchor as aw,
-  buildJiraCreateFields as b,
-  captureWithModernScreenshot as c,
+  SelectContent as a0,
+  SelectItem as a1,
+  JIRA_ISSUE_TYPE_VALUE_KEY as a2,
+  getJiraMetadata as a3,
+  buildJiraIssueFields as a4,
+  getJiraIssueTypeLabel as a5,
+  Button$1 as a6,
+  Root2 as a7,
+  Trigger as a8,
+  ChevronDown as a9,
+  useShadowOutsideDismiss as aA,
+  getPrimaryNotionMapping as aB,
+  buttonVariants as aC,
+  TEST_ATTR_KEYS as aD,
+  jaccard as aE,
+  textSimilarity as aF,
+  collectHeadings as aG,
+  buildElementLocator as aH,
+  normalizeForCompare as aI,
+  CONTAINER_SELECTOR as aJ,
+  safeRole as aK,
+  safeAccessibleName as aL,
+  sameDigitGroups as aM,
+  labelSimilarityKeepingDigits as aN,
+  landmarkRole as aO,
+  findElementBySelector as aP,
+  findElementByXPath as aQ,
+  OnboardingProvider as aR,
+  useOnboardingTarget as aS,
+  useOnboardingFlow as aT,
+  PopoverAnchor as aU,
+  Portal as aa,
+  Content2 as ab,
+  Check as ac,
+  X as ad,
+  DatePicker as ae,
+  getNotionPageMetadata as af,
+  buildNotionFieldViews as ag,
+  DirectUploadError as ah,
+  getRegisteredUploadId as ai,
+  getSnapshot as aj,
+  subscribe as ak,
+  ChevronRight as al,
+  ReactRemoveScroll as am,
+  hideOthers as an,
+  useFocusGuards as ao,
+  FocusScope as ap,
+  createShadowDismissRoot as aq,
+  getExposedJiraFields as ar,
+  isJiraFieldExposed as as,
+  normalizeExposedJiraFields as at,
+  resolveJiraIssueTypeId as au,
+  pickJiraIssueTypeFields as av,
+  switchJiraIssueType as aw,
+  getPrimaryJiraMapping as ax,
+  createCollection as ay,
+  useDirection as az,
+  captureWithModernScreenshot as b,
+  captureViewportWithElementCrop as c,
   directUploadToSignedUrl as d,
-  buildNotionCreateFields as e,
-  buildGuestOwnerQuery as f,
+  buildJiraCreateFields as e,
+  buildNotionCreateFields as f,
   getElementPosition as g,
-  composeIssueFilterGroups as h,
-  buildIssueIntegrationsPayload as i,
-  devLogger as j,
-  filterExcludeServiceRelatedLogs as k,
-  filterExcludeServiceRelatedConsoleLogs as l,
-  compactNetworkLogsForTransport as m,
-  CONSOLE_LOG_SUBMIT_LIMIT as n,
-  buildExternalUserPayload as o,
+  buildGuestOwnerQuery as h,
+  composeIssueFilterGroups as i,
+  buildIssueIntegrationsPayload as j,
+  devLogger as k,
+  filterExcludeServiceRelatedLogs as l,
+  filterExcludeServiceRelatedConsoleLogs as m,
+  compactNetworkLogsForTransport as n,
+  CONSOLE_LOG_SUBMIT_LIMIT as o,
   pristineFetch as p,
-  shrinkNetworkLogsToFit as q,
-  measureJsonBytes as r,
+  buildExternalUserPayload as q,
+  shrinkNetworkLogsToFit as r,
   selectNetworkLogsForSubmit as s,
-  sanitizeString as t,
+  measureJsonBytes as t,
   uploadScreenshotDataUrls as u,
-  serializeSocketTranscript as v,
-  uploadSocketTranscript as w,
-  getCurrentPageUrl as x,
-  SessionReplayCaptureController as y,
-  preloadModernScreenshot as z
+  sanitizeString as v,
+  collectAttachmentUploads as w,
+  hasReplayUpload as x,
+  getCurrentPageUrl as y,
+  createIssueUploadQueues as z
 };