@h-ai/feedback 0.0.0-stage → 0.1.0-alpha.70

package/dist/client/index.js

@@ -0,0 +1,889 @@
+import { HaiFeedbackError, feedbackM, redactFeedbackText } from '../chunk-DYEK2FNM.js';
+import { FeedbackEvidenceInputSchema, FeedbackReportSchema, FeedbackSubmitInputSchema } from '@h-ai/api-contract/feedback';
+import { core, ok, err } from '@h-ai/core';
+
+// src/client/feedback-client-image.ts
+var PRIVATE_SELECTOR = 'input,textarea,select,[contenteditable]:not([contenteditable="false"]),[data-feedback-private],.rr-block,.rr-mask';
+async function captureFeedbackScreenshot() {
+  if (document.fonts) {
+    let timeout;
+    try {
+      await Promise.race([document.fonts.ready, new Promise((resolve) => timeout = setTimeout(resolve, 500))]);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  const { default: html2canvas } = await import('html2canvas');
+  const canvas = await html2canvas(document.body, {
+    width: Math.min(window.innerWidth, 1920),
+    height: Math.min(window.innerHeight, 1200),
+    scale: 1,
+    // 原生 SVG foreignObject 保留 CSS mask 图标与字体基线，避免 CanvasRenderer 裁切文本。
+    foreignObjectRendering: true,
+    scrollX: -window.scrollX,
+    scrollY: -window.scrollY,
+    useCORS: false,
+    allowTaint: false,
+    logging: false,
+    imageTimeout: 1e3,
+    ignoreElements: (element) => element.matches("[data-feedback-ignore],iframe,video"),
+    onclone: (clone) => {
+      const colorCanvas = clone.createElement("canvas");
+      colorCanvas.width = 1;
+      colorCanvas.height = 1;
+      const paint = colorCanvas.getContext("2d", { willReadFrequently: true });
+      const colors = /* @__PURE__ */ new Map();
+      if (paint && clone.defaultView) {
+        for (const element of clone.querySelectorAll("*")) {
+          const computed = clone.defaultView.getComputedStyle(element);
+          for (const property of ["color", "background-color", "border-top-color", "border-bottom-color", "border-left-color", "border-right-color", "outline-color", "text-decoration-color", "-webkit-text-stroke-color"]) {
+            const raw = computed.getPropertyValue(property);
+            if (!/oklch|oklab|color\(|lab\(|lch\(/i.test(raw))
+              continue;
+            let normalized = colors.get(raw);
+            if (!normalized) {
+              paint.clearRect(0, 0, 1, 1);
+              paint.fillStyle = raw;
+              paint.fillRect(0, 0, 1, 1);
+              const pixel = paint.getImageData(0, 0, 1, 1).data;
+              normalized = `rgba(${pixel[0]},${pixel[1]},${pixel[2]},${pixel[3] / 255})`;
+              colors.set(raw, normalized);
+            }
+            element.style.setProperty(property, normalized, "important");
+          }
+        }
+      }
+      for (const element of clone.querySelectorAll(PRIVATE_SELECTOR)) {
+        const bounds = element.getBoundingClientRect();
+        const replacement = clone.createElement("div");
+        replacement.style.cssText = `width:${bounds.width}px;height:${bounds.height}px;background:#111;color:transparent;overflow:hidden`;
+        replacement.setAttribute("aria-hidden", "true");
+        element.replaceWith(replacement);
+      }
+    }
+  });
+  try {
+    return await canvasBytes(canvas);
+  } finally {
+    canvas.width = 0;
+    canvas.height = 0;
+  }
+}
+async function annotateFeedbackImage(bytes, annotation) {
+  if (![annotation.x, annotation.y, annotation.width, annotation.height].every(Number.isFinite) || annotation.width <= 0 || annotation.height <= 0)
+    throw new Error("Invalid annotation rectangle");
+  const image = new Image();
+  const imageUrl = URL.createObjectURL(new Blob([new Uint8Array(bytes)], { type: "image/png" }));
+  const canvas = document.createElement("canvas");
+  try {
+    image.src = imageUrl;
+    await image.decode();
+    canvas.width = image.naturalWidth;
+    canvas.height = image.naturalHeight;
+    const context = canvas.getContext("2d");
+    if (!context)
+      throw new Error("Canvas is unavailable");
+    context.drawImage(image, 0, 0);
+    if (annotation.mode === "mask") {
+      context.fillStyle = "#111";
+      context.fillRect(annotation.x, annotation.y, annotation.width, annotation.height);
+    } else {
+      context.strokeStyle = "#e11d48";
+      context.lineWidth = 3;
+      context.strokeRect(annotation.x, annotation.y, annotation.width, annotation.height);
+    }
+    return await canvasBytes(canvas);
+  } finally {
+    URL.revokeObjectURL(imageUrl);
+    canvas.width = 0;
+    canvas.height = 0;
+  }
+}
+async function canvasBytes(canvas) {
+  const blob = await new Promise((resolve, reject) => canvas.toBlob((value) => value ? resolve(value) : reject(new Error("Screenshot encoding failed")), "image/png"));
+  return new Uint8Array(await blob.arrayBuffer());
+}
+var CREDENTIAL_NAME = /authorization|password|passcode|secret|token|session|csrf|credential|api.?key|private.?key/i;
+function sanitizeFeedbackText(value) {
+  return redactFeedbackText(value).replace(/\bhttps?:\/\/[^\s<>"']+/gi, (url) => core.sanitize.sanitizeUrl(url));
+}
+function sanitizeFeedbackData(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function visit(input, depth) {
+    if (depth > 8)
+      return "[TRUNCATED]";
+    if (typeof input === "string")
+      return sanitizeFeedbackText(input).slice(0, 8192);
+    if (input instanceof Error)
+      return visit({ name: input.name, message: input.message, stack: input.stack }, depth + 1);
+    if (!input || typeof input !== "object")
+      return input === void 0 || typeof input === "function" || typeof input === "symbol" ? null : typeof input === "bigint" ? String(input) : input;
+    if (seen.has(input))
+      return "[CIRCULAR]";
+    seen.add(input);
+    if (Array.isArray(input))
+      return input.slice(0, 200).map((item) => visit(item, depth + 1));
+    const output = {};
+    for (const [key, item] of Object.entries(input).slice(0, 100)) {
+      if (["__proto__", "constructor", "prototype"].includes(key))
+        continue;
+      output[key] = CREDENTIAL_NAME.test(key) ? "[REDACTED]" : visit(item, depth + 1);
+    }
+    return output;
+  }
+  const safe = core.sanitize.sanitizeSensitiveFields(visit(value, 0));
+  return safe && typeof safe === "object" && !Array.isArray(safe) ? safe : { value: safe };
+}
+function sanitizeFeedbackReplay(value) {
+  function visit(input, depth) {
+    if (depth > 64)
+      throw new Error("Replay snapshot exceeds depth limit");
+    if (typeof input === "string")
+      return sanitizeFeedbackText(input);
+    if (input === void 0)
+      return null;
+    if (!input || typeof input !== "object")
+      return input;
+    if (Array.isArray(input))
+      return input.map((item) => visit(item, depth + 1));
+    const output = {};
+    for (const [key, item] of Object.entries(input)) {
+      if (["__proto__", "constructor", "prototype"].includes(key))
+        continue;
+      if (key === "attributes" && item && typeof item === "object") {
+        const attributes = {};
+        for (const [attribute, content] of Object.entries(item)) {
+          if (/^on|^(?:srcdoc|action|formaction|href|srcset)$/i.test(attribute) || CREDENTIAL_NAME.test(attribute))
+            continue;
+          if (attribute === "src" && typeof content === "string" && !/^data:image\/(?:png|jpeg|webp|gif);base64,/i.test(content)) {
+            attributes["data-feedback-missing-resource"] = true;
+            continue;
+          }
+          if (attribute === "style" && typeof content === "string" && /url\s*\(/i.test(content)) {
+            attributes.style = sanitizeFeedbackText(content).replace(/url\s*\([^)]*\)/gi, "");
+            attributes["data-feedback-missing-resource"] = true;
+          } else {
+            attributes[attribute] = visit(content, depth + 1);
+          }
+        }
+        output[key] = attributes;
+      } else if (key === "textContent" && typeof item === "string") {
+        output[key] = sanitizeFeedbackText(item).replace(/(?:url|@import)\s*\([^)]*\)|@import\s+["'][^"']+["']/gi, "");
+      } else {
+        output[key] = CREDENTIAL_NAME.test(key) ? "[REDACTED]" : visit(item, depth + 1);
+      }
+    }
+    return output;
+  }
+  return visit(value, 0);
+}
+function collectFeedbackCookies(cookie, allowlist) {
+  const allowed = new Set(allowlist.filter((name) => !CREDENTIAL_NAME.test(name)));
+  const output = {};
+  for (const pair of cookie.split(";")) {
+    const separator = pair.indexOf("=");
+    if (separator < 0)
+      continue;
+    const name = pair.slice(0, separator).trim();
+    if (!allowed.has(name))
+      continue;
+    output[name] = redactFeedbackText(pair.slice(separator + 1).trim().slice(0, 256));
+  }
+  return output;
+}
+function feedbackPageUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return "[INVALID_URL]";
+  }
+}
+
+// src/client/feedback-client-store.ts
+var STORE = "drafts";
+async function withStore(callback) {
+  const database = await new Promise((resolve, reject) => {
+    const request = indexedDB.open("hai-feedback-v1", 1);
+    request.onupgradeneeded = () => request.result.createObjectStore(STORE);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+  });
+  try {
+    return await new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE, "readwrite");
+      const request = callback(transaction.objectStore(STORE));
+      transaction.oncomplete = () => resolve(request.result);
+      transaction.onerror = () => reject(transaction.error);
+      transaction.onabort = () => reject(transaction.error);
+    });
+  } finally {
+    database.close();
+  }
+}
+async function saveFeedbackDraft(appId, draft) {
+  await withStore((store) => store.put(draft, appId));
+}
+async function restoreFeedbackDraft(appId) {
+  const value = await withStore((store) => store.get(appId));
+  if (!value || typeof value !== "object" || !("expiresAt" in value) || typeof value.expiresAt !== "number" || value.expiresAt <= Date.now()) {
+    await withStore((store) => store.delete(appId));
+    return void 0;
+  }
+  return value;
+}
+async function deleteFeedbackDraft(appId) {
+  await withStore((store) => {
+    store.delete(`${appId}:checkpoint`);
+    return store.delete(appId);
+  });
+}
+async function saveFeedbackCheckpoint(key, evidence) {
+  await withStore((store) => store.put({ evidence, expiresAt: Date.now() + 3e5 }, `${key}:checkpoint`));
+}
+async function restoreFeedbackCheckpoint(key) {
+  return withStore((store) => store.get(`${key}:checkpoint`));
+}
+
+// src/client/feedback-client-main.ts
+function createFeedbackClient() {
+  let config;
+  let initializing = false;
+  let draft;
+  let sequence = 0;
+  let buffer = [];
+  let bufferBytes = 0;
+  let dropped = 0;
+  let lastError;
+  let errorWindows = [];
+  let afterCount = 0;
+  let deadline = 0;
+  let initialIds = /* @__PURE__ */ new Set();
+  const uploadedIds = /* @__PURE__ */ new Set();
+  let flushPromise;
+  let preparePromise;
+  let persistTimer;
+  let flushTimer;
+  let stopReplay;
+  let unsubscribeLogger;
+  let source = "";
+  let keyScreenshots = [];
+  let lastKeyScreenshot = 0;
+  let keyScreenshotPromise;
+  let closing = false;
+  let closePromise;
+  let collectionFinished = false;
+  let collectionSealed = false;
+  let draftBytes = 0;
+  let storageKey = "";
+  const cleanups = [];
+  const missing = /* @__PURE__ */ new Set();
+  let replayChunks = [];
+  function failure(code = "OPERATION_FAILED", cause) {
+    const key = code === "NOT_INITIALIZED" ? "feedback_notInitialized" : code === "LIMIT_EXCEEDED" ? "feedback_limitExceeded" : code === "INVALID_INPUT" ? "feedback_invalidInput" : "feedback_operationFailed";
+    return err(HaiFeedbackError[code], feedbackM(key), cause);
+  }
+  function limits() {
+    return { events: config?.maxEvents ?? 1e3, bytes: config?.maxBytes ?? 2 * 1024 * 1024, age: config?.maxAgeMs ?? 3e5, before: config?.beforeCount ?? 100, after: config?.afterCount ?? 100 };
+  }
+  function schedulePersist() {
+    if (!config?.persistDraft || persistTimer)
+      return;
+    persistTimer = setTimeout(() => {
+      persistTimer = void 0;
+      if (config && draft && !collectionFinished)
+        void saveFeedbackDraft(storageKey, draft).catch(() => missing.add("browser-persistence-unavailable"));
+      else if (config)
+        void saveFeedbackCheckpoint(storageKey, buffer).catch(() => missing.add("browser-persistence-unavailable"));
+    }, 200);
+  }
+  function record(event) {
+    if (!config || closing)
+      return;
+    const entry = FeedbackEvidenceInputSchema.safeParse({
+      id: core.id.uuid(),
+      source,
+      sequence: ++sequence,
+      kind: event.kind,
+      timestamp: Date.now(),
+      requestId: event.requestId,
+      errorId: event.kind === "error" || event.kind === "request" && event.data.success === false ? event.errorId ?? core.id.uuid() : event.errorId,
+      data: sanitizeFeedbackData(event.data)
+    });
+    if (!entry.success)
+      return;
+    const item = entry.data;
+    const size = new TextEncoder().encode(JSON.stringify(item)).byteLength;
+    const bounds = limits();
+    if (size > Math.min(bounds.bytes, 64 * 1024)) {
+      dropped++;
+      return;
+    }
+    buffer.push(item);
+    bufferBytes += size;
+    while (buffer.length > bounds.events || bufferBytes > bounds.bytes || (buffer[0]?.timestamp ?? 0) < Date.now() - bounds.age) {
+      const removed = buffer.shift();
+      if (removed)
+        bufferBytes -= new TextEncoder().encode(JSON.stringify(removed)).byteLength;
+      dropped++;
+    }
+    const logEntry = item.kind === "log" || item.kind === "error";
+    if (logEntry) {
+      for (const window2 of errorWindows) {
+        if (item.timestamp <= window2.deadline && window2.after < bounds.after) {
+          window2.evidence.push(item);
+          window2.after++;
+          window2.bytes += size;
+        }
+      }
+    }
+    if (item.kind === "error" || item.kind === "request" && item.data.success === false) {
+      lastError = item;
+      const before = buffer.filter((entry2) => (entry2.kind === "log" || entry2.kind === "error") && entry2.id !== item.id);
+      const evidence = [...before.slice(Math.max(0, before.length - bounds.before)), item];
+      errorWindows.push({ anchor: item, evidence, after: 0, deadline: item.timestamp + (config.afterTimeoutMs ?? 3e4), bytes: new TextEncoder().encode(JSON.stringify(evidence)).byteLength });
+      void captureKeyScreenshot();
+    }
+    errorWindows = errorWindows.filter((window2) => window2.anchor.timestamp >= Date.now() - bounds.age);
+    while (errorWindows.length > 10 || errorWindows.reduce((total, window2) => total + window2.evidence.length, 0) > bounds.events || errorWindows.reduce((total, window2) => total + window2.bytes, 0) > bounds.bytes) {
+      errorWindows.shift();
+      missing.add("browser-error-windows-truncated");
+    }
+    schedulePersist();
+    if (draft && !collectionFinished && !collectionSealed && (Date.now() <= deadline && afterCount < bounds.after || item.kind === "environment") && draft.evidence.length < bounds.events && draftBytes + size <= bounds.bytes) {
+      draft.evidence.push(item);
+      draftBytes += size;
+      if (item.kind === "log" || item.kind === "error")
+        afterCount++;
+      schedulePersist();
+    }
+  }
+  function listen(name, callback) {
+    window.addEventListener(name, callback);
+    cleanups.push(() => window.removeEventListener(name, callback));
+  }
+  async function init(input) {
+    if (initializing)
+      return err(HaiFeedbackError.INIT_IN_PROGRESS, feedbackM("feedback_initInProgress"));
+    initializing = true;
+    try {
+      if (config || closePromise)
+        await close();
+      if (typeof window === "undefined" || !input.appId || !input.actions || ["submit", "appendEvidence", "completeCollection", "upload"].some((key) => typeof input.actions[key] !== "function"))
+        return failure("INVALID_INPUT");
+      const numeric = [input.maxEvents, input.maxBytes, input.maxAgeMs, input.beforeCount, input.afterCount, input.afterTimeoutMs, input.screenshotTimeoutMs, input.maxKeyScreenshots, input.keyScreenshotThrottleMs];
+      if (numeric.some((value) => value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) || input.persistDraft && !input.persistenceKey)
+        return failure("INVALID_INPUT");
+      config = input;
+      closing = false;
+      source = `browser:${core.id.uuid()}`;
+      storageKey = `${input.appId}:${input.persistenceKey ?? ""}`;
+      if (input.persistDraft) {
+        try {
+          const restored = await restoreFeedbackDraft(storageKey);
+          if (closing || config !== input)
+            return failure("NOT_INITIALIZED");
+          if (restored && Array.isArray(restored.evidence) && restored.evidence.every((item) => FeedbackEvidenceInputSchema.safeParse(item).success) && Array.isArray(restored.attachments) && restored.attachments.every((item) => item.bytes instanceof Uint8Array) && (!restored.report || FeedbackReportSchema.safeParse(restored.report).success)) {
+            draft = restored;
+            missing.add("browser-session-interrupted");
+            deadline = Date.now();
+          } else {
+            const checkpoint = await restoreFeedbackCheckpoint(storageKey);
+            if (closing || config !== input)
+              return failure("NOT_INITIALIZED");
+            if (checkpoint && typeof checkpoint === "object" && "evidence" in checkpoint && Array.isArray(checkpoint.evidence) && "expiresAt" in checkpoint && typeof checkpoint.expiresAt === "number" && checkpoint.expiresAt > Date.now()) {
+              const parsed = checkpoint.evidence.map((item) => FeedbackEvidenceInputSchema.safeParse(item));
+              if (parsed.every((item) => item.success)) {
+                buffer = parsed.filter((item) => item.success).map((item) => item.data);
+                bufferBytes = new TextEncoder().encode(JSON.stringify(buffer)).byteLength;
+                sequence = Math.max(0, ...buffer.map((item) => item.sequence));
+                lastError = buffer.filter((item) => item.kind === "error" || item.kind === "request" && item.data.success === false).at(-1);
+                missing.add("browser-session-interrupted");
+                missing.add("previous-page-screenshot-unavailable");
+              }
+            }
+          }
+        } catch {
+          if (closing || config !== input)
+            return failure("NOT_INITIALIZED");
+          missing.add("browser-persistence-unavailable");
+        }
+      }
+      unsubscribeLogger = core.logger.observe((entry) => {
+        if (entry.context.module === "feedback" || entry.context.feedback === true)
+          return;
+        record({ kind: ["error", "fatal"].includes(entry.level) ? "error" : "log", requestId: typeof entry.context.requestId === "string" ? entry.context.requestId : void 0, data: { level: entry.level, message: entry.message, context: entry.context } });
+      });
+      listen("error", (event) => record({ kind: "error", data: { message: event.message, stack: event.error instanceof Error ? event.error.stack : void 0, filename: feedbackPageUrl(event.filename || location.href), line: event.lineno, column: event.colno } }));
+      listen("unhandledrejection", (event) => record({ kind: "error", data: { reason: event.reason } }));
+      const click = (event) => {
+        if (!(event.target instanceof Element) || event.target.closest("[data-feedback-ignore]"))
+          return;
+        const target = event.target.closest("[data-feedback-action],button,a");
+        if (target && !target.closest("[data-feedback-private]")) {
+          record({ kind: "interaction", data: { action: target.getAttribute("data-feedback-action") ?? target.tagName.toLowerCase(), route: location.pathname } });
+          if (target.hasAttribute("data-feedback-action"))
+            void captureKeyScreenshot();
+        }
+      };
+      document.addEventListener("click", click, true);
+      cleanups.push(() => document.removeEventListener("click", click, true));
+      if (input.captureConsole) {
+        for (const level of ["debug", "info", "warn", "error"]) {
+          const original = globalThis.console[level];
+          const wrapper = (...args) => {
+            record({ kind: level === "error" ? "error" : "log", data: { channel: "console", level, arguments: args } });
+            original.apply(globalThis.console, args);
+          };
+          globalThis.console[level] = wrapper;
+          cleanups.push(() => {
+            if (globalThis.console[level] === wrapper)
+              globalThis.console[level] = original;
+          });
+        }
+      }
+      listen("pagehide", () => {
+        deadline = Date.now();
+        if (input.persistDraft && draft)
+          void saveFeedbackDraft(storageKey, draft).catch(() => missing.add("browser-persistence-unavailable"));
+        else if (input.persistDraft)
+          void saveFeedbackCheckpoint(storageKey, buffer).catch(() => missing.add("browser-persistence-unavailable"));
+        void flush();
+      });
+      if (input.replay)
+        await startReplay(input);
+      if (closing || config !== input)
+        return failure("NOT_INITIALIZED");
+      flushTimer = setInterval(() => {
+        if (draft?.report)
+          void flush();
+      }, 1e3);
+      return ok(void 0);
+    } catch (cause) {
+      await close();
+      return failure("OPERATION_FAILED", cause);
+    } finally {
+      initializing = false;
+    }
+  }
+  async function startReplay(activeConfig) {
+    try {
+      const { record: start } = await import('@rrweb/record');
+      if (closing || config !== activeConfig)
+        return;
+      stopReplay = start({
+        maskAllInputs: true,
+        maskTextSelector: "[data-feedback-private],.rr-mask",
+        blockSelector: "[data-feedback-ignore],[data-feedback-private],.rr-block,iframe,canvas,video",
+        inlineImages: true,
+        inlineStylesheet: true,
+        collectFonts: false,
+        checkoutEveryNms: 3e4,
+        emit: (event, isCheckout) => {
+          if (isCheckout || replayChunks.length === 0)
+            replayChunks.push([]);
+          let payload;
+          try {
+            payload = sanitizeFeedbackReplay(event);
+          } catch {
+            missing.add("replay-snapshot-truncated");
+            return;
+          }
+          const safe = FeedbackEvidenceInputSchema.safeParse({ id: core.id.uuid(), source, sequence: ++sequence, kind: "replay", timestamp: Date.now(), data: { event: payload } });
+          if (!safe.success)
+            return;
+          replayChunks.at(-1)?.push(safe.data);
+          while (replayChunks.length > 2)
+            replayChunks.shift();
+          const count = replayChunks.reduce((total, chunk) => total + chunk.length, 0);
+          const bytes = new TextEncoder().encode(JSON.stringify(replayChunks)).byteLength;
+          if (count > limits().events || bytes > limits().bytes) {
+            replayChunks = [];
+            missing.add("replay-capacity-exceeded");
+          }
+        }
+      }) ?? void 0;
+    } catch {
+      if (!closing && config === activeConfig)
+        missing.add("replay-recorder-unavailable");
+    }
+  }
+  function captureKeyScreenshot() {
+    if (!config || config.screenshot === false || config.keyScreenshots === false || config.maxKeyScreenshots === 0 || keyScreenshotPromise || Date.now() - lastKeyScreenshot < (config.keyScreenshotThrottleMs ?? 1e4))
+      return keyScreenshotPromise ?? Promise.resolve();
+    const activeConfig = config;
+    lastKeyScreenshot = Date.now();
+    keyScreenshotPromise = (async () => {
+      try {
+        const bytes = await bounded(activeConfig.captureScreenshot?.() ?? captureFeedbackScreenshot(), activeConfig.screenshotTimeoutMs ?? 3e3);
+        if (closing || config !== activeConfig)
+          return;
+        if (bytes.byteLength > 5 * 1024 * 1024) {
+          missing.add("key-screenshot-size-limit-exceeded");
+          return;
+        }
+        const image = await attachment(`operation-${lastKeyScreenshot}.png`, "image/png", bytes);
+        if (closing || config !== activeConfig)
+          return;
+        keyScreenshots.push({ attachment: image, timestamp: lastKeyScreenshot });
+        keyScreenshots = keyScreenshots.filter((item) => item.timestamp >= Date.now() - limits().age).slice(-Math.min(activeConfig.maxKeyScreenshots ?? 3, 5));
+      } catch {
+        if (!closing && config === activeConfig)
+          missing.add("key-screenshot-unavailable");
+      }
+    })().finally(() => {
+      keyScreenshotPromise = void 0;
+    });
+    return keyScreenshotPromise;
+  }
+  async function doPrepare() {
+    if (!config || closing)
+      return failure("NOT_INITIALIZED");
+    const activeConfig = config;
+    if (draft?.report && !collectionFinished) {
+      if (Date.now() < deadline && afterCount < limits().after)
+        draft.missing.push("collection-ended-by-new-feedback");
+      deadline = Date.now();
+      const settled = await flush();
+      if (!settled.success)
+        return settled;
+      if (closing || config !== activeConfig)
+        return failure("NOT_INITIALIZED");
+    }
+    if (draft && !collectionFinished)
+      return ok(draft);
+    collectionFinished = false;
+    collectionSealed = false;
+    initialIds.clear();
+    uploadedIds.clear();
+    const now = Date.now();
+    buffer = buffer.filter((item) => item.timestamp >= now - limits().age);
+    bufferBytes = new TextEncoder().encode(JSON.stringify(buffer)).byteLength;
+    errorWindows = errorWindows.filter((window2) => window2.anchor.timestamp >= now - limits().age);
+    const frozenWindow = errorWindows.at(-1);
+    const anchor = frozenWindow?.anchor ?? (lastError && lastError.timestamp >= now - limits().age && buffer.some((item) => item.id === lastError?.id) ? lastError : void 0);
+    const logs = buffer.filter((item) => item.kind === "log" || item.kind === "error");
+    const anchorIndex = anchor ? logs.findIndex((item) => item.id === anchor.id) : logs.length;
+    const anchorIndexes = anchor ? logs.map((item, index) => item.kind === "error" ? index : -1).filter((index) => index >= 0).slice(-10) : [];
+    const selectedIds = /* @__PURE__ */ new Set();
+    const selected = anchor ? (errorWindows.length ? errorWindows.flatMap((window2) => window2.evidence) : anchorIndexes.flatMap((index) => logs.slice(Math.max(0, index - limits().before), index + 1 + limits().after))).filter((item) => {
+      if (selectedIds.has(item.id))
+        return false;
+      selectedIds.add(item.id);
+      return true;
+    }).sort((a, b) => a.sequence - b.sequence) : logs.slice(Math.max(0, logs.length - limits().before));
+    const other = buffer.filter((item) => item.kind !== "log" && item.kind !== "error").slice(-100);
+    if (keyScreenshotPromise)
+      await keyScreenshotPromise;
+    if (closing || config !== activeConfig)
+      return failure("NOT_INITIALIZED");
+    keyScreenshots = keyScreenshots.filter((item) => item.timestamp >= now - limits().age);
+    draft = { submissionId: core.id.uuid(), anchorTime: anchor?.timestamp ?? now, anchorKind: anchor ? "error" : "feedback", errorId: anchor?.errorId, evidence: [...selected, ...other, ...replayChunks.flat()].sort((a, b) => a.sequence - b.sequence), attachments: keyScreenshots.map((item) => item.attachment), missing: [...missing], expiresAt: now + 864e5 };
+    while (draft.evidence.length > limits().events || new TextEncoder().encode(JSON.stringify(draft.evidence)).byteLength > limits().bytes) {
+      draft.evidence.shift();
+      missing.add("browser-draft-truncated");
+    }
+    draftBytes = new TextEncoder().encode(JSON.stringify(draft.evidence)).byteLength;
+    if (dropped)
+      draft.missing.push(`browser-buffer-truncated:${dropped}`);
+    afterCount = frozenWindow?.after ?? (anchor ? Math.max(0, logs.length - anchorIndex - 1) : 0);
+    deadline = (anchor?.timestamp ?? now) + (config.afterTimeoutMs ?? 3e4);
+    record({ kind: "environment", data: { appId: config.appId, appVersion: config.appVersion, buildId: config.buildId, commit: config.commit, url: feedbackPageUrl(location.href), browser: navigator.userAgent, language: navigator.language, timezone: new Intl.DateTimeFormat().resolvedOptions().timeZone, viewport: { width: innerWidth, height: innerHeight, pixelRatio: devicePixelRatio }, online: navigator.onLine, cookies: collectFeedbackCookies(document.cookie, config.cookieAllowlist ?? []) } });
+    if (config.screenshot !== false) {
+      const current = draft;
+      try {
+        const bytes = await bounded(config.captureScreenshot?.() ?? captureFeedbackScreenshot(), config.screenshotTimeoutMs ?? 3e3);
+        if (closing || config !== activeConfig || draft !== current)
+          return failure("NOT_INITIALIZED");
+        if (bytes.byteLength > 5 * 1024 * 1024) {
+          current.missing.push("screenshot-size-limit-exceeded");
+        } else {
+          const image = await attachment("screenshot.png", "image/png", bytes);
+          if (closing || config !== activeConfig || draft !== current)
+            return failure("NOT_INITIALIZED");
+          current.attachments.push(image);
+        }
+      } catch (cause) {
+        if (closing || config !== activeConfig || draft !== current)
+          return failure("NOT_INITIALIZED");
+        current.missing.push("screenshot-unavailable");
+        if (cause instanceof Error)
+          current.missing.push(`screenshot-error:${String(sanitizeFeedbackData({ message: cause.message }).message).slice(0, 300)}`);
+      }
+    }
+    schedulePersist();
+    return ok(draft);
+  }
+  function prepare() {
+    preparePromise ??= doPrepare().finally(() => {
+      preparePromise = void 0;
+    });
+    return preparePromise;
+  }
+  async function submit(input = {}) {
+    if (!config || closing)
+      return failure("NOT_INITIALIZED");
+    const activeConfig = config;
+    const prepared = preparePromise ? await preparePromise : draft ? ok(draft) : await prepare();
+    if (!prepared.success)
+      return prepared;
+    const current = prepared.data;
+    try {
+      const fingerprint = await digestHex(new TextEncoder().encode(JSON.stringify({ description: sanitizeFeedbackData({ text: input.description ?? "" }).text, category: input.category ?? "", contact: sanitizeFeedbackData({ text: input.contact ?? "" }).text, files: (input.files ?? []).map((item) => ({ name: item.name, size: item.size, lastModified: item.lastModified })), removed: [...input.removedAttachmentIds ?? []].sort() })));
+      if (closing || config !== activeConfig || draft !== current)
+        return failure("NOT_INITIALIZED");
+      if (current.submission && current.userInputFingerprint && fingerprint !== current.userInputFingerprint)
+        return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_retryInputChanged"));
+      if (!current.submission && input.removedAttachmentIds?.length)
+        current.attachments = current.attachments.filter((item) => !input.removedAttachmentIds?.includes(item.id));
+      if (!current.submission) {
+        const added = await addFiles(input.files ?? []);
+        if (!added.success)
+          return added;
+      }
+      if (closing || config !== activeConfig || draft !== current)
+        return failure("NOT_INITIALIZED");
+      current.submission ??= FeedbackSubmitInputSchema.parse({ submissionId: current.submissionId, appId: config.appId, appVersion: config.appVersion, buildId: config.buildId, commit: config.commit, description: typeof input.description === "string" ? String(sanitizeFeedbackData({ text: input.description }).text) : void 0, category: input.category, contact: input.contact, url: feedbackPageUrl(location.href), anchor: { kind: current.anchorKind, timestamp: current.anchorTime, errorId: current.errorId }, evidence: current.evidence, attachments: current.attachments.map(({ bytes: _bytes, ...metadata }) => metadata) });
+      current.userInputFingerprint = fingerprint;
+      schedulePersist();
+      const result = await activeConfig.actions.submit(current.submission);
+      if (!result.success)
+        return result;
+      if (closing || config !== activeConfig || draft !== current)
+        return result;
+      current.report = result.data;
+      initialIds = new Set(current.submission.evidence?.map((item) => item.id));
+      schedulePersist();
+      void flush();
+      return result;
+    } catch (cause) {
+      return failure("OPERATION_FAILED", cause);
+    }
+  }
+  async function doFlush() {
+    if (!config || !draft?.report)
+      return failure("NOT_INITIALIZED");
+    if (collectionFinished)
+      return ok(void 0);
+    try {
+      for (const item of draft.attachments) {
+        if (uploadedIds.has(item.id))
+          continue;
+        const result = await config.actions.upload({ id: draft.report.id, attachmentId: item.id, dataBase64: base64(item.bytes) });
+        if (!result.success)
+          return result;
+        uploadedIds.add(item.id);
+      }
+      let drainPasses = 0;
+      while (true) {
+        if (closing || Date.now() >= deadline || afterCount >= limits().after)
+          collectionSealed = true;
+        const pending = draft.evidence.filter((item) => !initialIds.has(item.id)).slice(0, 200);
+        if (pending.length === 0)
+          break;
+        const result = await config.actions.appendEvidence({ id: draft.report.id, evidence: pending });
+        if (!result.success)
+          return result;
+        for (const id of result.data.acknowledged)
+          initialIds.add(id);
+        if (pending.some((item) => !initialIds.has(item.id)))
+          return failure();
+        drainPasses++;
+        if (drainPasses >= 20)
+          return ok(void 0);
+      }
+      if (collectionSealed) {
+        const result = await config.actions.completeCollection({ id: draft.report.id, missing: [.../* @__PURE__ */ new Set([...draft.missing, ...missing])] });
+        if (!result.success)
+          return result;
+        collectionFinished = true;
+        const updatedReport = FeedbackReportSchema.safeParse(result.data);
+        if (updatedReport.success)
+          draft.report = updatedReport.data;
+        if (config.persistDraft)
+          await deleteFeedbackDraft(storageKey);
+      }
+      schedulePersist();
+      return ok(void 0);
+    } catch (cause) {
+      return failure("OPERATION_FAILED", cause);
+    }
+  }
+  function flush() {
+    flushPromise ??= doFlush().finally(() => {
+      flushPromise = void 0;
+    });
+    return flushPromise;
+  }
+  async function annotate(id, mark) {
+    if (!draft || closing)
+      return failure("NOT_INITIALIZED");
+    const current = draft;
+    const item = current.attachments.find((value) => value.id === id);
+    if (!item || current.submission)
+      return failure("INVALID_INPUT");
+    const originalBytes = item.bytes;
+    try {
+      const bytes = await annotateFeedbackImage(originalBytes, mark);
+      const name = /\.[^.]+$/.test(item.name) ? item.name.replace(/\.[^.]+$/, ".png") : `${item.name}.png`;
+      const updated = await attachment(name, "image/png", bytes);
+      if (closing || draft !== current || current.submission || !current.attachments.includes(item) || item.bytes !== originalBytes)
+        return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_conflict"));
+      Object.assign(item, updated, { id });
+      schedulePersist();
+      return ok(void 0);
+    } catch (cause) {
+      return failure("OPERATION_FAILED", cause);
+    }
+  }
+  async function addFiles(files) {
+    if (!draft)
+      return failure("NOT_INITIALIZED");
+    if (draft.submission && files.length)
+      return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_retryInputChanged"));
+    const current = draft;
+    const items = [];
+    const newMissing = [];
+    try {
+      for (const file of files) {
+        if (items.length >= 20 || file.size > 5 * 1024 * 1024)
+          return failure("LIMIT_EXCEEDED");
+        if (!["image/png", "image/jpeg", "image/webp", "text/plain", "application/json"].includes(file.type))
+          return failure("INVALID_INPUT");
+        let bytes;
+        if (file.type.startsWith("text/") || file.type === "application/json") {
+          const raw = await file.text();
+          if (file.type === "application/json" && raw.length > 8192)
+            newMissing.push(`attachment-text-truncated:${String(sanitizeFeedbackData({ text: file.name }).text).slice(0, 100)}`);
+          bytes = file.type === "application/json" ? new TextEncoder().encode(JSON.stringify(sanitizeFeedbackData(JSON.parse(raw)))) : new TextEncoder().encode(sanitizeFeedbackText(raw));
+        } else {
+          bytes = new Uint8Array(await file.arrayBuffer());
+        }
+        if (bytes.byteLength > 5 * 1024 * 1024)
+          return failure("LIMIT_EXCEEDED");
+        const item = await attachment(file.name, file.type, bytes);
+        if (!items.some((existing) => existing.name === item.name && existing.checksum === item.checksum))
+          items.push(item);
+      }
+      if (draft !== current || closing)
+        return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_conflict"));
+      if (current.submission && files.length)
+        return err(HaiFeedbackError.CONFLICT, feedbackM("feedback_retryInputChanged"));
+      const merged = [...current.attachments];
+      for (const item of items) {
+        if (!merged.some((existing) => existing.name === item.name && existing.checksum === item.checksum))
+          merged.push(item);
+      }
+      if (merged.length > 20)
+        return failure("LIMIT_EXCEEDED");
+      current.attachments = merged;
+      current.missing.push(...newMissing);
+      schedulePersist();
+      return ok(void 0);
+    } catch (cause) {
+      return failure("INVALID_INPUT", cause);
+    }
+  }
+  async function exportDraft(input = {}) {
+    if (!draft)
+      return failure("NOT_INITIALIZED");
+    try {
+      const { createFeedbackBundle } = await import('../bundle/index.js');
+      const attachments = [...draft.attachments];
+      if (!draft.submission) {
+        const added = await addFiles(input.files ?? []);
+        if (!added.success)
+          return added;
+        attachments.splice(0, attachments.length, ...draft.attachments);
+      } else {
+        for (const file of input.files ?? []) {
+          if (attachments.length >= 20 || file.size > 5 * 1024 * 1024)
+            return failure("LIMIT_EXCEEDED");
+          if (!["image/png", "image/jpeg", "image/webp", "text/plain", "application/json"].includes(file.type))
+            return failure("INVALID_INPUT");
+          const bytes = file.type === "application/json" ? new TextEncoder().encode(JSON.stringify(sanitizeFeedbackData(JSON.parse(await file.text())))) : file.type.startsWith("text/") ? new TextEncoder().encode(sanitizeFeedbackText(await file.text())) : new Uint8Array(await file.arrayBuffer());
+          if (bytes.byteLength > 5 * 1024 * 1024)
+            return failure("LIMIT_EXCEEDED");
+          const item = await attachment(file.name, file.type, bytes);
+          if (!attachments.some((existing) => existing.name === item.name && existing.checksum === item.checksum))
+            attachments.push(item);
+        }
+      }
+      return createFeedbackBundle({ report: { ...draft.report ?? { id: draft.submissionId, appId: config?.appId, anchor: { kind: draft.anchorKind, timestamp: draft.anchorTime }, evidenceRevision: 1 }, ...sanitizeFeedbackData({ description: input.description ?? draft.report?.description ?? "", category: input.category, contact: input.contact }) }, evidence: draft.evidence, attachments: attachments.filter((item) => !input.removedAttachmentIds?.includes(item.id)), missing: [.../* @__PURE__ */ new Set([...draft.missing, ...missing, ...!draft.report ? ["server-evidence-not-obtained", "feedback-not-yet-accepted"] : []])] });
+    } catch (cause) {
+      return failure("OPERATION_FAILED", cause);
+    }
+  }
+  function close() {
+    closePromise ??= doClose().finally(() => {
+      closePromise = void 0;
+    });
+    return closePromise;
+  }
+  async function doClose() {
+    closing = true;
+    unsubscribeLogger?.();
+    unsubscribeLogger = void 0;
+    stopReplay?.();
+    stopReplay = void 0;
+    for (const cleanup of cleanups.splice(0))
+      cleanup();
+    if (flushTimer)
+      clearInterval(flushTimer);
+    if (persistTimer)
+      clearTimeout(persistTimer);
+    flushTimer = void 0;
+    persistTimer = void 0;
+    await preparePromise;
+    await keyScreenshotPromise;
+    if (draft?.report)
+      await flush();
+    if (config?.persistDraft && draft && !collectionFinished)
+      await saveFeedbackDraft(storageKey, draft).catch(() => void 0);
+    config = void 0;
+    buffer = [];
+    bufferBytes = 0;
+    draft = void 0;
+    lastError = void 0;
+    errorWindows = [];
+    replayChunks = [];
+    keyScreenshots = [];
+    lastKeyScreenshot = 0;
+    initialIds.clear();
+    uploadedIds.clear();
+    missing.clear();
+    dropped = 0;
+    collectionFinished = false;
+    collectionSealed = false;
+  }
+  return { init, prepare, submit, flush, record, getDraft: () => draft, annotate, addFiles, exportDraft, close };
+}
+var feedbackClient = createFeedbackClient();
+async function bounded(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([promise, new Promise((_resolve, reject) => {
+      timer = setTimeout(() => reject(new Error("Capture timed out")), ms);
+    })]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function attachment(name, contentType, bytes) {
+  const checksum = await digestHex(bytes);
+  return { id: core.id.uuid(), name: String(sanitizeFeedbackData({ text: name }).text).slice(0, 255), contentType, size: bytes.byteLength, checksum, bytes };
+}
+async function digestHex(bytes) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+  return [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("");
+}
+function base64(bytes) {
+  let value = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768)
+    value += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  return btoa(value);
+}
+
+export { createFeedbackClient, feedbackClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map