@tra-bilisim/report-issue 0.1.0

package/dist/chunk-5S66KGBW.js

@@ -0,0 +1,118 @@
+// src/core/videoRecorder.ts
+var DEFAULT_MAX_DURATION_MS = 15e3;
+function pickMimeType() {
+  const candidates = [
+    "video/mp4;codecs=avc1.42E01E",
+    "video/mp4",
+    "video/webm;codecs=vp8",
+    "video/webm;codecs=vp9",
+    "video/webm"
+  ];
+  return candidates.find((type) => MediaRecorder.isTypeSupported(type)) ?? "video/webm";
+}
+function createVideoRecorder(callbacks, options = {}) {
+  const maxDurationMs = options.maxDurationMs ?? DEFAULT_MAX_DURATION_MS;
+  let recorder = null;
+  let stream = null;
+  let chunks = [];
+  let timeout = null;
+  let interval = null;
+  const setRecordingState = (next) => {
+    callbacks.onStateChange?.(next);
+  };
+  const clearTimers = () => {
+    if (timeout) clearTimeout(timeout);
+    if (interval) clearInterval(interval);
+    timeout = null;
+    interval = null;
+  };
+  const cleanup = () => {
+    clearTimers();
+    stream?.getTracks().forEach((track) => track.stop());
+    stream = null;
+    recorder = null;
+    setRecordingState(false);
+    callbacks.onTick?.(0);
+  };
+  const stop = () => {
+    if (recorder && recorder.state !== "inactive") {
+      try {
+        recorder.stop();
+      } catch {
+        cleanup();
+      }
+      return;
+    }
+    cleanup();
+  };
+  const start = async () => {
+    if (!navigator.mediaDevices?.getDisplayMedia) {
+      return "unsupported";
+    }
+    try {
+      const displayOptions = {
+        video: { displaySurface: "browser", width: { max: 1280 }, height: { max: 720 }, frameRate: { max: 15 } },
+        audio: false,
+        // Offer only "This Tab"; remove the whole-screen option entirely.
+        preferCurrentTab: true,
+        monitorTypeSurfaces: "exclude"
+      };
+      const nextStream = await navigator.mediaDevices.getDisplayMedia(displayOptions);
+      const surface = nextStream.getVideoTracks()[0]?.getSettings().displaySurface;
+      if (surface && surface !== "browser") {
+        nextStream.getTracks().forEach((track) => track.stop());
+        return "wrong-surface";
+      }
+      stream = nextStream;
+      chunks = [];
+      const mimeType = pickMimeType();
+      recorder = new MediaRecorder(nextStream, { mimeType, videoBitsPerSecond: 5e5 });
+      recorder.ondataavailable = (e) => {
+        if (e.data.size > 0) chunks.push(e.data);
+      };
+      recorder.onstop = () => {
+        const blob = new Blob(chunks, { type: mimeType });
+        const ext = mimeType.includes("mp4") ? "mp4" : "webm";
+        const file = new File([blob], `recording-${Date.now()}.${ext}`, { type: mimeType });
+        callbacks.onComplete(file);
+        cleanup();
+      };
+      nextStream.getVideoTracks()[0]?.addEventListener("ended", stop);
+      recorder.start();
+      setRecordingState(true);
+      callbacks.onTick?.(0);
+      const startTime = Date.now();
+      interval = setInterval(() => {
+        callbacks.onTick?.(Math.floor((Date.now() - startTime) / 1e3));
+      }, 250);
+      timeout = setTimeout(stop, maxDurationMs);
+      return "started";
+    } catch {
+      cleanup();
+      return "denied";
+    }
+  };
+  const dispose = () => {
+    stream?.getTracks().forEach((track) => track.stop());
+    clearTimers();
+  };
+  return {
+    start,
+    stop,
+    dispose,
+    maxDurationSeconds: maxDurationMs / 1e3
+  };
+}
+
+// src/core/consent.ts
+var CONSENT_VERSION = "1.0";
+function createConsent(captureType, version = CONSENT_VERSION) {
+  return {
+    accepted: true,
+    version,
+    acceptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    captureType
+  };
+}
+
+export { CONSENT_VERSION, createConsent, createVideoRecorder };

package/dist/chunk-EXDFVVYA.js

@@ -0,0 +1,73 @@
+// src/core/reportLogs.ts
+var MAX_CONSOLE = 200;
+var MAX_NETWORK = 100;
+var consoleLogs = [];
+var networkLogs = [];
+var pendingRequests = /* @__PURE__ */ new Map();
+function safeStringify(arg) {
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+function pushConsoleLog(level, args) {
+  consoleLogs.push({ level, message: args.map(safeStringify).join(" "), ts: Date.now() });
+  if (consoleLogs.length > MAX_CONSOLE) consoleLogs.shift();
+}
+function beginNetworkRequest(trackingId, method, url) {
+  pendingRequests.set(trackingId, { trackingId, method, url, requestTs: Date.now() });
+}
+function completeNetworkRequest(trackingId, status, isError, message, errorMessage) {
+  const entry = pendingRequests.get(trackingId);
+  if (!entry) return;
+  pendingRequests.delete(trackingId);
+  networkLogs.push({
+    ...entry,
+    responseTs: Date.now(),
+    status,
+    isError,
+    message: message ?? errorMessage ?? null,
+    errorMessage,
+    duration: Date.now() - entry.requestTs
+  });
+  if (networkLogs.length > MAX_NETWORK) networkLogs.shift();
+}
+function failNetworkRequest(trackingId, status, errorMessage) {
+  const entry = pendingRequests.get(trackingId);
+  if (!entry) return;
+  pendingRequests.delete(trackingId);
+  networkLogs.push({
+    ...entry,
+    responseTs: Date.now(),
+    status,
+    isError: true,
+    message: errorMessage ?? null,
+    errorMessage,
+    duration: Date.now() - entry.requestTs
+  });
+  if (networkLogs.length > MAX_NETWORK) networkLogs.shift();
+}
+function getConsoleLogs() {
+  return [...consoleLogs];
+}
+function getNetworkLogs() {
+  return [...networkLogs];
+}
+var consolePatched = false;
+function patchConsole() {
+  if (consolePatched) return;
+  if (typeof console === "undefined") return;
+  consolePatched = true;
+  ["log", "warn", "error", "info"].forEach((level) => {
+    const original = console[level].bind(console);
+    console[level] = (...args) => {
+      original(...args);
+      pushConsoleLog(level, args);
+    };
+  });
+}
+
+export { beginNetworkRequest, completeNetworkRequest, failNetworkRequest, getConsoleLogs, getNetworkLogs, patchConsole, pushConsoleLog };

package/dist/chunk-JMQUG5Q7.js

@@ -0,0 +1,99 @@
+import { patchConsole } from './chunk-EXDFVVYA.js';
+import { createContext, forwardRef, useState, useMemo, useEffect, useContext } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var DEFAULT_MAX_FILES = 10;
+var DEFAULT_MAX_FILE_SIZE = 5 * 1024 * 1024;
+var DEFAULT_MAX_RECORDING_SECONDS = 15;
+var identityT = (key) => key;
+var defaultEnvironmentResolver = (url) => {
+  let host = url.toLowerCase();
+  try {
+    host = new URL(url, typeof window !== "undefined" ? window.location.origin : void 0).hostname.toLowerCase();
+  } catch {
+  }
+  if (host === "localhost" || host === "127.0.0.1" || host.includes("local")) return "Locale";
+  if (["test", "uat", "stage", "staging", "dev"].some((k) => host.includes(k))) return "Test";
+  return "Prod";
+};
+var noopToast = {
+  // eslint-disable-next-line no-console
+  success: (message) => console.info("[report-issue]", message),
+  // eslint-disable-next-line no-console
+  error: (message) => console.error("[report-issue]", message)
+};
+function resolveConfig(adapter) {
+  return {
+    adapter,
+    t: adapter.t ?? identityT,
+    locale: adapter.locale,
+    toast: adapter.toast ?? noopToast,
+    environmentResolver: adapter.environmentResolver ?? defaultEnvironmentResolver,
+    getCurrentUrl: adapter.getCurrentUrl ?? (() => typeof window !== "undefined" ? window.location.href : ""),
+    maxFiles: adapter.maxFiles ?? DEFAULT_MAX_FILES,
+    maxFileSizeBytes: adapter.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE,
+    maxRecordingSeconds: adapter.maxRecordingSeconds ?? DEFAULT_MAX_RECORDING_SECONDS
+  };
+}
+var ReportIssueContext = createContext(void 0);
+var ReportIssueProvider = ({ config, children }) => {
+  const [isCapturing, setIsCapturing] = useState(false);
+  const [isRecording, setIsRecording] = useState(false);
+  const [isVideoMaskEnabled, setIsVideoMaskEnabled] = useState(false);
+  const [isReportOpen, setIsReportOpen] = useState(false);
+  const resolved = useMemo(() => resolveConfig(config), [config]);
+  useEffect(() => {
+    if (config.captureConsole !== false) patchConsole();
+  }, [config.captureConsole]);
+  const captureMode = isCapturing || isRecording;
+  const value = useMemo(() => ({
+    config: resolved,
+    isCapturing,
+    setIsCapturing,
+    isRecording,
+    setIsRecording,
+    isVideoMaskEnabled,
+    setIsVideoMaskEnabled,
+    isReportOpen,
+    setIsReportOpen,
+    captureMode
+  }), [resolved, isCapturing, isRecording, isVideoMaskEnabled, isReportOpen, captureMode]);
+  return /* @__PURE__ */ jsx(ReportIssueContext.Provider, { value, children });
+};
+var useReportIssue = () => {
+  const ctx = useContext(ReportIssueContext);
+  if (!ctx) throw new Error("useReportIssue must be used within ReportIssueProvider");
+  return ctx;
+};
+var useReportIssueConfig = () => useReportIssue().config;
+
+// src/react/ui/cn.ts
+function cn(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+var Button = forwardRef(
+  ({ variant = "solid", color = "primary", size = "md", loading = false, disabled, className, children, ...rest }, ref) => /* @__PURE__ */ jsxs(
+    "button",
+    {
+      ref,
+      type: "button",
+      disabled: disabled || loading,
+      className: cn(
+        "rpi-btn",
+        variant === "outline" && "rpi-btn--outline",
+        variant !== "outline" && color === "error" && "rpi-btn--error",
+        size === "sm" && "rpi-btn--sm",
+        size === "icon" && "rpi-btn--icon",
+        className
+      ),
+      ...rest,
+      children: [
+        loading && /* @__PURE__ */ jsx("span", { className: "rpi-btn__spinner", "aria-hidden": true }),
+        children
+      ]
+    }
+  )
+);
+Button.displayName = "RpiButton";
+
+export { Button, ReportIssueProvider, cn, useReportIssue, useReportIssueConfig };

package/dist/chunk-KY2IRP36.js

@@ -0,0 +1,102 @@
+import { applyMask, applyInputMask, removeMask } from './chunk-ZYF6UFBB.js';
+import html2canvas from 'html2canvas-pro';
+
+var HIDE_DIALOG_CLASS = "report-hide-dialog";
+var waitForCaptureImages = async () => {
+  const images = Array.from(document.images).filter((img) => {
+    if (img.closest("[data-report-ignore-capture]")) return false;
+    const style = window.getComputedStyle(img);
+    return img.getClientRects().length > 0 && style.display !== "none" && style.visibility !== "hidden";
+  });
+  await Promise.all(images.map((img) => {
+    if (img.complete && img.naturalWidth > 0) {
+      return img.decode?.().catch(() => void 0) ?? Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const done = () => resolve();
+      img.addEventListener("load", done, { once: true });
+      img.addEventListener("error", done, { once: true });
+      setTimeout(done, 1e3);
+    });
+  }));
+};
+var inlineCaptureSvgImages = async () => {
+  const restores = [];
+  const svgImages = Array.from(document.images).filter((img) => {
+    if (img.closest("[data-report-ignore-capture]")) return false;
+    const src = img.currentSrc || img.src;
+    if (!src) return false;
+    try {
+      const url = new URL(src, window.location.href);
+      return url.origin === window.location.origin && url.pathname.toLowerCase().endsWith(".svg");
+    } catch {
+      return false;
+    }
+  });
+  await Promise.all(svgImages.map(async (img) => {
+    const originalSrc = img.getAttribute("src");
+    const originalSrcset = img.getAttribute("srcset");
+    const src = img.currentSrc || img.src;
+    try {
+      const response = await fetch(src);
+      if (!response.ok) return;
+      const svg = await response.text();
+      img.removeAttribute("srcset");
+      img.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+      restores.push(() => {
+        if (originalSrcset === null) img.removeAttribute("srcset");
+        else img.setAttribute("srcset", originalSrcset);
+        if (originalSrc === null) img.removeAttribute("src");
+        else img.setAttribute("src", originalSrc);
+      });
+      await img.decode?.().catch(() => void 0);
+    } catch {
+    }
+  }));
+  return () => restores.forEach((restore) => restore());
+};
+async function captureMaskedScreenshot() {
+  let restoreCaptureSvgImages = () => {
+  };
+  document.documentElement.classList.add(HIDE_DIALOG_CLASS);
+  applyMask();
+  applyInputMask();
+  await new Promise((resolve) => {
+    setTimeout(resolve, 450);
+  });
+  applyInputMask();
+  restoreCaptureSvgImages = await inlineCaptureSvgImages();
+  await waitForCaptureImages();
+  const docEl = document.documentElement;
+  const viewportWidth = docEl.clientWidth;
+  const viewportHeight = window.innerHeight;
+  const fullHeight = Math.max(docEl.scrollHeight, document.body.scrollHeight);
+  const pageScrolls = fullHeight > viewportHeight + 1;
+  const previousScrollX = window.scrollX;
+  const previousScrollY = window.scrollY;
+  if (pageScrolls) window.scrollTo(0, 0);
+  try {
+    const canvas = await html2canvas(document.body, {
+      useCORS: true,
+      scale: window.devicePixelRatio || 1,
+      width: viewportWidth,
+      height: pageScrolls ? fullHeight : viewportHeight,
+      windowWidth: viewportWidth,
+      windowHeight: pageScrolls ? fullHeight : viewportHeight,
+      ignoreElements: (el) => el.hasAttribute?.("data-report-ignore-capture") || el.getAttribute?.("data-slot") === "dialog-overlay",
+      // onclone runs after the DOM is cloned but before rendering. React cannot
+      // reset values in the clone, so masking is reliable here.
+      onclone: (clonedDoc) => {
+        applyInputMask(clonedDoc);
+      }
+    });
+    return canvas.toDataURL("image/png");
+  } finally {
+    if (pageScrolls) window.scrollTo(previousScrollX, previousScrollY);
+    restoreCaptureSvgImages();
+    removeMask();
+    document.documentElement.classList.remove(HIDE_DIALOG_CLASS);
+  }
+}
+
+export { captureMaskedScreenshot };

package/dist/chunk-ZYF6UFBB.js

@@ -0,0 +1,162 @@
+// src/core/reportMask.ts
+var MASK_CHAR = "\u25CF";
+var MASK_LENGTH = 6;
+var MASK_PLACEHOLDER = MASK_CHAR.repeat(MASK_LENGTH);
+var VIDEO_STYLE_ID = "report-mask-video-style";
+var MEDIA_TAGS = /* @__PURE__ */ new Set(["IMG", "PICTURE", "SVG", "CANVAS", "VIDEO"]);
+var MASK_IGNORE_SELECTOR = "[data-report-mask-ignore], [data-sonner-toaster], [data-sonner-toast]";
+var TEXT_MASK_IGNORE_SELECTOR = "[data-report-mask-text-ignore]";
+var FORCE_TEXT_MASK_SELECTOR = "[data-report-mask-control], [data-report-mask-value]";
+var IGNORED_INPUT_TYPES = /* @__PURE__ */ new Set(["hidden", "checkbox", "radio", "file", "button", "submit", "reset", "image", "range", "color", "password"]);
+var maskedTextNodes = /* @__PURE__ */ new Map();
+function isInputElement(el) {
+  return el.tagName === "INPUT";
+}
+function isTextareaElement(el) {
+  return el.tagName === "TEXTAREA";
+}
+function isFormField(el) {
+  return isInputElement(el) || isTextareaElement(el);
+}
+function hasIgnoreAncestor(node) {
+  let cur = node.parentNode;
+  while (cur && cur !== document.body) {
+    if (cur instanceof HTMLElement && cur.matches(MASK_IGNORE_SELECTOR)) return true;
+    cur = cur.parentNode;
+  }
+  return false;
+}
+function hasTextMaskIgnoreAncestor(node) {
+  let cur = node.parentNode;
+  while (cur && cur !== document.body) {
+    if (cur instanceof HTMLElement && cur.matches(TEXT_MASK_IGNORE_SELECTOR)) return true;
+    cur = cur.parentNode;
+  }
+  return false;
+}
+function hasForceTextMaskAncestor(node) {
+  let cur = node.parentNode;
+  while (cur && cur !== document.body) {
+    if (cur instanceof HTMLElement && cur.matches(FORCE_TEXT_MASK_SELECTOR)) return true;
+    cur = cur.parentNode;
+  }
+  return false;
+}
+function hasCaptureIgnoreAncestor(el) {
+  let cur = el.parentElement;
+  while (cur && cur !== document.body) {
+    if (cur.hasAttribute("data-report-ignore-capture")) return true;
+    cur = cur.parentElement;
+  }
+  return false;
+}
+function hasMediaAncestor(node) {
+  let cur = node.parentNode;
+  while (cur && cur !== document.body) {
+    if (cur instanceof Element && MEDIA_TAGS.has(cur.tagName)) return true;
+    cur = cur.parentNode;
+  }
+  return false;
+}
+function applyInputMask(targetDoc = document) {
+  const trackForRestore = targetDoc === document;
+  targetDoc.querySelectorAll("input, textarea").forEach((el) => {
+    if (hasIgnoreAncestor(el)) return;
+    if (hasCaptureIgnoreAncestor(el)) return;
+    if (isInputElement(el)) {
+      if (IGNORED_INPUT_TYPES.has(el.type)) return;
+      if (!el.value.trim()) return;
+      if (trackForRestore && el.dataset.reportOriginalValue === void 0) el.dataset.reportOriginalValue = el.value;
+      if (el.type === "number") {
+        if (trackForRestore) el.dataset.reportOriginalType = "number";
+        el.type = "text";
+      }
+      el.value = MASK_PLACEHOLDER;
+    } else if (isTextareaElement(el)) {
+      if (!el.value.trim()) return;
+      if (trackForRestore && el.dataset.reportOriginalValue === void 0) el.dataset.reportOriginalValue = el.value;
+      el.value = MASK_PLACEHOLDER;
+    }
+  });
+}
+function applyMask() {
+  const walker = document.createTreeWalker(
+    document.body,
+    NodeFilter.SHOW_TEXT,
+    {
+      acceptNode(node2) {
+        const parent = node2.parentElement;
+        if (!parent) return NodeFilter.FILTER_REJECT;
+        const tag = parent.tagName;
+        if (tag === "SCRIPT" || tag === "STYLE" || tag === "NOSCRIPT") return NodeFilter.FILTER_REJECT;
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    }
+  );
+  let node = walker.nextNode();
+  while (node) {
+    const original = node.nodeValue ?? "";
+    const shouldMask = original.trim() && !hasIgnoreAncestor(node) && (hasForceTextMaskAncestor(node) || !hasTextMaskIgnoreAncestor(node)) && !hasMediaAncestor(node);
+    if (shouldMask) {
+      if (maskedTextNodes.has(node)) {
+        if (original !== MASK_PLACEHOLDER) {
+          maskedTextNodes.set(node, original);
+          node.nodeValue = MASK_PLACEHOLDER;
+        }
+      } else {
+        maskedTextNodes.set(node, original);
+        node.nodeValue = MASK_PLACEHOLDER;
+      }
+    }
+    node = walker.nextNode();
+  }
+}
+function removeMask() {
+  document.querySelectorAll("[data-report-original-value]").forEach((el) => {
+    const original = el.dataset.reportOriginalValue ?? "";
+    if (isInputElement(el) && el.dataset.reportOriginalType) {
+      el.type = el.dataset.reportOriginalType;
+      delete el.dataset.reportOriginalType;
+    }
+    if (isFormField(el)) el.value = original;
+    delete el.dataset.reportOriginalValue;
+  });
+  maskedTextNodes.forEach((original, node) => {
+    node.nodeValue = original;
+  });
+  maskedTextNodes.clear();
+}
+var videoMaskObserver = null;
+function toggleVideoMask(enable) {
+  if (enable) {
+    if (!document.getElementById(VIDEO_STYLE_ID)) {
+      const style = document.createElement("style");
+      style.id = VIDEO_STYLE_ID;
+      style.textContent = `
+        .report-video-mask input:not([data-report-mask-ignore]),
+        .report-video-mask textarea:not([data-report-mask-ignore]) {
+          -webkit-text-security: disc !important;
+        }
+      `;
+      document.head.appendChild(style);
+    }
+    document.documentElement.classList.add("report-video-mask");
+    applyMask();
+    if (!videoMaskObserver) {
+      videoMaskObserver = new MutationObserver(() => {
+        applyMask();
+      });
+      videoMaskObserver.observe(document.body, { childList: true, subtree: true, characterData: true });
+    }
+  } else {
+    if (videoMaskObserver) {
+      videoMaskObserver.disconnect();
+      videoMaskObserver = null;
+    }
+    document.documentElement.classList.remove("report-video-mask");
+    document.getElementById(VIDEO_STYLE_ID)?.remove();
+    removeMask();
+  }
+}
+
+export { applyInputMask, applyMask, removeMask, toggleVideoMask };

package/dist/consent-DmS4DxOf.d.ts

@@ -0,0 +1,135 @@
+interface ConsoleEntry {
+    level: 'log' | 'warn' | 'error' | 'info';
+    message: string;
+    ts: number;
+}
+interface NetworkEntry {
+    trackingId: string;
+    method?: string;
+    url?: string;
+    requestTs: number;
+    responseTs?: number;
+    status?: number;
+    isError?: boolean;
+    duration?: number;
+    message?: string | null;
+    errorMessage?: string;
+}
+type CaptureType = 'video' | 'screenshot';
+interface RecordingConsent {
+    accepted: true;
+    version: string;
+    acceptedAt: string;
+    captureType: CaptureType;
+}
+interface ReportCategoryOption {
+    label: string;
+    value: number;
+}
+interface PageOption {
+    value: string;
+    label: string;
+}
+interface ReportMetadata {
+    userId?: string | number | null;
+    userName?: string | null;
+    email?: string | null;
+    roles?: string[];
+    userAgent?: string;
+    screenResolution?: string;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/** Structured payload handed to the host `submit` adapter. */
+interface ReportSubmitPayload {
+    files: File[];
+    page: string;
+    environment: string;
+    categoryId?: number | null;
+    description?: string | null;
+    consoleLogs: ConsoleEntry[];
+    networkLogs: NetworkEntry[];
+    recordingConsent?: RecordingConsent | null;
+    screenshotConsent?: RecordingConsent | null;
+    metadata: ReportMetadata;
+}
+interface ReportSubmitResult {
+    ok: boolean;
+    message?: string | null;
+}
+interface ReportIssueToast {
+    success: (message: string) => void;
+    error: (message: string) => void;
+}
+/**
+ * The single injection point that removes all host coupling. A consumer supplies
+ * how to submit, how to resolve categories/metadata/current page, how to translate,
+ * and how to toast. Everything except `submit` has a sensible default.
+ */
+interface ReportIssueAdapter {
+    /**
+     * Persist a report. Receives both the structured payload and a ready-to-send
+     * multipart `FormData` (the canonical wire contract — see README).
+     */
+    submit: (payload: ReportSubmitPayload, formData: FormData) => Promise<ReportSubmitResult>;
+    /** Category dropdown options. Omit to hide the category field. */
+    getCategories?: () => Promise<ReportCategoryOption[]> | ReportCategoryOption[];
+    /** Session metadata attached to every report. */
+    getMetadata?: () => ReportMetadata | Promise<ReportMetadata>;
+    /** Absolute URL of the page the user is on. Defaults to `window.location.href`. */
+    getCurrentUrl?: () => string;
+    /** Options for the "which page" dropdown. Function form is re-read on open. */
+    pageOptions?: PageOption[] | (() => PageOption[]);
+    /** Maps a page URL to an environment label (e.g. Locale/Test/Prod). */
+    environmentResolver?: (url: string) => string;
+    /** i18n. Defaults to identity (returns the key, which is English text). */
+    t?: (key: string, options?: Record<string, unknown>) => string;
+    locale?: string;
+    /** Toast sink. Defaults to `console`-based no-op-ish behaviour. */
+    toast?: ReportIssueToast;
+    /** Limits. */
+    maxFiles?: number;
+    maxFileSizeBytes?: number;
+    maxRecordingSeconds?: number;
+    /** Patch `console.*` to capture logs when the provider mounts. Default true. */
+    captureConsole?: boolean;
+}
+
+declare function pushConsoleLog(level: ConsoleEntry['level'], args: unknown[]): void;
+declare function beginNetworkRequest(trackingId: string, method?: string, url?: string): void;
+declare function completeNetworkRequest(trackingId: string, status?: number, isError?: boolean, message?: string, errorMessage?: string): void;
+declare function failNetworkRequest(trackingId: string, status?: number, errorMessage?: string): void;
+declare function getConsoleLogs(): ConsoleEntry[];
+declare function getNetworkLogs(): NetworkEntry[];
+/**
+ * Wraps `console.log/warn/error/info` so early logs are captured. Idempotent.
+ * This is an explicit opt-in call (invoked by the provider) rather than an
+ * import-time side effect, so importing the package never mutates globals.
+ */
+declare function patchConsole(): void;
+
+type RecorderStartResult = 'started' | 'unsupported' | 'wrong-surface' | 'denied';
+interface VideoRecorderCallbacks {
+    onComplete: (file: File) => void;
+    onStateChange?: (isRecording: boolean) => void;
+    onTick?: (elapsedSeconds: number) => void;
+}
+interface VideoRecorderController {
+    start: () => Promise<RecorderStartResult>;
+    stop: () => void;
+    /** Stop tracks/timers without firing onComplete. Call on unmount. */
+    dispose: () => void;
+    readonly maxDurationSeconds: number;
+}
+/**
+ * Framework-agnostic screen recorder restricted to the current browser tab.
+ * Enforces "this tab only" and a hard max duration. No React inside.
+ */
+declare function createVideoRecorder(callbacks: VideoRecorderCallbacks, options?: {
+    maxDurationMs?: number;
+}): VideoRecorderController;
+
+declare const CONSENT_VERSION = "1.0";
+declare function createConsent(captureType: CaptureType, version?: string): RecordingConsent;
+
+export { CONSENT_VERSION as C, type NetworkEntry as N, type PageOption as P, type RecorderStartResult as R, type VideoRecorderCallbacks as V, type CaptureType as a, type ConsoleEntry as b, type RecordingConsent as c, type ReportCategoryOption as d, type ReportIssueAdapter as e, type ReportIssueToast as f, type ReportMetadata as g, type ReportSubmitPayload as h, type ReportSubmitResult as i, type VideoRecorderController as j, beginNetworkRequest as k, completeNetworkRequest as l, createConsent as m, createVideoRecorder as n, failNetworkRequest as o, getConsoleLogs as p, getNetworkLogs as q, patchConsole as r, pushConsoleLog as s };