issue-sticker 0.1.1 → 0.2.0

package/dist/issue-sticker-headless.js

@@ -0,0 +1,1914 @@
+import { u as uploadScreenshotDataUrls, a as uploadSignedMediaWithApi, d as directUploadWithFallback, n as normalizeExposedJiraFields, b as normalizeJiraFieldId, g as getElementPosition, c as captureWithModernScreenshot, e as buildJiraCreateFields, f as buildNotionCreateFields, s as syncExternalIssueIntegrations, h as devLogger, C as ConsoleCollector, N as NetworkCollector, i as filterExcludeServiceRelatedLogs, j as filterExcludeServiceRelatedConsoleLogs, k as compactNetworkLogsForTransport, l as sanitizeString, S as ScreenRecordingController, m as SessionReplayCaptureController, p as preloadModernScreenshot } from "./NetworkCollector-BlY2qUKF.js";
+import "react/jsx-runtime";
+import "react";
+import "./createLucideIcon-B457EluY.js";
+class IssueStickerHeadlessError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "IssueStickerHeadlessError";
+  }
+}
+function readApiBaseUrlFromEnv() {
+  if (typeof process !== "undefined" && process.env && Object.prototype.hasOwnProperty.call(process.env, "VITE_API_BASE_URL")) {
+    const value = process.env.VITE_API_BASE_URL;
+    return typeof value === "string" && value.trim() && value.trim() !== "undefined" ? value.trim() : void 0;
+  }
+  const viteValue = "https://api.issuesticker.com";
+  return typeof viteValue === "string" && viteValue.trim() && viteValue.trim() !== "undefined" ? viteValue.trim() : void 0;
+}
+function getApiBaseUrl() {
+  const baseUrl = readApiBaseUrlFromEnv();
+  if (!baseUrl) {
+    throw new IssueStickerHeadlessError(
+      "NETWORK_ERROR",
+      "API 서버 주소(VITE_API_BASE_URL)가 설정되지 않았습니다."
+    );
+  }
+  if (!/^https?:\/\//.test(baseUrl)) {
+    throw new IssueStickerHeadlessError(
+      "NETWORK_ERROR",
+      `API 서버 주소(VITE_API_BASE_URL)가 올바르지 않습니다: ${baseUrl}`
+    );
+  }
+  return baseUrl.replace(/\/+$/, "");
+}
+function createRequestId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function extractErrorMessage(error, fallback) {
+  if (!error) return fallback || "요청에 실패했습니다.";
+  if (typeof error === "string") return error;
+  return error.message || error.code || fallback || "요청에 실패했습니다.";
+}
+class HeadlessTransport {
+  constructor(options) {
+    this.options = options;
+  }
+  async request(endpoint, options = {}) {
+    const response = await this.requestResponse(endpoint, options);
+    return response.data;
+  }
+  async requestResponse(endpoint, options = {}) {
+    if (!endpoint.startsWith("/") || endpoint.startsWith("//")) {
+      throw new IssueStickerHeadlessError(
+        "NETWORK_ERROR",
+        `API endpoint는 상대 경로여야 합니다: ${endpoint}`
+      );
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "x-client-info": "issue-sticker-sdk"
+    };
+    if (!options.skipAuth) {
+      const authHeader = await this.options.resolveAuthorizationHeader();
+      if (authHeader) headers.Authorization = authHeader;
+    }
+    const execute = (nextHeaders) => fetch(`${getApiBaseUrl()}${endpoint}`, {
+      method: options.method ?? "GET",
+      headers: nextHeaders,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    let response = await execute(headers);
+    if (!options.skipAuth && response.status === 401 && this.options.getAuthMode() === "member") {
+      const retryHeaders = { ...headers };
+      const authHeader = await this.options.resolveAuthorizationHeader(true).catch(() => null);
+      if (authHeader) {
+        retryHeaders.Authorization = authHeader;
+        response = await execute(retryHeaders);
+      }
+    }
+    if (response.status === 204) {
+      return { success: true };
+    }
+    const json = await response.json().catch(() => null);
+    if (!response.ok || !(json == null ? void 0 : json.success)) {
+      throw new IssueStickerHeadlessError(
+        response.status === 401 ? "MEMBER_AUTH_REQUIRED" : "NETWORK_ERROR",
+        extractErrorMessage(json == null ? void 0 : json.error, (json == null ? void 0 : json.message) || `요청 실패: ${response.status}`),
+        json
+      );
+    }
+    return json;
+  }
+  async uploadScreenshotPreviews(previews) {
+    const uploads = await uploadScreenshotDataUrls(
+      [...previews],
+      (file, mediaType) => this.uploadSignedMedia(file, mediaType)
+    );
+    return uploads.filter((upload) => Boolean(upload));
+  }
+  async uploadSignedMedia(file, mediaType) {
+    try {
+      return await uploadSignedMediaWithApi(
+        {
+          post: (endpoint, body) => this.request(endpoint, {
+            method: "POST",
+            body
+          }),
+          directUpload: directUploadWithFallback
+        },
+        file,
+        mediaType
+      );
+    } catch (error) {
+      if (error instanceof IssueStickerHeadlessError) {
+        throw error;
+      }
+      throw new IssueStickerHeadlessError(
+        "CAPTURE_FAILED",
+        error instanceof Error ? error.message : "미디어 업로드에 실패했습니다.",
+        error
+      );
+    }
+  }
+}
+const BRIDGE_READY = "ISSUE_STICKER_SDK_AUTH_BRIDGE_READY";
+const BRIDGE_REQUEST = "ISSUE_STICKER_SDK_AUTH_REQUEST";
+const BRIDGE_RESPONSE = "ISSUE_STICKER_SDK_AUTH_RESPONSE";
+const BRIDGE_LOGIN_SUCCESS = "ISSUE_STICKER_SDK_AUTH_LOGIN_SUCCESS";
+const BRIDGE_LOGIN_ERROR = "ISSUE_STICKER_SDK_AUTH_LOGIN_ERROR";
+const TOKEN_REFRESH_MARGIN_MS = 6e4;
+const BRIDGE_TIMEOUT_MS = 15e3;
+function buildBridgeUrl(bridgeUrl, params) {
+  const url = new URL(bridgeUrl);
+  url.searchParams.set("apiKey", params.apiKey);
+  if (params.tenantId) url.searchParams.set("tenantId", params.tenantId);
+  if (params.projectId) url.searchParams.set("projectId", params.projectId);
+  if (typeof window !== "undefined") {
+    url.searchParams.set("parentOrigin", window.location.origin);
+    url.searchParams.set("hostOrigin", window.location.origin);
+  }
+  if (params.interactive) {
+    url.searchParams.set("interactive", "1");
+  }
+  return url.toString();
+}
+class HeadlessAuthBridge {
+  constructor(options) {
+    this.options = options;
+    this.bridgeReady = false;
+    this.bridgeOrigin = null;
+    this.hiddenBridgeFrame = null;
+    this.loginBridgeFrame = null;
+    this.bridgeWaiters = [];
+    this.pendingBridgeRequests = /* @__PURE__ */ new Map();
+    this.memberToken = null;
+    this.memberTokenPromise = null;
+    this.authBridgeUrl = null;
+    this.handleBridgeMessage = this.handleBridgeMessage.bind(this);
+  }
+  get canUseBridge() {
+    return Boolean(this.authBridgeUrl);
+  }
+  setAuthBridgeUrl(authBridgeUrl) {
+    if (this.authBridgeUrl === authBridgeUrl) return;
+    this.authBridgeUrl = authBridgeUrl;
+    this.bridgeOrigin = authBridgeUrl ? new URL(authBridgeUrl).origin : null;
+    this.bridgeReady = false;
+  }
+  clearMemberToken() {
+    this.memberToken = null;
+  }
+  mountHiddenBridgeFrame() {
+    if (!this.authBridgeUrl || this.hiddenBridgeFrame || typeof document === "undefined" || typeof window === "undefined") {
+      return;
+    }
+    window.addEventListener("message", this.handleBridgeMessage);
+    const frame = document.createElement("iframe");
+    frame.title = "IssueSticker auth bridge";
+    frame.src = buildBridgeUrl(this.authBridgeUrl, {
+      apiKey: this.options.apiKey,
+      tenantId: this.options.getTenantId(),
+      projectId: this.options.getProjectId()
+    });
+    frame.style.display = "none";
+    frame.setAttribute("aria-hidden", "true");
+    frame.dataset.issueStickerHeadlessAuth = "true";
+    document.body.appendChild(frame);
+    this.hiddenBridgeFrame = frame;
+  }
+  postLogout() {
+    this.postBridgeMessage({
+      type: BRIDGE_REQUEST,
+      requestId: createRequestId(),
+      command: "logout"
+    });
+  }
+  destroy() {
+    var _a, _b;
+    this.clearMemberToken();
+    this.memberTokenPromise = null;
+    this.bridgeReady = false;
+    this.bridgeWaiters = [];
+    (_a = this.hiddenBridgeFrame) == null ? void 0 : _a.remove();
+    (_b = this.loginBridgeFrame) == null ? void 0 : _b.remove();
+    this.hiddenBridgeFrame = null;
+    this.loginBridgeFrame = null;
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.handleBridgeMessage);
+    }
+    this.pendingBridgeRequests.forEach((request) => {
+      if (typeof window !== "undefined") {
+        window.clearTimeout(request.timeoutId);
+      }
+      request.reject(new Error("Headless auth bridge destroyed"));
+    });
+    this.pendingBridgeRequests.clear();
+  }
+  async getValidMemberToken(options = {}) {
+    const cached = this.memberToken;
+    if (!options.forceRefresh && cached && cached.expiresAtMs - Date.now() > TOKEN_REFRESH_MARGIN_MS) {
+      return cached.accessToken;
+    }
+    if (!this.memberTokenPromise) {
+      this.memberTokenPromise = this.requestBridgeMemberToken(Boolean(options.forceRefresh)).then((result) => {
+        this.applyToken(result);
+        return result.accessToken;
+      }).catch(() => null).finally(() => {
+        this.memberTokenPromise = null;
+      });
+    }
+    return this.memberTokenPromise;
+  }
+  async openInteractiveLoginFrame() {
+    if (!this.authBridgeUrl) {
+      throw new IssueStickerHeadlessError(
+        "MEMBER_AUTH_REQUIRED",
+        "SDK auth bridge를 사용할 수 없습니다."
+      );
+    }
+    if (typeof document === "undefined" || typeof window === "undefined") {
+      throw new IssueStickerHeadlessError(
+        "MEMBER_AUTH_REQUIRED",
+        "브라우저 DOM에서만 멤버 로그인을 시작할 수 있습니다."
+      );
+    }
+    await new Promise((resolve, reject) => {
+      const wrapper = document.createElement("div");
+      wrapper.dataset.issueStickerHeadlessAuth = "true";
+      wrapper.style.position = "fixed";
+      wrapper.style.inset = "0";
+      wrapper.style.zIndex = "2147483647";
+      wrapper.style.background = "rgba(15, 23, 42, 0.42)";
+      wrapper.style.display = "grid";
+      wrapper.style.placeItems = "center";
+      const frame = document.createElement("iframe");
+      frame.title = "IssueSticker member login";
+      frame.src = buildBridgeUrl(this.authBridgeUrl, {
+        apiKey: this.options.apiKey,
+        tenantId: this.options.getTenantId(),
+        projectId: this.options.getProjectId(),
+        interactive: true
+      });
+      frame.style.width = "min(420px, calc(100vw - 32px))";
+      frame.style.height = "min(640px, calc(100vh - 32px))";
+      frame.style.border = "0";
+      frame.style.borderRadius = "12px";
+      frame.style.boxShadow = "0 24px 80px rgba(15, 23, 42, 0.32)";
+      wrapper.appendChild(frame);
+      document.body.appendChild(wrapper);
+      this.loginBridgeFrame = frame;
+      const cleanup = () => {
+        window.removeEventListener("message", onMessage);
+        wrapper.remove();
+        if (this.loginBridgeFrame === frame) this.loginBridgeFrame = null;
+      };
+      const onMessage = (event) => {
+        var _a, _b;
+        if (!this.bridgeOrigin || event.origin !== this.bridgeOrigin) return;
+        const message = event.data;
+        if (message.type === BRIDGE_LOGIN_SUCCESS && message.data) {
+          this.applyToken(message.data);
+          cleanup();
+          resolve();
+        }
+        if (message.type === BRIDGE_LOGIN_ERROR) {
+          cleanup();
+          reject(
+            new IssueStickerHeadlessError(
+              "MEMBER_AUTH_REQUIRED",
+              ((_a = message.error) == null ? void 0 : _a.message) || ((_b = message.error) == null ? void 0 : _b.code) || "멤버 로그인에 실패했습니다.",
+              message.error
+            )
+          );
+        }
+      };
+      window.addEventListener("message", onMessage);
+    });
+  }
+  requestBridgeMemberToken(forceRefresh = false) {
+    if (!this.authBridgeUrl || !this.bridgeOrigin) {
+      throw new IssueStickerHeadlessError(
+        "MEMBER_AUTH_REQUIRED",
+        "SDK auth bridge URL이 초기화되지 않았습니다."
+      );
+    }
+    if (typeof window === "undefined") {
+      throw new IssueStickerHeadlessError(
+        "MEMBER_AUTH_REQUIRED",
+        "브라우저 DOM에서만 멤버 토큰을 요청할 수 있습니다."
+      );
+    }
+    return this.waitForBridgeReady().then(
+      () => new Promise((resolve, reject) => {
+        const requestId = createRequestId();
+        const timeoutId = window.setTimeout(() => {
+          this.pendingBridgeRequests.delete(requestId);
+          reject(
+            new IssueStickerHeadlessError(
+              "MEMBER_AUTH_REQUIRED",
+              "SDK auth bridge 응답 시간이 초과되었습니다."
+            )
+          );
+        }, BRIDGE_TIMEOUT_MS);
+        this.pendingBridgeRequests.set(requestId, {
+          resolve: (result) => {
+            if (!(result == null ? void 0 : result.accessToken)) {
+              reject(
+                new IssueStickerHeadlessError(
+                  "MEMBER_AUTH_REQUIRED",
+                  "SDK member token을 발급받지 못했습니다."
+                )
+              );
+              return;
+            }
+            resolve(result);
+          },
+          reject,
+          timeoutId
+        });
+        this.postBridgeMessage({
+          type: BRIDGE_REQUEST,
+          requestId,
+          command: "get-member-token",
+          apiKey: this.options.apiKey,
+          tenantId: this.options.getTenantId(),
+          projectId: this.options.getProjectId(),
+          hostOrigin: typeof window !== "undefined" ? window.location.origin : void 0,
+          forceRefresh
+        });
+      })
+    );
+  }
+  waitForBridgeReady() {
+    if (this.bridgeReady) return Promise.resolve();
+    if (typeof window === "undefined") {
+      return Promise.reject(
+        new IssueStickerHeadlessError(
+          "MEMBER_AUTH_REQUIRED",
+          "브라우저 DOM에서만 SDK auth bridge를 사용할 수 있습니다."
+        )
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = window.setTimeout(() => {
+        this.bridgeWaiters = this.bridgeWaiters.filter((waiter) => waiter !== done);
+        reject(
+          new IssueStickerHeadlessError(
+            "MEMBER_AUTH_REQUIRED",
+            "SDK auth bridge 준비 시간이 초과되었습니다."
+          )
+        );
+      }, BRIDGE_TIMEOUT_MS);
+      const done = () => {
+        window.clearTimeout(timeoutId);
+        resolve();
+      };
+      this.bridgeWaiters.push(done);
+    });
+  }
+  handleBridgeMessage(event) {
+    var _a, _b, _c;
+    if (!this.bridgeOrigin || event.origin !== this.bridgeOrigin) return;
+    const message = event.data;
+    if (message.type === BRIDGE_READY && event.source === ((_a = this.hiddenBridgeFrame) == null ? void 0 : _a.contentWindow)) {
+      this.bridgeReady = true;
+      const waiters = this.bridgeWaiters;
+      this.bridgeWaiters = [];
+      waiters.forEach((waiter) => waiter());
+      return;
+    }
+    if (message.type === BRIDGE_RESPONSE && message.requestId) {
+      const pending = this.pendingBridgeRequests.get(message.requestId);
+      if (!pending) return;
+      window.clearTimeout(pending.timeoutId);
+      this.pendingBridgeRequests.delete(message.requestId);
+      if (message.success && message.data) {
+        pending.resolve(message.data);
+      } else {
+        pending.reject(
+          new IssueStickerHeadlessError(
+            "MEMBER_AUTH_REQUIRED",
+            ((_b = message.error) == null ? void 0 : _b.message) || ((_c = message.error) == null ? void 0 : _c.code) || "멤버 인증이 필요합니다.",
+            message.error
+          )
+        );
+      }
+    }
+  }
+  postBridgeMessage(message) {
+    var _a;
+    if (!this.bridgeOrigin || !((_a = this.hiddenBridgeFrame) == null ? void 0 : _a.contentWindow)) return;
+    this.hiddenBridgeFrame.contentWindow.postMessage(message, this.bridgeOrigin);
+  }
+  applyToken(result) {
+    const expiresAtMs = new Date(result.expiresAt).getTime();
+    this.memberToken = {
+      accessToken: result.accessToken,
+      expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : Date.now() + Math.max(result.expiresIn - 60, 60) * 1e3
+    };
+    this.options.onToken(result);
+  }
+}
+const JIRA_FILTERABLE_FIELD_IDS = /* @__PURE__ */ new Set([
+  "status",
+  "priority",
+  "assignee",
+  "reporter",
+  "fixVersions",
+  "issuetype",
+  "project_key",
+  "sprint_id",
+  "sprint_name",
+  "epic_link",
+  "story_points"
+]);
+const NOTION_FILTERABLE_FIELD_TYPES = /* @__PURE__ */ new Set(["select", "multi_select", "status", "checkbox"]);
+function getJiraConfig(integration) {
+  if (integration.service_type !== "JIRA") return null;
+  return integration.config ?? null;
+}
+function getNotionConfig(integration) {
+  if (integration.service_type !== "NOTION") return null;
+  return integration.config ?? null;
+}
+function getExposedFields(config) {
+  if (!(config == null ? void 0 : config.exposed_fields)) return [];
+  return normalizeExposedJiraFields(
+    Array.isArray(config.exposed_fields) ? config.exposed_fields : void 0
+  );
+}
+function getLastKnownJiraFields(config) {
+  const fields = config == null ? void 0 : config.last_known_fields;
+  if (!Array.isArray(fields)) return [];
+  return fields.filter(
+    (field) => Boolean(field) && typeof field === "object" && typeof field.id === "string" && typeof field.name === "string"
+  );
+}
+function getSelectedNotionFields(config) {
+  const fields = config == null ? void 0 : config.selected_fields;
+  if (!Array.isArray(fields)) return [];
+  return fields.filter((field) => typeof field === "string");
+}
+function getLastKnownNotionFields(config) {
+  const fields = config == null ? void 0 : config.last_known_fields;
+  if (!Array.isArray(fields)) return [];
+  return fields.filter(
+    (field) => Boolean(field) && typeof field === "object" && typeof field.id === "string" && typeof field.name === "string" && typeof field.type === "string"
+  );
+}
+const OPTION_CUSTOM_FIELD_TYPES = /* @__PURE__ */ new Set(["select", "multi_select"]);
+function getSelectableCustomFieldOptions(field) {
+  var _a;
+  if (!OPTION_CUSTOM_FIELD_TYPES.has(field.field_type)) return [];
+  const rawOptions = (_a = field.field_config) == null ? void 0 : _a.options;
+  if (!Array.isArray(rawOptions)) return [];
+  return rawOptions.filter((option) => typeof option === "string" && option.trim().length > 0).map((option) => ({ label: option, value: option }));
+}
+function getJiraOptionValue(option) {
+  return option.id;
+}
+function getJiraFieldFilterOptions(field) {
+  const options = field.options ?? [];
+  if (!options.length) return [];
+  return options.map((option) => ({
+    label: option.name || option.value || option.id,
+    value: getJiraOptionValue(option)
+  })).filter((option) => option.value.length > 0);
+}
+function getNotionFieldFilterOptions(field) {
+  if (field.type === "checkbox") {
+    return [
+      { label: "체크됨", value: "true" },
+      { label: "체크 안 됨", value: "false" }
+    ];
+  }
+  const options = field.options ?? [];
+  if (!options.length) return [];
+  return options.map((option) => ({
+    label: option.name,
+    value: option.name
+  })).filter((option) => option.value.length > 0);
+}
+function mergeOptions(current, next) {
+  const byValue = new Map(current.map((option) => [option.value, option]));
+  for (const option of next) {
+    if (!byValue.has(option.value)) {
+      byValue.set(option.value, option);
+    }
+  }
+  return Array.from(byValue.values()).sort((a, b) => a.label.localeCompare(b.label));
+}
+function upsertFilterGroup(groups, group) {
+  const existing = groups.get(group.id);
+  if (!existing) {
+    groups.set(group.id, {
+      ...group,
+      options: mergeOptions([], group.options)
+    });
+    return;
+  }
+  groups.set(group.id, {
+    ...existing,
+    options: mergeOptions(existing.options, group.options)
+  });
+}
+function appendCustomFieldFilterGroups(groups, exposedFieldIds, customFields) {
+  for (const field of customFields) {
+    if (!exposedFieldIds.has(normalizeJiraFieldId(field.field_key))) continue;
+    const options = getSelectableCustomFieldOptions(field);
+    if (!options.length) continue;
+    upsertFilterGroup(groups, {
+      kind: "custom",
+      id: `custom:${field.id}`,
+      fieldDefinitionId: field.id,
+      label: field.field_name,
+      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;
+    }
+    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;
+  });
+  const jiraConfig = jiraIntegration ? getJiraConfig(jiraIntegration) : null;
+  const configExposedFields = getExposedFields(jiraConfig);
+  if (configExposedFields.length) {
+    const exposedFieldIds = new Set(configExposedFields);
+    appendCustomFieldFilterGroups(groups, exposedFieldIds, customFields);
+    appendJiraFieldFilterGroups(groups, exposedFieldIds, 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((a, b) => a.label.localeCompare(b.label));
+}
+function buildHeadlessCaptureContext({
+  target,
+  event,
+  videoFile,
+  createVideoPreviewUrl,
+  sessionReplayEnabled
+}) {
+  const mediaMode = videoFile ? "video" : "screenshot";
+  const position = getElementPosition(target, event);
+  return {
+    mediaMode,
+    position,
+    screenshotPreviewUrls: [],
+    videoPreviewUrl: mediaMode === "video" && videoFile ? createVideoPreviewUrl(videoFile) : null,
+    targetSelector: position.selector,
+    sessionReplayEnabled,
+    sessionReplayPreview: null
+  };
+}
+async function captureHeadlessScreenshots({
+  target,
+  excludeSelectors
+}) {
+  const screenshots = await Promise.all([
+    captureWithModernScreenshot({
+      element: document.documentElement,
+      excludeSelectors,
+      width: window.innerWidth,
+      height: window.innerHeight
+    }).catch(() => void 0),
+    captureWithModernScreenshot({
+      element: target,
+      excludeSelectors
+    }).catch(() => void 0)
+  ]);
+  return screenshots.filter(
+    (dataUrl) => typeof dataUrl === "string" && dataUrl.length > 0
+  );
+}
+function normalizeCustomInputType(fieldType) {
+  if (fieldType === "number") return "number";
+  if (fieldType === "select") return "select";
+  if (fieldType === "multi_select") return "multi_select";
+  if (fieldType === "date") return "date";
+  if (fieldType === "checkbox" || fieldType === "boolean") return "checkbox";
+  return "text";
+}
+function buildCustomFieldOptions(field) {
+  var _a;
+  const rawOptions = (_a = field.field_config) == null ? void 0 : _a.options;
+  if (!Array.isArray(rawOptions)) return [];
+  return rawOptions.map((option) => {
+    if (typeof option === "string") {
+      const value = option.trim();
+      return value ? { label: value, value } : null;
+    }
+    if (option && typeof option === "object") {
+      const candidate = option;
+      const converted = toOption(candidate);
+      return converted.value ? converted : null;
+    }
+    return null;
+  }).filter((option) => Boolean(option));
+}
+function buildCustomFieldDescriptors(fields) {
+  return fields.map((field) => ({
+    id: field.id,
+    source: "custom",
+    label: field.field_name || field.field_key || field.id,
+    inputType: normalizeCustomInputType(field.field_type),
+    options: buildCustomFieldOptions(field)
+  }));
+}
+function normalizeJiraInputType(inputType) {
+  if (inputType === "user" || inputType === "issue") return inputType;
+  if (inputType === "number") return "number";
+  if (inputType === "select") return "select";
+  if (inputType === "readonly") return "readonly";
+  return "text";
+}
+function normalizeNotionInputType(inputType) {
+  if (inputType === "number" || inputType === "select" || inputType === "multi_select" || inputType === "date" || inputType === "checkbox" || inputType === "people" || inputType === "readonly") {
+    return inputType;
+  }
+  return "text";
+}
+function toOption(option) {
+  const value = option.value || option.id || option.name || option.label || "";
+  return {
+    value,
+    label: option.label || option.name || option.value || option.id || value,
+    description: option.description
+  };
+}
+function getFilledDynamicValues(draft, fields, source) {
+  return Object.fromEntries(
+    fields.filter((field) => field.source === source).map((field) => [field.id, draft.dynamicFields[field.id]]).filter(([, value]) => value !== void 0 && value !== null && value !== "")
+  );
+}
+function getJiraUserLabel(user) {
+  return user.displayName || user.emailAddress || user.accountId;
+}
+function getJiraIssueLabel(issue) {
+  return issue.summary ? `${issue.key} ${issue.summary}` : issue.key;
+}
+async function buildIssueFormSchema(values, deps) {
+  var _a, _b;
+  if (deps.authMode !== "member") {
+    return { fields: [], unavailableReason: "public-mode" };
+  }
+  const [active, customFields] = await Promise.all([
+    deps.getActiveIntegration(),
+    deps.getCustomFieldDefinitions()
+  ]);
+  const dynamicFields = [];
+  if ((active == null ? void 0 : active.service_type) === "JIRA") {
+    const response = await deps.requestResponse(
+      `/api/jira/integration-fields/${encodeURIComponent(active.id)}`
+    );
+    const exposedFields = Array.isArray((_a = response.data) == null ? void 0 : _a.exposed_fields) ? response.data.exposed_fields : active.config.exposed_fields;
+    const fields = buildJiraCreateFields(exposedFields, ((_b = response.data) == null ? void 0 : _b.fields) ?? [], values);
+    dynamicFields.push(
+      ...fields.map((field) => ({
+        id: field.id,
+        source: "jira",
+        label: field.label,
+        inputType: normalizeJiraInputType(field.inputType),
+        options: field.options.map(toOption),
+        ...field.inputType === "user" ? {
+          search: (query) => deps.searchJiraProjectUsers(query).then((items) => items.map(toOption)),
+          resolveValueLabel: (value) => deps.resolveJiraProjectUserLabel(value)
+        } : {},
+        ...field.inputType === "issue" ? {
+          search: (query) => deps.searchJiraProjectIssues(query).then((items) => items.map(toOption)),
+          resolveValueLabel: (value) => deps.resolveJiraProjectIssueLabel(value)
+        } : {}
+      }))
+    );
+  } else if ((active == null ? void 0 : active.service_type) === "NOTION") {
+    const selectedFields = Array.isArray(active.config.selected_fields) ? active.config.selected_fields : [];
+    const fieldDefinitions = Array.isArray(active.config.last_known_fields) ? active.config.last_known_fields : [];
+    const fields = buildNotionCreateFields(selectedFields, fieldDefinitions, values);
+    dynamicFields.push(
+      ...fields.map((field) => ({
+        id: field.id,
+        source: "notion",
+        label: field.name,
+        inputType: normalizeNotionInputType(field.inputType),
+        options: field.options.map(toOption),
+        ...field.inputType === "people" ? {
+          search: (query) => deps.searchNotionPeople(query).then(
+            (items) => items.map((item) => ({
+              label: item.name,
+              value: item.id,
+              description: item.email
+            }))
+          )
+        } : {}
+      }))
+    );
+  }
+  dynamicFields.push(...buildCustomFieldDescriptors(customFields));
+  if (dynamicFields.length === 0) {
+    return { fields: [], unavailableReason: "not-configured" };
+  }
+  return { fields: dynamicFields };
+}
+function recordToFilterArray(record, keyFieldName) {
+  if (!record) return null;
+  const entries = Object.entries(record).filter(([, values]) => values.length > 0);
+  if (entries.length === 0) return null;
+  return entries.map(
+    ([key, values]) => ({ [keyFieldName]: key, values })
+  );
+}
+function hasIssueListFilters(filters) {
+  var _a;
+  return Boolean(
+    ((_a = filters.search) == null ? void 0 : _a.trim()) || filters.dateFrom || filters.dateTo || filters.page || hasRecordFilters(filters.customFieldValues) || hasRecordFilters(filters.jiraFieldValues) || hasRecordFilters(filters.notionFieldValues)
+  );
+}
+function hasRecordFilters(record) {
+  return Boolean(record && Object.values(record).some((values) => values.length > 0));
+}
+function buildIssueQueryParams(filters, context) {
+  var _a;
+  const params = new URLSearchParams();
+  params.set("project_id", context.projectId);
+  if (filters.url && filters.url !== "all") {
+    params.set("url", Array.isArray(filters.url) ? filters.url.join(",") : filters.url);
+  } else if (!filters.url && context.currentUrl) {
+    params.set("url", context.currentUrl);
+  }
+  if ((_a = filters.search) == null ? void 0 : _a.trim()) params.set("search", filters.search.trim());
+  if (filters.dateFrom) params.set("date_from", filters.dateFrom);
+  if (filters.dateTo) params.set("date_to", filters.dateTo);
+  if (filters.page) params.set("page", String(filters.page));
+  if (filters.pageSize) params.set("page_size", String(filters.pageSize));
+  if (filters.sortOrder) params.set("sort_order", filters.sortOrder);
+  const externalUserId = context.authMode === "public" ? filters.externalUserId || context.defaultExternalUserId : filters.externalUserId;
+  if (externalUserId) params.set("external_user_id", externalUserId);
+  const custom = recordToFilterArray(filters.customFieldValues, "fieldDefinitionId");
+  const jira = recordToFilterArray(filters.jiraFieldValues, "fieldName");
+  const notion = recordToFilterArray(filters.notionFieldValues, "fieldName");
+  if (custom) params.set("custom_field_filters", JSON.stringify(custom));
+  if (jira) params.set("jira_field_filters", JSON.stringify(jira));
+  if (notion) params.set("notion_field_filters", JSON.stringify(notion));
+  return params;
+}
+const STICKER_PAGE_SIZE = 500;
+const STICKER_FETCH_LIMIT = 2e3;
+class HeadlessIssueRepository {
+  constructor(options) {
+    this.options = options;
+  }
+  request(endpoint, options = {}) {
+    return this.options.transport.request(endpoint, options);
+  }
+  requestResponse(endpoint, options = {}) {
+    return this.options.transport.requestResponse(endpoint, options);
+  }
+  openIssue(issueId) {
+    return this.request(
+      `/api/sdk/issues/${encodeURIComponent(issueId)}`
+    );
+  }
+  createIssue(issueData) {
+    return this.request("/api/sdk/issues", {
+      method: "POST",
+      body: issueData
+    });
+  }
+  async loadFilterSchema() {
+    if (this.options.getAuthMode() !== "member") {
+      return { groups: [], unavailableReason: "public-mode" };
+    }
+    const [integrations, customFields] = await Promise.all([
+      this.getProjectIntegrations(),
+      this.getCustomFieldDefinitions()
+    ]);
+    const groups = composeIssueFilterGroups(integrations, customFields);
+    return { groups };
+  }
+  async getActiveIntegration() {
+    const integrations = await this.getProjectIntegrations();
+    return integrations.find((integration) => integration.service_type === "JIRA") ?? integrations.find((integration) => integration.service_type === "NOTION") ?? null;
+  }
+  async getProjectIntegrations() {
+    const integrations = await this.request(
+      `/api/integrations/${this.options.getProjectId()}`
+    );
+    return Array.isArray(integrations) ? integrations.filter((integration) => integration.is_active !== false) : [];
+  }
+  async getCustomFieldDefinitions() {
+    const fields = await this.request(
+      `/api/integrations/fields/definitions?projectId=${encodeURIComponent(this.options.getProjectId())}`
+    );
+    return Array.isArray(fields) ? fields : [];
+  }
+  /**
+   * 이슈 저장 이후의 외부 연동(Jira/Notion/커스텀 필드)을 이어서 실행한다.
+   *
+   * 실패는 이슈 저장을 되돌리지 않으므로 throw 하지 않고 결과로 돌려준다. headless 는
+   * UI 가 없어 toast 를 띄울 수 없으니, 통합하는 쪽이 이 값을 보고 판단해야 한다.
+   */
+  async syncDynamicFields(createdIssue, draft, schema, context) {
+    if (this.options.getAuthMode() !== "member") {
+      return { failedServices: [] };
+    }
+    const active = await this.getActiveIntegration().catch(() => null);
+    const fields = (schema == null ? void 0 : schema.fields) ?? [];
+    const jiraValues = getFilledDynamicValues(draft, fields, "jira");
+    const notionValues = getFilledDynamicValues(draft, fields, "notion");
+    const customValues = getFilledDynamicValues(draft, fields, "custom");
+    return syncExternalIssueIntegrations({
+      issueId: createdIssue.id,
+      title: draft.title.trim(),
+      description: draft.description.trim(),
+      url: this.options.getCurrentUrl() ?? "",
+      screenshotUrl: context.screenshotUrl,
+      videoUrl: context.videoUrl,
+      jira: {
+        enabled: (active == null ? void 0 : active.service_type) === "JIRA",
+        fields: jiraValues,
+        createIssue: (input) => this.request("/api/jira/issues", {
+          method: "POST",
+          body: {
+            projectId: this.options.getProjectId(),
+            issueId: input.issueId,
+            issueData: {
+              title: input.title,
+              description: input.description,
+              url: input.url,
+              screenshotUrl: input.screenshotUrl,
+              videoUrl: input.videoUrl,
+              fields: input.fields
+            }
+          }
+        })
+      },
+      notion: {
+        enabled: (active == null ? void 0 : active.service_type) === "NOTION",
+        properties: notionValues,
+        createPage: (input) => this.request("/api/notion/pages", {
+          method: "POST",
+          body: {
+            projectId: this.options.getProjectId(),
+            issueId: input.issueId,
+            properties: input.properties
+          }
+        })
+      },
+      customFieldValues: customValues,
+      upsertCustomFieldValue: (fieldDefinitionId, value) => this.request(
+        `/api/custom-field-values/issues/${encodeURIComponent(createdIssue.id)}/values`,
+        {
+          method: "PUT",
+          body: {
+            field_definition_id: fieldDefinitionId,
+            value
+          }
+        }
+      ),
+      onError: (service, error) => {
+        devLogger.error("headless", `${service} 연동 실패 (이슈 저장은 성공):`, error);
+      }
+    });
+  }
+  async fetchAllIssueStickers(filters) {
+    var _a, _b, _c;
+    const projectId = this.options.getProjectId();
+    const externalUserId = this.options.getAuthMode() === "public" ? filters.externalUserId || this.options.getDefaultExternalUserId() : void 0;
+    if (this.options.getAuthMode() === "public" && !externalUserId) {
+      return [];
+    }
+    if (hasIssueListFilters(filters)) {
+      const params = buildIssueQueryParams(filters, {
+        projectId,
+        authMode: this.options.getAuthMode(),
+        defaultExternalUserId: this.options.getDefaultExternalUserId(),
+        currentUrl: this.options.getCurrentUrl()
+      });
+      const response = await this.requestResponse(
+        `/api/sdk/issues?${params.toString()}`
+      );
+      return ((_a = response.data) == null ? void 0 : _a.items) ?? [];
+    }
+    const issues = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore && issues.length <= STICKER_FETCH_LIMIT) {
+      const params = new URLSearchParams();
+      params.set("project_id", projectId);
+      params.set("page", String(page));
+      params.set("page_size", String(filters.pageSize ?? STICKER_PAGE_SIZE));
+      if (filters.url && filters.url !== "all") {
+        params.set("url", Array.isArray(filters.url) ? filters.url.join(",") : filters.url);
+      } else if (!filters.url && this.options.getCurrentUrl()) {
+        params.set("url", this.options.getCurrentUrl());
+      }
+      if (externalUserId) params.set("external_user_id", externalUserId);
+      if (filters.sortOrder) params.set("sort_order", filters.sortOrder);
+      const response = await this.requestResponse(`/api/sdk/issues/stickers?${params.toString()}`);
+      const pageItems = ((_b = response.data) == null ? void 0 : _b.items) ?? [];
+      issues.push(...pageItems);
+      hasMore = Boolean((_c = response.data) == null ? void 0 : _c.hasMore) && pageItems.length > 0;
+      page += 1;
+    }
+    return issues;
+  }
+  searchJiraProjectUsers(query) {
+    return this.request(
+      `/api/jira/projects/${encodeURIComponent(this.options.getProjectId())}/users/search?query=${encodeURIComponent(query)}`
+    ).then(
+      (users) => users.map((user) => ({
+        value: user.accountId,
+        label: getJiraUserLabel(user),
+        description: user.emailAddress
+      }))
+    );
+  }
+  resolveJiraProjectUserLabel(accountId) {
+    return this.request(
+      `/api/jira/projects/${encodeURIComponent(this.options.getProjectId())}/users/${encodeURIComponent(accountId)}`
+    ).then(getJiraUserLabel).catch(() => null);
+  }
+  searchJiraProjectIssues(query) {
+    return this.request(
+      `/api/jira/projects/${encodeURIComponent(this.options.getProjectId())}/issues?query=${encodeURIComponent(query)}`
+    ).then(
+      (issues) => issues.map((issue) => ({
+        value: issue.key,
+        label: getJiraIssueLabel(issue),
+        description: issue.status
+      }))
+    );
+  }
+  async resolveJiraProjectIssueLabel(issueKey) {
+    var _a, _b;
+    const issues = await this.searchJiraProjectIssues(issueKey).catch(() => []);
+    return ((_a = issues.find((issue) => issue.value === issueKey)) == null ? void 0 : _a.label) ?? ((_b = issues[0]) == null ? void 0 : _b.label) ?? null;
+  }
+  searchNotionPeople(query) {
+    return this.request(
+      `/api/notion/users?projectId=${encodeURIComponent(this.options.getProjectId())}&query=${encodeURIComponent(query)}`
+    );
+  }
+}
+const defaultDeps = {
+  createNetworkCollector: (apiBaseUrl) => new NetworkCollector(apiBaseUrl),
+  createConsoleCollector: () => new ConsoleCollector()
+};
+class HeadlessLogCollectors {
+  constructor(config, getApiBaseUrl2, deps = defaultDeps) {
+    this.config = config;
+    this.getApiBaseUrl = getApiBaseUrl2;
+    this.deps = deps;
+    this.networkCollector = null;
+    this.consoleCollector = null;
+  }
+  start() {
+    var _a, _b;
+    if (((_a = this.config.capture) == null ? void 0 : _a.networkLogs) !== false && !this.networkCollector) {
+      this.networkCollector = this.deps.createNetworkCollector(this.getApiBaseUrl());
+      this.networkCollector.start();
+    }
+    if (((_b = this.config.capture) == null ? void 0 : _b.consoleLogs) !== false && !this.consoleCollector) {
+      this.consoleCollector = this.deps.createConsoleCollector();
+      this.consoleCollector.start();
+    }
+  }
+  stop() {
+    var _a, _b;
+    (_a = this.networkCollector) == null ? void 0 : _a.stop();
+    (_b = this.consoleCollector) == null ? void 0 : _b.stop();
+    this.networkCollector = null;
+    this.consoleCollector = null;
+  }
+  collect() {
+    var _a, _b;
+    const networkLogs = filterExcludeServiceRelatedLogs(
+      ((_a = this.networkCollector) == null ? void 0 : _a.getFilteredLogs()) ?? []
+    ).slice(-50);
+    const consoleLogs = filterExcludeServiceRelatedConsoleLogs(
+      ((_b = this.consoleCollector) == null ? void 0 : _b.getFilteredLogs()) ?? []
+    ).slice(-50);
+    return {
+      networkLogs: compactNetworkLogsForTransport(networkLogs) ?? [],
+      consoleLogs
+    };
+  }
+}
+class HeadlessPendingMedia {
+  constructor() {
+    this.file = null;
+    this.objectUrl = null;
+  }
+  get videoFile() {
+    return this.file;
+  }
+  get previewUrl() {
+    return this.objectUrl;
+  }
+  get hasVideo() {
+    return Boolean(this.file);
+  }
+  setVideoFile(file) {
+    this.file = file;
+  }
+  createVideoPreviewUrl(file) {
+    if (this.objectUrl) {
+      URL.revokeObjectURL(this.objectUrl);
+    }
+    this.file = file;
+    this.objectUrl = URL.createObjectURL(file);
+    return this.objectUrl;
+  }
+  clear() {
+    if (this.objectUrl) {
+      URL.revokeObjectURL(this.objectUrl);
+      this.objectUrl = null;
+    }
+    this.file = null;
+  }
+}
+function createReplayFile(snapshot) {
+  return new File([snapshot.payload], "session-replay.gz", {
+    type: "application/gzip"
+  });
+}
+function createSessionReplayMeta(snapshot) {
+  return {
+    window_seconds: snapshot.windowSeconds,
+    event_count: snapshot.eventCount,
+    size_bytes: snapshot.sizeBytes,
+    rrweb_version: snapshot.rrwebVersion,
+    privacy_config_version: snapshot.privacyConfigVersion
+  };
+}
+function createInitialHeadlessSnapshot() {
+  return {
+    phase: "idle",
+    auth: {
+      mode: "public",
+      isReady: false,
+      canUseIntegrations: false,
+      tenantId: null,
+      projectId: null,
+      accountId: null
+    },
+    issues: [],
+    activeIssue: null,
+    draft: null,
+    videoCapture: {
+      isRecording: false,
+      hasRecordedVideo: false,
+      error: null
+    },
+    sessionReplay: {
+      available: false,
+      canAttach: false,
+      enabled: true,
+      error: null
+    },
+    formSchema: null,
+    filterSchema: null,
+    error: null
+  };
+}
+function assertScreenshotCaptureOptions(options) {
+  const legacyOptions = options;
+  if (!legacyOptions) return;
+  if (legacyOptions.mediaMode && legacyOptions.mediaMode !== "screenshot") {
+    throw new IssueStickerHeadlessError(
+      "VALIDATION_ERROR",
+      "영상 캡쳐는 startVideoCapture()와 stopVideoCapture()를 사용해야 합니다."
+    );
+  }
+  if ("videoFile" in legacyOptions) {
+    throw new IssueStickerHeadlessError(
+      "VALIDATION_ERROR",
+      "headless API는 videoFile을 직접 받지 않습니다. startVideoCapture()로 녹화하세요."
+    );
+  }
+  if ("sessionReplay" in legacyOptions) {
+    throw new IssueStickerHeadlessError(
+      "VALIDATION_ERROR",
+      "세션 리플레이 첨부 여부는 setSessionReplayEnabled()로 설정해야 합니다."
+    );
+  }
+}
+class HeadlessClientState {
+  constructor() {
+    this.snapshot = createInitialHeadlessSnapshot();
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  get phase() {
+    return this.snapshot.phase;
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.snapshot);
+    return () => this.listeners.delete(listener);
+  }
+  setSnapshot(patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      ...patch,
+      auth: patch.auth ? { ...this.snapshot.auth, ...patch.auth } : this.snapshot.auth
+    };
+    this.listeners.forEach((listener) => listener(this.snapshot));
+  }
+  reset() {
+    this.listeners.clear();
+    this.snapshot = createInitialHeadlessSnapshot();
+  }
+  applyBridgeToken(result) {
+    var _a, _b, _c;
+    this.setSnapshot({
+      auth: {
+        mode: "member",
+        isReady: true,
+        canUseIntegrations: true,
+        tenantId: ((_a = result.context) == null ? void 0 : _a.tenantId) || this.snapshot.auth.tenantId,
+        projectId: ((_b = result.context) == null ? void 0 : _b.projectId) || this.snapshot.auth.projectId,
+        accountId: ((_c = result.context) == null ? void 0 : _c.accountId) || this.snapshot.auth.accountId
+      }
+    });
+  }
+  setAuthMode(mode) {
+    this.setSnapshot({
+      auth: {
+        ...this.snapshot.auth,
+        mode,
+        canUseIntegrations: mode === "member",
+        accountId: mode === "member" ? this.snapshot.auth.accountId : null
+      }
+    });
+  }
+  requireProjectId() {
+    const projectId = this.snapshot.auth.projectId;
+    if (!projectId) {
+      throw new IssueStickerHeadlessError(
+        "NOT_INITIALIZED",
+        "프로젝트 컨텍스트가 준비되지 않았습니다."
+      );
+    }
+    return projectId;
+  }
+  requireDraft() {
+    if (!this.snapshot.draft) {
+      throw new IssueStickerHeadlessError("INVALID_PHASE", "작성 중인 이슈가 없습니다.");
+    }
+    return this.snapshot.draft;
+  }
+  assertPhase(allowed, action) {
+    if (!allowed.includes(this.snapshot.phase)) {
+      throw new IssueStickerHeadlessError(
+        "INVALID_PHASE",
+        `${action}은 현재 phase(${this.snapshot.phase})에서 호출할 수 없습니다.`
+      );
+    }
+  }
+}
+function buildIssueCreatePayload({
+  draft,
+  auth,
+  config,
+  projectId,
+  uploads,
+  logs,
+  currentUrl,
+  userAgent
+}) {
+  var _a, _b;
+  return sanitizeString({
+    url: currentUrl,
+    title: draft.title.trim(),
+    description: draft.description.trim(),
+    position: draft.position,
+    ...uploads.screenshotUploadIds.length > 0 ? { screenshot_upload_ids: uploads.screenshotUploadIds } : {},
+    ...uploads.videoUpload ? { video_upload_id: uploads.videoUpload.id } : {},
+    ...uploads.replayUpload ? {
+      session_replay_upload_id: uploads.replayUpload.uploadId,
+      session_replay_meta: uploads.replayUpload.meta
+    } : {},
+    network_logs: logs.networkLogs.length > 0 ? logs.networkLogs : void 0,
+    console_logs: logs.consoleLogs.length > 0 ? logs.consoleLogs : void 0,
+    user_agent: userAgent,
+    tenant_id: auth.tenantId,
+    project_id: projectId,
+    account_id: auth.accountId ?? void 0,
+    external_user_id: ((_a = config.user) == null ? void 0 : _a.id) ?? null,
+    external_user_name: ((_b = config.user) == null ? void 0 : _b.name) ?? null
+  });
+}
+async function submitHeadlessIssueDraft({
+  draft,
+  pendingVideoFile,
+  transport,
+  issueRepository,
+  formSchema,
+  auth,
+  config,
+  projectId,
+  logs,
+  currentUrl,
+  userAgent,
+  uploadSessionReplaySnapshot
+}) {
+  var _a;
+  const screenshotUploads = draft.mediaMode === "screenshot" ? await transport.uploadScreenshotPreviews(draft.screenshotPreviewUrls) : [];
+  const screenshotUploadIds = screenshotUploads.map((upload) => upload.id);
+  const videoUpload = draft.mediaMode === "video" && pendingVideoFile ? await transport.uploadSignedMedia(pendingVideoFile, "video") : null;
+  const replayUpload = draft.sessionReplayEnabled ? await uploadSessionReplaySnapshot() : null;
+  const issueData = buildIssueCreatePayload({
+    draft,
+    auth,
+    config,
+    projectId,
+    uploads: { screenshotUploadIds, videoUpload, replayUpload },
+    logs,
+    currentUrl,
+    userAgent
+  });
+  const createdIssue = await issueRepository.createIssue(issueData);
+  await issueRepository.syncDynamicFields(createdIssue, draft, formSchema, {
+    screenshotUrl: (_a = screenshotUploads[0]) == null ? void 0 : _a.url,
+    videoUrl: videoUpload == null ? void 0 : videoUpload.url
+  });
+  return createdIssue;
+}
+const HEADLESS_CAPTURE_STYLE_ID = "issue-sticker-headless-capture-style";
+const HEADLESS_CAPTURE_STYLE = `
+  body.issue-sticker-mode-active,
+  body.issue-sticker-mode-active * {
+    cursor: crosshair !important;
+  }
+
+  body.issue-sticker-mode-active [data-issue-sticker-capture-ignore="true"],
+  body.issue-sticker-mode-active [data-issue-sticker-capture-ignore="true"] *,
+  body.issue-sticker-mode-active #issue-sticker-host,
+  body.issue-sticker-mode-active #issue-sticker-host * {
+    cursor: default !important;
+  }
+
+  body.issue-sticker-mode-active .issue-sticker-mode-highlight {
+    outline: 3px solid #00856f !important;
+    outline-offset: 3px !important;
+    box-shadow:
+      0 0 0 7px rgba(0, 133, 111, 0.18),
+      0 10px 28px rgba(0, 0, 0, 0.26) !important;
+    transition:
+      outline-color 120ms ease,
+      box-shadow 120ms ease !important;
+  }
+`;
+function isHTMLElement(value) {
+  return typeof HTMLElement !== "undefined" && value instanceof HTMLElement;
+}
+function resolveHeadlessCaptureTarget(target) {
+  if (!isHTMLElement(target)) return null;
+  return target.closest('[data-issue-sticker-capture-target="true"]') ?? target;
+}
+function ensureHeadlessCaptureStyles() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(HEADLESS_CAPTURE_STYLE_ID)) return;
+  const style = document.createElement("style");
+  style.id = HEADLESS_CAPTURE_STYLE_ID;
+  style.textContent = HEADLESS_CAPTURE_STYLE;
+  document.head.appendChild(style);
+}
+function startHeadlessTargetSelection({
+  isIgnoredTarget,
+  onCapture
+}) {
+  ensureHeadlessCaptureStyles();
+  document.body.classList.add("issue-sticker-mode-active");
+  let highlightedElement = null;
+  const clearHighlight = () => {
+    highlightedElement == null ? void 0 : highlightedElement.classList.remove("issue-sticker-mode-highlight");
+    highlightedElement = null;
+  };
+  const handleMouseOver = (event) => {
+    const target = resolveHeadlessCaptureTarget(event.target);
+    if (!target || isIgnoredTarget(target)) return;
+    clearHighlight();
+    target.classList.add("issue-sticker-mode-highlight");
+    highlightedElement = target;
+  };
+  const handleMouseOut = (event) => {
+    if (event.target === highlightedElement) {
+      clearHighlight();
+    }
+  };
+  const handleClick = (event) => {
+    const clickTarget = resolveHeadlessCaptureTarget(event.target);
+    if (!clickTarget || isIgnoredTarget(clickTarget)) return;
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    onCapture(highlightedElement ?? clickTarget, event);
+  };
+  document.addEventListener("mouseover", handleMouseOver, { capture: true, passive: true });
+  document.addEventListener("mouseout", handleMouseOut, { capture: true, passive: true });
+  document.addEventListener("click", handleClick, { capture: true, passive: false });
+  return () => {
+    document.removeEventListener("mouseover", handleMouseOver, {
+      capture: true
+    });
+    document.removeEventListener("mouseout", handleMouseOut, {
+      capture: true
+    });
+    document.removeEventListener("click", handleClick, { capture: true });
+    clearHighlight();
+    document.body.classList.remove("issue-sticker-mode-active");
+  };
+}
+const DEFAULT_EXCLUDE_SELECTORS = [
+  '[data-issue-sticker-capture-ignore="true"]',
+  "#issue-sticker-host",
+  '[data-issue-sticker-headless-auth="true"]'
+];
+class HeadlessClientImpl {
+  constructor(config) {
+    var _a;
+    this.config = config;
+    this.state = new HeadlessClientState();
+    this.pendingMedia = new HeadlessPendingMedia();
+    this.initializePromise = null;
+    this.captureCleanup = null;
+    this.captureSession = null;
+    this.suppressNextVideoStopSelection = false;
+    if (!((_a = config.apiKey) == null ? void 0 : _a.trim())) {
+      throw new IssueStickerHeadlessError("VALIDATION_ERROR", "apiKey가 필요합니다.");
+    }
+    this.authBridge = new HeadlessAuthBridge({
+      apiKey: config.apiKey,
+      getTenantId: () => this.snapshot.auth.tenantId,
+      getProjectId: () => this.snapshot.auth.projectId,
+      onToken: (result) => this.state.applyBridgeToken(result)
+    });
+    this.transport = new HeadlessTransport({
+      getAuthMode: () => this.snapshot.auth.mode,
+      resolveAuthorizationHeader: (forceRefreshMemberToken) => this.resolveAuthorizationHeader(forceRefreshMemberToken)
+    });
+    this.issueRepository = new HeadlessIssueRepository({
+      transport: this.transport,
+      getProjectId: () => this.state.requireProjectId(),
+      getAuthMode: () => this.snapshot.auth.mode,
+      getDefaultExternalUserId: () => {
+        var _a2;
+        return (_a2 = this.config.user) == null ? void 0 : _a2.id;
+      },
+      getCurrentUrl: () => typeof window !== "undefined" ? window.location.href : void 0
+    });
+    this.logCollectors = new HeadlessLogCollectors(this.config, getApiBaseUrl);
+    this.screenRecordingController = new ScreenRecordingController({
+      onStopped: (file) => {
+        void this.handleRecordedVideoStopped(file);
+      }
+    });
+    this.screenRecordingController.subscribe((recording) => {
+      this.state.setSnapshot({
+        videoCapture: {
+          isRecording: recording.isRecording,
+          hasRecordedVideo: Boolean(recording.recordedFile || this.pendingMedia.hasVideo),
+          error: recording.error
+        }
+      });
+    });
+    this.sessionReplayController = new SessionReplayCaptureController({
+      loadCapabilities: () => this.request("/api/session-replays/capabilities")
+    });
+    this.sessionReplayController.subscribe((sessionReplay) => {
+      this.applySessionReplaySnapshot(sessionReplay);
+    });
+  }
+  get snapshot() {
+    return this.state.getSnapshot();
+  }
+  get phase() {
+    return this.state.phase;
+  }
+  getSnapshot() {
+    return this.state.getSnapshot();
+  }
+  subscribe(listener) {
+    return this.state.subscribe(listener);
+  }
+  async initialize() {
+    if (this.snapshot.auth.isReady) {
+      return;
+    }
+    if (this.initializePromise) {
+      return this.initializePromise;
+    }
+    this.initializePromise = this.initializeInternal().finally(() => {
+      this.initializePromise = null;
+    });
+    return this.initializePromise;
+  }
+  async refreshIssues(filters = {}) {
+    await this.ensureInitialized();
+    this.state.assertPhase(["idle", "viewingIssue"], "refreshIssues");
+    this.state.setSnapshot({ phase: "loadingIssues", error: null });
+    try {
+      const issues = await this.issueRepository.fetchAllIssueStickers(filters);
+      this.state.setSnapshot({ issues, phase: "idle" });
+    } catch (error) {
+      const nextError = this.toHeadlessError(error);
+      this.state.setSnapshot({ phase: "idle", error: nextError });
+      throw nextError;
+    }
+  }
+  async refreshFilterSchema() {
+    await this.ensureInitialized();
+    try {
+      this.state.setSnapshot({ filterSchema: await this.issueRepository.loadFilterSchema() });
+    } catch (error) {
+      this.state.setSnapshot({
+        filterSchema: { groups: [], unavailableReason: "loading-failed" },
+        error: this.toHeadlessError(error)
+      });
+    }
+  }
+  async openIssue(issueId) {
+    await this.ensureInitialized();
+    this.state.assertPhase(["idle", "viewingIssue"], "openIssue");
+    this.state.setSnapshot({ phase: "viewingIssue", error: null });
+    try {
+      const activeIssue = await this.issueRepository.openIssue(issueId);
+      this.state.setSnapshot({ activeIssue, phase: "viewingIssue" });
+    } catch (error) {
+      const nextError = this.toHeadlessError(error);
+      this.state.setSnapshot({ activeIssue: null, phase: "idle", error: nextError });
+      throw nextError;
+    }
+  }
+  closeIssue() {
+    if (this.snapshot.phase === "viewingIssue") {
+      this.state.setSnapshot({ activeIssue: null, phase: "idle" });
+    }
+  }
+  async startIssueCapture(options = {}) {
+    await this.ensureInitialized();
+    this.state.assertPhase(["idle", "viewingIssue"], "startIssueCapture");
+    if (typeof document === "undefined" || typeof window === "undefined") {
+      throw new IssueStickerHeadlessError(
+        "CAPTURE_FAILED",
+        "브라우저 DOM에서만 이슈 캡쳐를 시작할 수 있습니다."
+      );
+    }
+    assertScreenshotCaptureOptions(options);
+    this.closeIssue();
+    this.clearCaptureListeners();
+    this.clearPendingMedia();
+    this.beginTargetSelection();
+  }
+  async startVideoCapture() {
+    await this.ensureInitialized();
+    this.state.assertPhase(["idle", "viewingIssue"], "startVideoCapture");
+    if (typeof document === "undefined" || typeof window === "undefined") {
+      throw new IssueStickerHeadlessError(
+        "CAPTURE_FAILED",
+        "브라우저 DOM에서만 영상 캡쳐를 시작할 수 있습니다."
+      );
+    }
+    this.closeIssue();
+    this.clearCaptureListeners();
+    this.clearPendingMedia();
+    this.captureSession = null;
+    this.suppressNextVideoStopSelection = false;
+    this.state.setSnapshot({ phase: "recordingVideo", draft: null, formSchema: null, error: null });
+    try {
+      await this.screenRecordingController.startRecording();
+    } catch (error) {
+      const nextError = this.toHeadlessError(error, "CAPTURE_FAILED");
+      this.clearPendingMedia();
+      this.state.setSnapshot({ phase: "idle", error: nextError });
+      throw nextError;
+    }
+  }
+  async stopVideoCapture() {
+    await this.ensureInitialized();
+    this.state.assertPhase(["recordingVideo"], "stopVideoCapture");
+    const file = await this.screenRecordingController.stopRecording();
+    if (!file && this.snapshot.phase === "recordingVideo") {
+      this.clearPendingMedia();
+      this.state.setSnapshot({ phase: "idle" });
+    }
+  }
+  setSessionReplayEnabled(enabled) {
+    this.sessionReplayController.setEnabled(enabled);
+  }
+  beginTargetSelection() {
+    if (typeof document === "undefined") {
+      throw new IssueStickerHeadlessError(
+        "CAPTURE_FAILED",
+        "브라우저 DOM에서만 이슈 캡쳐를 시작할 수 있습니다."
+      );
+    }
+    preloadModernScreenshot();
+    this.captureSession = null;
+    this.state.setSnapshot({
+      phase: "selectingTarget",
+      draft: null,
+      formSchema: null,
+      error: null
+    });
+    this.captureCleanup = startHeadlessTargetSelection({
+      isIgnoredTarget: (target) => this.isIgnoredTarget(target),
+      onCapture: (target, event) => {
+        void this.captureTarget(target, event);
+      }
+    });
+  }
+  cancelIssueCapture() {
+    if (this.snapshot.phase !== "recordingVideo" && this.snapshot.phase !== "selectingTarget" && this.snapshot.phase !== "draftingIssue") {
+      return;
+    }
+    this.clearCaptureListeners();
+    if (this.snapshot.phase === "recordingVideo") {
+      this.suppressNextVideoStopSelection = true;
+      this.screenRecordingController.discard();
+    }
+    this.clearPendingMedia();
+    this.captureSession = null;
+    this.state.setSnapshot({ phase: "idle", draft: null, formSchema: null, error: null });
+  }
+  async submitDraft(input) {
+    await this.ensureInitialized();
+    this.state.assertPhase(["draftingIssue"], "submitDraft");
+    this.state.requireDraft();
+    if (!input.title.trim()) {
+      throw new IssueStickerHeadlessError("VALIDATION_ERROR", "제목을 입력해주세요.");
+    }
+    if (!input.description.trim()) {
+      throw new IssueStickerHeadlessError("VALIDATION_ERROR", "설명을 입력해주세요.");
+    }
+    this.state.setSnapshot({ phase: "submittingIssue", error: null });
+    try {
+      const session = this.captureSession;
+      const screenshotPreviewUrls = (session == null ? void 0 : session.screenshots) ? await session.screenshots : this.state.requireDraft().screenshotPreviewUrls;
+      const formSchema = this.snapshot.formSchema ?? ((session == null ? void 0 : session.formSchema) ? await session.formSchema : null);
+      const submission = {
+        ...this.state.requireDraft(),
+        screenshotPreviewUrls,
+        title: input.title,
+        description: input.description,
+        dynamicFields: input.dynamicFields ?? {}
+      };
+      const createdIssue = await submitHeadlessIssueDraft({
+        draft: submission,
+        pendingVideoFile: this.pendingMedia.videoFile,
+        transport: this.transport,
+        issueRepository: this.issueRepository,
+        formSchema,
+        auth: this.snapshot.auth,
+        config: this.config,
+        projectId: this.state.requireProjectId(),
+        logs: this.logCollectors.collect(),
+        currentUrl: typeof window !== "undefined" ? window.location.href : "",
+        userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+        uploadSessionReplaySnapshot: () => this.uploadSessionReplaySnapshot()
+      });
+      this.clearCaptureListeners();
+      this.clearPendingMedia();
+      this.captureSession = null;
+      this.state.setSnapshot({
+        phase: "idle",
+        draft: null,
+        formSchema: null,
+        issues: [createdIssue, ...this.snapshot.issues]
+      });
+      return createdIssue;
+    } catch (error) {
+      const nextError = this.toHeadlessError(error);
+      this.state.setSnapshot({ phase: "draftingIssue", error: nextError });
+      throw nextError;
+    }
+  }
+  async loginAsMember() {
+    await this.ensureInitialized();
+    if (!this.authBridge.canUseBridge) {
+      throw new IssueStickerHeadlessError(
+        "MEMBER_AUTH_REQUIRED",
+        "SDK auth bridge를 사용할 수 없습니다."
+      );
+    }
+    const silentToken = await this.authBridge.getValidMemberToken({ forceRefresh: true }).catch(() => null);
+    if (silentToken) {
+      this.state.setAuthMode("member");
+      await this.refreshFilterSchema();
+      await this.sessionReplayController.refresh();
+      return;
+    }
+    await this.authBridge.openInteractiveLoginFrame();
+    await this.refreshFilterSchema();
+    await this.sessionReplayController.refresh();
+  }
+  async logoutMember() {
+    await this.ensureInitialized();
+    this.authBridge.clearMemberToken();
+    this.state.setAuthMode("public");
+    this.authBridge.postLogout();
+    this.state.setSnapshot({
+      filterSchema: { groups: [], unavailableReason: "public-mode" },
+      formSchema: null
+    });
+    void this.sessionReplayController.refresh();
+  }
+  destroy() {
+    this.clearCaptureListeners();
+    this.suppressNextVideoStopSelection = true;
+    this.captureSession = null;
+    this.screenRecordingController.destroy();
+    this.sessionReplayController.destroy();
+    this.clearPendingMedia();
+    this.logCollectors.stop();
+    this.authBridge.destroy();
+    this.state.reset();
+  }
+  async initializeInternal() {
+    this.state.setSnapshot({ phase: "initializing", error: null });
+    try {
+      const result = await this.request("/api/sdk/auth/public-init", {
+        method: "POST",
+        body: { apiKey: this.config.apiKey },
+        skipAuth: true
+      });
+      this.authBridge.setAuthBridgeUrl(result.authBridgeUrl ?? null);
+      this.state.setSnapshot({
+        phase: "idle",
+        auth: {
+          mode: "public",
+          isReady: true,
+          canUseIntegrations: false,
+          tenantId: result.tenantId,
+          projectId: result.projectId,
+          accountId: null
+        },
+        filterSchema: { groups: [], unavailableReason: "public-mode" }
+      });
+      this.logCollectors.start();
+      this.authBridge.mountHiddenBridgeFrame();
+      void this.sessionReplayController.initialize();
+    } catch (error) {
+      const nextError = this.toHeadlessError(error);
+      this.state.setSnapshot({ phase: "idle", error: nextError });
+      throw nextError;
+    }
+  }
+  async takeSessionReplayPreview() {
+    const sessionReplay = this.sessionReplayController.getSnapshot();
+    if (!sessionReplay.enabled || !sessionReplay.canAttach) return null;
+    try {
+      const snapshot = await this.sessionReplayController.takeSnapshot();
+      return snapshot ? createSessionReplayMeta(snapshot) : null;
+    } catch {
+      return null;
+    }
+  }
+  async uploadSessionReplaySnapshot() {
+    const sessionReplay = this.sessionReplayController.getSnapshot();
+    if (!sessionReplay.enabled || !sessionReplay.canAttach) return null;
+    try {
+      const snapshot = await this.sessionReplayController.takeSnapshot();
+      if (!snapshot) return null;
+      if (snapshot.eventCount <= 0) return null;
+      const upload = await this.transport.uploadSignedMedia(createReplayFile(snapshot), "replay");
+      return {
+        uploadId: upload.id,
+        url: upload.url,
+        meta: createSessionReplayMeta(snapshot)
+      };
+    } catch {
+      return null;
+    }
+  }
+  async handleRecordedVideoStopped(file) {
+    if (this.suppressNextVideoStopSelection) {
+      this.suppressNextVideoStopSelection = false;
+      this.clearPendingMedia();
+      return;
+    }
+    this.pendingMedia.setVideoFile(file);
+    this.state.setSnapshot({
+      videoCapture: {
+        isRecording: false,
+        hasRecordedVideo: true,
+        error: null
+      }
+    });
+    if (this.snapshot.phase === "recordingVideo") {
+      try {
+        this.beginTargetSelection();
+      } catch (error) {
+        const nextError = this.toHeadlessError(error, "CAPTURE_FAILED");
+        this.clearPendingMedia();
+        this.state.setSnapshot({ phase: "idle", error: nextError });
+      }
+    }
+  }
+  applySessionReplaySnapshot(sessionReplay) {
+    const canAttachCurrentDraft = Boolean(sessionReplay.enabled && sessionReplay.canAttach);
+    this.state.setSnapshot({
+      sessionReplay: {
+        available: sessionReplay.available,
+        canAttach: sessionReplay.canAttach,
+        enabled: sessionReplay.enabled,
+        error: sessionReplay.error
+      },
+      draft: this.snapshot.draft ? {
+        ...this.snapshot.draft,
+        sessionReplayEnabled: canAttachCurrentDraft,
+        sessionReplayPreview: canAttachCurrentDraft ? this.snapshot.draft.sessionReplayPreview : null
+      } : this.snapshot.draft
+    });
+  }
+  clearPendingMedia() {
+    this.pendingMedia.clear();
+    this.screenRecordingController.clearRecordedFile();
+    this.state.setSnapshot({
+      videoCapture: {
+        isRecording: this.screenRecordingController.getSnapshot().isRecording,
+        hasRecordedVideo: false,
+        error: this.screenRecordingController.getSnapshot().error
+      }
+    });
+  }
+  captureTarget(target, event) {
+    if (this.snapshot.phase !== "selectingTarget") {
+      return;
+    }
+    this.clearCaptureListeners();
+    const sessionReplay = this.sessionReplayController.getSnapshot();
+    const draft = buildHeadlessCaptureContext({
+      target,
+      event,
+      videoFile: this.pendingMedia.videoFile,
+      createVideoPreviewUrl: (file) => this.pendingMedia.createVideoPreviewUrl(file),
+      sessionReplayEnabled: Boolean(sessionReplay.enabled && sessionReplay.canAttach)
+    });
+    this.state.setSnapshot({ phase: "draftingIssue", draft, formSchema: null, error: null });
+    this.beginBackgroundCapturePreparation(draft, target);
+  }
+  beginBackgroundCapturePreparation(draft, target) {
+    var _a, _b;
+    const token = {};
+    this.captureSession = {
+      token,
+      screenshots: draft.mediaMode === "screenshot" ? captureHeadlessScreenshots({ target, excludeSelectors: this.getExcludeSelectors() }) : null,
+      formSchema: this.loadFormSchema({})
+    };
+    const isCurrentSession = () => {
+      var _a2;
+      return ((_a2 = this.captureSession) == null ? void 0 : _a2.token) === token;
+    };
+    void ((_a = this.captureSession.screenshots) == null ? void 0 : _a.then((screenshotPreviewUrls) => {
+      if (!isCurrentSession()) return;
+      this.mergeDraft({ screenshotPreviewUrls });
+    }));
+    void ((_b = this.captureSession.formSchema) == null ? void 0 : _b.then((formSchema) => {
+      if (!isCurrentSession()) return;
+      this.state.setSnapshot({ formSchema });
+    }));
+    if (draft.sessionReplayEnabled) {
+      void this.takeSessionReplayPreview().then((sessionReplayPreview) => {
+        var _a2;
+        if (!isCurrentSession()) return;
+        if (!((_a2 = this.snapshot.draft) == null ? void 0 : _a2.sessionReplayEnabled)) return;
+        this.mergeDraft({ sessionReplayPreview });
+      });
+    }
+  }
+  mergeDraft(patch) {
+    const draft = this.snapshot.draft;
+    if (!draft) return;
+    if (this.snapshot.phase !== "draftingIssue" && this.snapshot.phase !== "submittingIssue") {
+      return;
+    }
+    this.state.setSnapshot({ draft: { ...draft, ...patch } });
+  }
+  async loadFormSchema(values) {
+    try {
+      return await buildIssueFormSchema(values, {
+        authMode: this.snapshot.auth.mode,
+        getActiveIntegration: () => this.issueRepository.getActiveIntegration(),
+        getCustomFieldDefinitions: () => this.issueRepository.getCustomFieldDefinitions(),
+        requestResponse: (endpoint) => this.issueRepository.requestResponse(endpoint),
+        searchJiraProjectUsers: (query) => this.issueRepository.searchJiraProjectUsers(query),
+        resolveJiraProjectUserLabel: (accountId) => this.issueRepository.resolveJiraProjectUserLabel(accountId),
+        searchJiraProjectIssues: (query) => this.issueRepository.searchJiraProjectIssues(query),
+        resolveJiraProjectIssueLabel: (issueKey) => this.issueRepository.resolveJiraProjectIssueLabel(issueKey),
+        searchNotionPeople: (query) => this.issueRepository.searchNotionPeople(query)
+      });
+    } catch (error) {
+      this.state.setSnapshot({ error: this.toHeadlessError(error) });
+      return { fields: [], unavailableReason: "loading-failed" };
+    }
+  }
+  async request(endpoint, options = {}) {
+    return this.transport.request(endpoint, options);
+  }
+  async resolveAuthorizationHeader(forceRefreshMemberToken = false) {
+    if (this.snapshot.auth.mode === "member") {
+      const token = await this.authBridge.getValidMemberToken({
+        forceRefresh: forceRefreshMemberToken
+      });
+      if (!token) {
+        throw new IssueStickerHeadlessError("MEMBER_AUTH_REQUIRED", "멤버 로그인이 필요합니다.");
+      }
+      return `Bearer ${token}`;
+    }
+    return `ApiKey ${this.config.apiKey}`;
+  }
+  ensureInitialized() {
+    return this.snapshot.auth.isReady ? Promise.resolve() : this.initialize();
+  }
+  clearCaptureListeners() {
+    var _a;
+    (_a = this.captureCleanup) == null ? void 0 : _a.call(this);
+    this.captureCleanup = null;
+  }
+  isIgnoredTarget(target) {
+    if (target.closest(".issue-sticker-marker")) return true;
+    return this.getExcludeSelectors().some((selector) => target.closest(selector));
+  }
+  getExcludeSelectors() {
+    var _a;
+    return [...DEFAULT_EXCLUDE_SELECTORS, ...((_a = this.config.capture) == null ? void 0 : _a.excludeSelectors) ?? []];
+  }
+  toHeadlessError(error, fallbackCode = "NETWORK_ERROR") {
+    if (error instanceof IssueStickerHeadlessError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new IssueStickerHeadlessError(fallbackCode, error.message, error);
+    }
+    return new IssueStickerHeadlessError(fallbackCode, "알 수 없는 오류가 발생했습니다.", error);
+  }
+}
+function createIssueStickerHeadless(config) {
+  return new HeadlessClientImpl(config);
+}
+export {
+  IssueStickerHeadlessError,
+  createIssueStickerHeadless,
+  createIssueStickerHeadless as default
+};