issue-sticker 0.11.0 → 0.12.0

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

@@ -1,4 +1,4 @@
-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, A as Anchor, m as useControllableState, B as Root2$1, n 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-DQdLNs7v.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, useRef, useEffect, useCallback, createContext, useContext, useLayoutEffect, useMemo } from "react";
@@ -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-DQdLNs7v.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-DQdLNs7v.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 };
@@ -2920,53 +2945,836 @@ async function captureWithModernScreenshot(options) {
         SCREENSHOT_DATA_URL_QUALITY
       )
     );
-  } finally {
-    canvasFrames.forEach((frame) => frame.bitmap.close());
-    excludeSnapshot.cleanup();
-    stickySnapshot.cleanup();
+  } finally {
+    canvasFrames.forEach((frame) => frame.bitmap.close());
+    excludeSnapshot.cleanup();
+    stickySnapshot.cleanup();
+  }
+}
+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 }
+  };
+}
+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();
+  }
+}
+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 };
+}
+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 {
+}
+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;
+}
+function stripMimeParameters(mimeType) {
+  return mimeType.split(";", 1)[0].trim().toLowerCase();
+}
+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 = () => resolve(reader.result);
+    reader.onerror = () => reject(reader.error ?? new Error("업로드 파일을 읽지 못했습니다."));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function lockName(recordId) {
+  return `issue-sticker-upload:${recordId}`;
+}
+function lockManager() {
+  return typeof navigator !== "undefined" ? navigator.locks : void 0;
+}
+async function heldLockNames() {
+  var _a;
+  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();
+  }
+}
+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("");
+}
+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;
+  }
+  /** 그 이슈의 실패 기록을 전부 다시 올린다. 첨부 대기열은 한 이슈에 리플레이·소켓 두 기록을 둔다. */
+  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";
+      }
+    );
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    callSafely(() => listener(this.snapshot()));
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  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";
+      }
+    );
+  }
+  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 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 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 } : {}
+  };
 }
-const __vite_import_meta_env__ = { "DEV": false };
-function isDevLoggingEnabled() {
-  const env = __vite_import_meta_env__;
-  {
-    return env.DEV;
+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;
 }
-function isInternalDebugLog(message2) {
-  return Boolean(message2 == null ? void 0 : message2.includes(ISSUE_STICKER_INTERNAL_LOG_PREFIX));
+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 write(method, scope, args) {
-  if (!isDevLoggingEnabled()) {
-    return;
-  }
-  const log = console[method];
-  log(ISSUE_STICKER_INTERNAL_LOG_PREFIX, `[${scope}]`, ...args);
+function hasReplayUpload(uploads) {
+  return uploads.some((upload) => upload.mediaType === "replay");
 }
-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);
+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);
@@ -3014,7 +3822,8 @@ async function directUploadToSignedUrl(signedUrl, file, contentType) {
   const response = await fetch(signedUrl, {
     method: "PUT",
     headers: {
-      "Content-Type": contentType
+      "Content-Type": contentType,
+      "x-client-info": "issue-sticker-sdk"
     },
     body: file
   });
@@ -3066,6 +3875,83 @@ async function uploadSignedMediaWithApi(api, file, mediaType, options = {}) {
     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) {
@@ -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);
@@ -5649,64 +6536,6 @@ class NetworkCollector {
     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 }));
-  }
-  return {
-    payload,
-    checksumSha256: await sha256Hex(payload),
-    sizeBytes: payload.byteLength,
-    connectionCount: connections.length,
-    frameCount
-  };
-}
 var NetworkLogType = /* @__PURE__ */ ((NetworkLogType2) => {
   NetworkLogType2["MAIN_FRAME"] = "main_frame";
   NetworkLogType2["SUB_FRAME"] = "sub_frame";
@@ -9112,6 +9941,8 @@ var Trigger = PopoverTrigger$1;
 var Portal = PopoverPortal;
 var Content2 = PopoverContent$1;
 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;
@@ -9120,7 +9951,48 @@ function isInsideLayer(path, content) {
     return node.matches(FLOATING_LAYER_SELECTOR) && !node.contains(content);
   });
 }
-function useShadowOutsideDismiss(onDismiss) {
+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(() => {
@@ -9130,45 +10002,67 @@ function useShadowOutsideDismiss(onDismiss) {
     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;
-    const handle = (event) => {
-      var _a2;
-      if (isInsideLayer(event.composedPath(), content)) return;
-      (_a2 = onDismissRef.current) == null ? void 0 : _a2.call(onDismissRef);
-    };
-    const types = ["pointerdown", "focusin"];
-    types.forEach((type) => root.addEventListener(type, handle));
-    detachRef.current = () => types.forEach((type) => root.removeEventListener(type, handle));
-  }, []);
+  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]
+  );
 }
-const PopoverOpenChangeContext = React.createContext(
-  void 0
-);
-function Popover(props) {
-  return /* @__PURE__ */ jsx(PopoverOpenChangeContext.Provider, { value: props.onOpenChange, children: /* @__PURE__ */ jsx(Root2, { ...props }) });
+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 onOpenChange = React.useContext(PopoverOpenChangeContext);
-  const dismissRef = useShadowOutsideDismiss(
-    React.useCallback(() => onOpenChange == null ? void 0 : onOpenChange(false), [onOpenChange])
-  );
-  const contentRef = React.useCallback(
-    (node) => {
-      dismissRef(node);
-      if (typeof ref === "function") ref(node);
-      else if (ref) ref.current = node;
-    },
-    [dismissRef, ref]
-  );
+  const contentRef = usePopoverContentDismissRef(ref);
   return /* @__PURE__ */ jsx(Portal, { container: portalContainer, children: /* @__PURE__ */ jsx(
     Content2,
     {
@@ -10554,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,
@@ -10606,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),
@@ -16311,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]
 });
@@ -16496,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 {
@@ -16518,103 +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,
-  sameDigitGroups as aA,
-  labelSimilarityKeepingDigits as aB,
-  landmarkRole as aC,
-  findElementBySelector as aD,
-  findElementByXPath as aE,
-  OnboardingProvider as aF,
-  useOnboardingTarget as aG,
-  useOnboardingFlow as aH,
-  PopoverAnchor as aI,
-  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,
-  TEST_ATTR_KEYS as ar,
-  jaccard as as,
-  textSimilarity as at,
-  collectHeadings as au,
-  buildElementLocator as av,
-  normalizeForCompare as aw,
-  CONTAINER_SELECTOR as ax,
-  safeRole as ay,
-  safeAccessibleName as az,
-  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
 };