@allstak/react-native 0.3.4 → 0.4.1

package/dist/index.mjs

@@ -29,6 +29,58 @@ var HttpTransport = class {
     this.enqueueOrDispatch({ path, payload });
     return Promise.resolve();
   }
+  /**
+   * One-shot POST that resolves with the parsed JSON response body. Used
+   * by `captureException` to retrieve the server-assigned event id so
+   * follow-up attachment uploads can be linked.
+   *
+   * Fail-open: returns `null` on any error (network, non-2xx, parse).
+   * Respects {@link timeoutMs} via `AbortController`. Bounded retries.
+   */
+  async sendAndRead(path, payload, options = {}) {
+    if (!this.enabled) return null;
+    const timeoutMs = options.timeoutMs ?? 5e3;
+    const retries = Math.max(0, options.retries ?? 1);
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= retries) {
+      try {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const res = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-AllStak-Key": this.apiKey
+            },
+            body: JSON.stringify(payload),
+            signal: controller.signal
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          const text = await res.text();
+          if (!text) return null;
+          try {
+            return JSON.parse(text);
+          } catch {
+            return null;
+          }
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      } catch (err) {
+        lastError = err;
+        attempt += 1;
+        if (attempt > retries) break;
+        await new Promise((r) => setTimeout(r, 200 * attempt));
+      }
+    }
+    if (lastError && typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn("[AllStak] sendAndRead failed:", lastError?.message);
+    }
+    return null;
+  }
   enqueueOrDispatch(item) {
     if (Date.now() < this.circuitOpenUntil) {
       this.push(item);
@@ -1383,10 +1435,358 @@ function unbindHttpInstrumentation() {
   _currentRuntime = null;
 }
 
+// src/runtime.ts
+var cached = null;
+function detectRuntimeMode() {
+  if (cached) return cached;
+  cached = computeRuntimeMode();
+  return cached;
+}
+function __resetRuntimeModeForTest() {
+  cached = null;
+}
+function computeRuntimeMode() {
+  try {
+    const Constants = require("expo-constants");
+    const appOwnership = Constants?.default?.appOwnership ?? Constants?.appOwnership;
+    if (appOwnership === "expo") return "expo-go";
+    if (appOwnership === "standalone" || appOwnership === "guest") return "expo-dev-client";
+    const exec = Constants?.default?.executionEnvironment ?? Constants?.executionEnvironment;
+    if (exec === "storeClient") return "expo-go";
+    if (exec === "standalone" || exec === "bare") return "expo-dev-client";
+  } catch {
+  }
+  try {
+    require("expo");
+    return "expo-dev-client";
+  } catch {
+  }
+  try {
+    require("react-native");
+    return "rn-cli";
+  } catch {
+  }
+  return "unknown";
+}
+function runtimeAllowsScreenshot(mode = detectRuntimeMode()) {
+  if (mode === "expo-go") return false;
+  return true;
+}
+function tryRequire(id2) {
+  try {
+    return require(id2);
+  } catch {
+    return null;
+  }
+}
+
+// src/privacy.tsx
+import * as React from "react";
+function getRN() {
+  return tryRequire("react-native");
+}
+var state = {
+  isCapturing: false,
+  sensitiveRefs: /* @__PURE__ */ new Set()
+};
+var listeners = /* @__PURE__ */ new Set();
+function __setCapturing(value) {
+  if (state.isCapturing === value) return;
+  state.isCapturing = value;
+  for (const fn of listeners) {
+    try {
+      fn(value);
+    } catch {
+    }
+  }
+}
+function __resetPrivacyStateForTest() {
+  state.isCapturing = false;
+  state.sensitiveRefs.clear();
+  listeners.clear();
+}
+function isCapturingScreenshot() {
+  return state.isCapturing;
+}
+function sensitiveRefCount() {
+  return state.sensitiveRefs.size;
+}
+function registerSensitiveRef(ref) {
+  state.sensitiveRefs.add(ref);
+  return () => {
+    state.sensitiveRefs.delete(ref);
+  };
+}
+function useIsCapturing() {
+  const [val, setVal] = React.useState(state.isCapturing);
+  React.useEffect(() => {
+    const fn = (v) => setVal(v);
+    listeners.add(fn);
+    return () => {
+      listeners.delete(fn);
+    };
+  }, []);
+  return val;
+}
+function useAllStakPrivacy() {
+  const isCapturing = useIsCapturing();
+  return { isCapturing, registerSensitiveRef };
+}
+function getView() {
+  const RN = getRN();
+  return RN?.View ?? ((props) => React.createElement(React.Fragment, null, props.children));
+}
+function getText() {
+  const RN = getRN();
+  return RN?.Text ?? ((props) => React.createElement(React.Fragment, null, props.children));
+}
+function getTextInput() {
+  const RN = getRN();
+  return RN?.TextInput ?? ((props) => React.createElement(React.Fragment, null, null));
+}
+var DEFAULT_MASK_COLOR = "#d8dde7";
+var DEFAULT_MASK_LABEL = "\u2022\u2022\u2022\u2022\u2022\u2022";
+function AllStakMaskedView({
+  children,
+  maskLabel = DEFAULT_MASK_LABEL,
+  maskColor = DEFAULT_MASK_COLOR,
+  hideScreenshot = false,
+  privacy = "mask",
+  style,
+  ...rest
+}) {
+  const isCapturing = useIsCapturing();
+  const View = getView();
+  const Text = getText();
+  if (!isCapturing || privacy === "show") {
+    return React.createElement(View, { style, ...rest }, children);
+  }
+  if (privacy === "hide" || hideScreenshot) {
+    return React.createElement(View, { style: [{ backgroundColor: maskColor }, style], ...rest });
+  }
+  return React.createElement(
+    View,
+    { style: [{ backgroundColor: maskColor, alignItems: "center", justifyContent: "center" }, style], ...rest },
+    React.createElement(Text, { style: { color: "#3f4652", fontSize: 12 } }, maskLabel)
+  );
+}
+function AllStakPrivacyView(props) {
+  return React.createElement(AllStakMaskedView, { hideScreenshot: true, ...props });
+}
+function AllStakTextInput({
+  privacy = "mask",
+  style,
+  maskColor = DEFAULT_MASK_COLOR,
+  ...rest
+}) {
+  const isCapturing = useIsCapturing();
+  const View = getView();
+  const TextInput = getTextInput();
+  if (isCapturing && privacy !== "show") {
+    return React.createElement(View, {
+      style: [{ minHeight: 40, backgroundColor: maskColor, borderRadius: 4 }, style]
+    });
+  }
+  return React.createElement(TextInput, { style, ...rest });
+}
+function AllStakSensitiveText({
+  children,
+  privacy = "mask",
+  style,
+  maskLabel = DEFAULT_MASK_LABEL,
+  ...rest
+}) {
+  const isCapturing = useIsCapturing();
+  const Text = getText();
+  if (isCapturing && privacy !== "show") {
+    return React.createElement(Text, { style, ...rest }, maskLabel);
+  }
+  return React.createElement(Text, { style, ...rest }, children);
+}
+
+// src/screenshot.ts
+var DEFAULT_SCREENSHOT_CONFIG = {
+  captureScreenshotOnError: false,
+  screenshotRedaction: "strict",
+  screenshotMaskStyle: "solid",
+  screenshotMaxBytes: 5e5,
+  screenshotQuality: 0.7,
+  screenshotFormat: "jpg",
+  screenshotSampleRate: 1,
+  screenshotOnUnhandledOnly: true,
+  screenshotUploadTimeoutMs: 8e3,
+  screenshotCaptureTimeoutMs: 2e3,
+  screenshotNativeMode: "auto",
+  screenshotFailPolicy: "send-event-only"
+};
+function resolveScreenshotConfig(partial) {
+  const c = { ...DEFAULT_SCREENSHOT_CONFIG, ...partial ?? {} };
+  c.screenshotMaxBytes = clamp(c.screenshotMaxBytes, 1024, 5e6);
+  c.screenshotQuality = clamp(c.screenshotQuality, 0, 1);
+  c.screenshotSampleRate = clamp(c.screenshotSampleRate, 0, 1);
+  c.screenshotUploadTimeoutMs = clamp(c.screenshotUploadTimeoutMs, 500, 6e4);
+  c.screenshotCaptureTimeoutMs = clamp(c.screenshotCaptureTimeoutMs, 100, 3e4);
+  return c;
+}
+function clamp(n, lo, hi) {
+  if (typeof n !== "number" || !Number.isFinite(n)) return lo;
+  return Math.max(lo, Math.min(hi, n));
+}
+var rootViewRef = null;
+function __setRootViewRef(ref) {
+  rootViewRef = ref;
+}
+var warnedAboutBothApis = false;
+function warnIfBothApisPresent(callbackPresent, flatPresent) {
+  if (!callbackPresent || !flatPresent || warnedAboutBothApis) return;
+  warnedAboutBothApis = true;
+  console.warn(
+    "[AllStak] Both `screenshot.provider` (deprecated) and the flat `captureScreenshotOnError` API are configured. The flat API takes precedence. Remove `screenshot.provider` to silence this warning."
+  );
+}
+function isViewShotAvailable() {
+  return tryRequire("react-native-view-shot") !== null;
+}
+async function captureViaViewShot(config) {
+  if (config.screenshotNativeMode === "disabled") return null;
+  const viewShot = tryRequire("react-native-view-shot");
+  if (!viewShot) return null;
+  const captureRef = viewShot.captureRef ?? viewShot.default?.captureRef;
+  if (typeof captureRef !== "function") return null;
+  const refTarget = rootViewRef?.current;
+  if (!refTarget) return null;
+  const format = config.screenshotFormat === "jpg" ? "jpg" : config.screenshotFormat;
+  const dimensions = readDimensions();
+  __setCapturing(true);
+  await new Promise((r) => setTimeout(r, 16));
+  try {
+    const captured = await Promise.race([
+      Promise.resolve(captureRef(refTarget, {
+        format,
+        quality: config.screenshotQuality,
+        result: "base64"
+      })),
+      new Promise((resolve) => setTimeout(() => resolve(null), config.screenshotCaptureTimeoutMs))
+    ]);
+    if (!captured || typeof captured !== "string") return null;
+    const sizeBytes = estimateBase64Size(captured);
+    if (sizeBytes > config.screenshotMaxBytes) {
+      if (__DEV__) {
+        console.warn(`[AllStak] Screenshot ${sizeBytes}B exceeds limit ${config.screenshotMaxBytes}B; dropping.`);
+      }
+      return null;
+    }
+    const contentType = format === "png" ? "image/png" : format === "webp" ? "image/webp" : "image/jpeg";
+    return {
+      dataBase64: captured,
+      contentType,
+      width: dimensions.width,
+      height: dimensions.height,
+      sizeBytes
+    };
+  } catch (err) {
+    if (__DEV__) {
+      console.warn("[AllStak] view-shot capture failed:", err?.message);
+    }
+    return null;
+  } finally {
+    __setCapturing(false);
+  }
+}
+function estimateBase64Size(base64) {
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(base64.length * 3 / 4) - padding;
+}
+function readDimensions() {
+  try {
+    const RN = tryRequire("react-native");
+    const dims = RN?.Dimensions?.get?.("window");
+    if (dims && typeof dims.width === "number" && typeof dims.height === "number") {
+      return { width: Math.round(dims.width), height: Math.round(dims.height) };
+    }
+  } catch {
+  }
+  return { width: 0, height: 0 };
+}
+async function maybeCaptureScreenshot(config, ctx) {
+  try {
+    if (!config.captureScreenshotOnError) return null;
+    if (config.screenshotOnUnhandledOnly && ctx.unhandled === false) return null;
+    if (config.screenshotSampleRate < 1 && Math.random() >= config.screenshotSampleRate) return null;
+    if (!runtimeAllowsScreenshot(ctx.runtimeMode)) return null;
+    if (config.isScreenshotAllowed) {
+      try {
+        const allowed = await config.isScreenshotAllowed(ctx);
+        if (!allowed) return null;
+      } catch {
+        return null;
+      }
+    }
+    if (config.beforeScreenshotCapture) {
+      try {
+        const cont = await config.beforeScreenshotCapture(ctx);
+        if (!cont) return null;
+      } catch {
+        return null;
+      }
+    }
+    const upload = await captureViaViewShot(config);
+    if (!upload) return null;
+    const metadata = {
+      captureMethod: "react-native-view-shot",
+      redactionMode: config.screenshotRedaction,
+      maskStyle: config.screenshotMaskStyle,
+      format: config.screenshotFormat,
+      width: upload.width,
+      height: upload.height,
+      sizeBytes: upload.sizeBytes,
+      privacyComponentsDetected: sensitiveRefCount(),
+      runtimeMode: ctx.runtimeMode
+    };
+    if (config.beforeScreenshotUpload) {
+      try {
+        const filtered = await config.beforeScreenshotUpload(upload, metadata);
+        if (!filtered) return null;
+        return { upload: filtered, metadata };
+      } catch {
+        return null;
+      }
+    }
+    return { upload, metadata };
+  } catch (err) {
+    if (__DEV__) {
+      console.warn("[AllStak] maybeCaptureScreenshot fail-open:", err?.message);
+    }
+    return null;
+  }
+}
+function pickScreenshotConfig(source) {
+  const out = {};
+  const pick = (key) => {
+    if (source[key] !== void 0) out[key] = source[key];
+  };
+  pick("captureScreenshotOnError");
+  pick("screenshotRedaction");
+  pick("screenshotMaskStyle");
+  pick("screenshotMaxBytes");
+  pick("screenshotQuality");
+  pick("screenshotFormat");
+  pick("screenshotSampleRate");
+  pick("screenshotOnUnhandledOnly");
+  pick("screenshotUploadTimeoutMs");
+  pick("screenshotCaptureTimeoutMs");
+  pick("screenshotNativeMode");
+  pick("screenshotFailPolicy");
+  pick("beforeScreenshotCapture");
+  pick("beforeScreenshotUpload");
+  pick("isScreenshotAllowed");
+  return out;
+}
+
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
 var SDK_NAME = "allstak-react-native";
-var SDK_VERSION = "0.3.4";
+var SDK_VERSION = "0.4.1";
 var ERRORS_PATH = "/ingest/v1/errors";
 var LOGS_PATH = "/ingest/v1/logs";
 var VALID_BREADCRUMB_TYPES = /* @__PURE__ */ new Set(["http", "log", "ui", "navigation", "query", "default"]);
@@ -1565,6 +1965,18 @@ var AllStakClient = class {
       breadcrumbs: currentBreadcrumbs,
       fingerprint: eff.fingerprint
     };
+    const flatPresent = this.config.captureScreenshotOnError === true;
+    const callbackPresent = Boolean(this.config.screenshot?.provider);
+    warnIfBothApisPresent(callbackPresent, flatPresent);
+    if (flatPresent) {
+      void this.runFlatScreenshotPipeline(error, payload).catch(() => {
+        void this.sendThroughBeforeSend({
+          ...payload,
+          metadata: { ...payload.metadata ?? {}, "screenshot.status": "failed" }
+        });
+      });
+      return;
+    }
     if (this.shouldCaptureScreenshot()) {
       void this.withScreenshotMetadata(error, payload).then((enriched) => this.sendThroughBeforeSend(enriched)).catch(() => this.sendThroughBeforeSend({
         ...payload,
@@ -1580,6 +1992,86 @@ var AllStakClient = class {
       }
     });
   }
+  /**
+   * Flat screenshot API path. Capture first (so masking primitives can
+   * swap), send the event with a `screenshot.status` metadata tag, read
+   * back the server-assigned errorId, then upload the attachment.
+   *
+   * Fail-open at every step.
+   */
+  async runFlatScreenshotPipeline(error, payload) {
+    const sc = resolveScreenshotConfig(pickScreenshotConfig(this.config));
+    const runtimeMode = detectRuntimeMode();
+    const ctx = { error, unhandled: true, runtimeMode };
+    let captured = null;
+    try {
+      captured = await maybeCaptureScreenshot(sc, ctx);
+    } catch {
+      captured = null;
+    }
+    const status = !sc.captureScreenshotOnError ? "disabled" : captured ? "captured" : runtimeMode === "expo-go" ? "unsupported_runtime" : "unavailable";
+    const eventPayload = {
+      ...payload,
+      metadata: {
+        ...payload.metadata ?? {},
+        "screenshot.status": status,
+        "screenshot.runtimeMode": runtimeMode,
+        ...captured ? {
+          "screenshot.contentType": captured.upload.contentType,
+          "screenshot.width": captured.upload.width,
+          "screenshot.height": captured.upload.height,
+          "screenshot.sizeBytes": captured.upload.sizeBytes,
+          "screenshot.redactionMode": captured.metadata.redactionMode,
+          "screenshot.maskStyle": captured.metadata.maskStyle,
+          "screenshot.captureMethod": captured.metadata.captureMethod
+        } : {}
+      }
+    };
+    let finalPayload = eventPayload;
+    if (this.config.beforeSend) {
+      try {
+        finalPayload = await this.config.beforeSend(eventPayload);
+      } catch {
+        finalPayload = eventPayload;
+      }
+    }
+    if (!finalPayload) return;
+    let eventId = null;
+    try {
+      const resp = await this.transport.sendAndRead(
+        ERRORS_PATH,
+        finalPayload,
+        { timeoutMs: 5e3, retries: 1 }
+      );
+      eventId = resp?.data?.id ?? resp?.id ?? null;
+    } catch {
+    }
+    if (!captured || !eventId) return;
+    try {
+      await this.transport.sendAndRead(
+        `/ingest/v1/errors/${encodeURIComponent(eventId)}/attachments`,
+        {
+          kind: "screenshot",
+          contentType: captured.upload.contentType,
+          dataBase64: captured.upload.dataBase64,
+          width: captured.upload.width,
+          height: captured.upload.height,
+          redactionMode: captured.metadata.redactionMode,
+          captureMethod: captured.metadata.captureMethod,
+          sizeBytes: captured.upload.sizeBytes,
+          metadata: {
+            maskStyle: captured.metadata.maskStyle,
+            format: captured.metadata.format,
+            runtimeMode: captured.metadata.runtimeMode,
+            privacyComponentsDetected: captured.metadata.privacyComponentsDetected ?? 0,
+            sdkVersion: SDK_VERSION
+          }
+        },
+        { timeoutMs: sc.screenshotUploadTimeoutMs, retries: 2 }
+      );
+    } catch {
+    }
+  }
   /** Start a new span. Auto-parented to any currently-active span. */
   startSpan(operation, options) {
     return this.tracing.startSpan(operation, options);
@@ -2104,7 +2596,7 @@ function byteSize(value) {
 }
 
 // src/provider.tsx
-import * as React from "react";
+import * as React2 from "react";
 
 // src/auto-breadcrumbs.ts
 var FETCH_FLAG2 = "__allstak_fetch_patched__";
@@ -2341,17 +2833,17 @@ function tryAutoInstrumentNavigation() {
     const rnav = require("@react-navigation/native");
     if (!rnav || !rnav.NavigationContainer) return false;
     if (rnav[NAV_AUTO_PATCH_FLAG]) return true;
-    const React2 = require("react");
-    if (!React2 || typeof React2.forwardRef !== "function") return false;
+    const React3 = require("react");
+    if (!React3 || typeof React3.forwardRef !== "function") return false;
     const OrigContainer = rnav.NavigationContainer;
-    const Wrapped = React2.forwardRef(function AllStakNavigationContainer(props, userRef) {
-      const internalRef = React2.useRef(null);
-      const setRef = React2.useCallback((r) => {
+    const Wrapped = React3.forwardRef(function AllStakNavigationContainer(props, userRef) {
+      const internalRef = React3.useRef(null);
+      const setRef = React3.useCallback((r) => {
         internalRef.current = r;
         if (typeof userRef === "function") userRef(r);
         else if (userRef) userRef.current = r;
       }, [userRef]);
-      React2.useEffect(() => {
+      React3.useEffect(() => {
         if (internalRef.current) {
           try {
             instrumentReactNavigation(internalRef.current);
@@ -2359,7 +2851,7 @@ function tryAutoInstrumentNavigation() {
           }
         }
       }, []);
-      return React2.createElement(OrigContainer, { ...props, ref: setRef });
+      return React3.createElement(OrigContainer, { ...props, ref: setRef });
     });
     Wrapped.displayName = "AllStakNavigationContainer";
     try {
@@ -2589,9 +3081,16 @@ function installReactNative(options = {}) {
 }
 
 // src/provider.tsx
-var AllStakContext = React.createContext(null);
+function getRN2() {
+  return tryRequire("react-native");
+}
+function getRootView() {
+  const RN = getRN2();
+  return RN?.View;
+}
+var AllStakContext = React2.createContext(null);
 var __providerOwnedInstance = null;
-var AllStakErrorBoundary = class extends React.Component {
+var AllStakErrorBoundary = class extends React2.Component {
   constructor() {
     super(...arguments);
     this.state = { error: null };
@@ -2659,9 +3158,31 @@ function AllStakProvider({
   autoNetworkCapture,
   autoFetchBreadcrumbs,
   autoConsoleBreadcrumbs,
-  autoNavigationBreadcrumbs
+  autoNavigationBreadcrumbs,
+  captureScreenshotOnError,
+  screenshotRedaction,
+  screenshotMaskStyle,
+  screenshotMaxBytes,
+  screenshotQuality,
+  screenshotFormat,
+  screenshotSampleRate,
+  screenshotOnUnhandledOnly,
+  screenshotUploadTimeoutMs,
+  screenshotCaptureTimeoutMs,
+  screenshotNativeMode,
+  screenshotFailPolicy,
+  beforeScreenshotCapture,
+  beforeScreenshotUpload,
+  isScreenshotAllowed
 }) {
-  const clientRef = React.useRef(null);
+  const clientRef = React2.useRef(null);
+  const rootRef = React2.useRef(null);
+  React2.useEffect(() => {
+    __setRootViewRef(rootRef);
+    return () => {
+      __setRootViewRef(null);
+    };
+  }, []);
   if (!clientRef.current) {
     const existing = AllStak._getInstance();
     if (existing && __providerOwnedInstance === existing) {
@@ -2685,7 +3206,22 @@ function AllStakProvider({
         replay,
         tracesSampleRate,
         service,
-        dist
+        dist,
+        captureScreenshotOnError,
+        screenshotRedaction,
+        screenshotMaskStyle,
+        screenshotMaxBytes,
+        screenshotQuality,
+        screenshotFormat,
+        screenshotSampleRate,
+        screenshotOnUnhandledOnly,
+        screenshotUploadTimeoutMs,
+        screenshotCaptureTimeoutMs,
+        screenshotNativeMode,
+        screenshotFailPolicy,
+        beforeScreenshotCapture,
+        beforeScreenshotUpload,
+        isScreenshotAllowed
       };
       clientRef.current = AllStak.init(config);
       __providerOwnedInstance = clientRef.current;
@@ -2705,7 +3241,7 @@ function AllStakProvider({
       }
     }
   }
-  React.useEffect(() => {
+  React2.useEffect(() => {
     return () => {
       if (destroyOnUnmount) {
         AllStak.destroy();
@@ -2715,10 +3251,17 @@ function AllStakProvider({
       }
     };
   }, [destroyOnUnmount, debug]);
-  return /* @__PURE__ */ React.createElement(AllStakContext.Provider, { value: clientRef.current }, /* @__PURE__ */ React.createElement(AllStakErrorBoundary, { fallback, onError, debug }, children));
+  const boundary = /* @__PURE__ */ React2.createElement(AllStakErrorBoundary, { fallback, onError, debug }, children);
+  const RootView = getRootView();
+  const wrapped = RootView ? React2.createElement(
+    RootView,
+    { ref: rootRef, style: { flex: 1 }, collapsable: false },
+    boundary
+  ) : boundary;
+  return /* @__PURE__ */ React2.createElement(AllStakContext.Provider, { value: clientRef.current }, wrapped);
 }
 function useAllStak() {
-  return React.useMemo(
+  return React2.useMemo(
     () => ({
       captureException: (error, ctx) => AllStak.captureException(error, ctx),
       captureMessage: (msg, level = "info") => AllStak.captureMessage(msg, level),
@@ -2788,8 +3331,13 @@ export {
   ALWAYS_REDACT_QUERY,
   AllStak,
   AllStakClient,
+  AllStakMaskedView,
+  AllStakPrivacyView,
   AllStakProvider,
+  AllStakSensitiveText,
+  AllStakTextInput,
   DEFAULT_REDACT_BODY_FIELDS,
+  DEFAULT_SCREENSHOT_CONFIG,
   HttpRequestModule,
   INGEST_HOST,
   REDACTED,
@@ -2800,18 +3348,30 @@ export {
   __devTriggerNativeCrash,
   __resetAutoNavigationFlagForTest,
   __resetConsoleInstrumentationFlagForTest,
+  __resetPrivacyStateForTest,
   __resetProviderInstanceForTest,
+  __resetRuntimeModeForTest,
   __setNativeModuleForTest,
   applyArchitectureTags,
   captureBodyResult,
+  captureViaViewShot,
   detectArchitecture,
+  detectRuntimeMode,
   drainPendingNativeCrashes,
   installReactNative,
   instrumentNavigationFromLinking,
   instrumentReactNavigation,
+  isCapturingScreenshot,
+  isViewShotAvailable,
+  maybeCaptureScreenshot,
+  pickScreenshotConfig,
   redactUrl,
+  registerSensitiveRef,
+  resolveScreenshotConfig,
+  runtimeAllowsScreenshot,
   sanitizeHeaders,
   tryAutoInstrumentNavigation,
-  useAllStak
+  useAllStak,
+  useAllStakPrivacy
 };
 //# sourceMappingURL=index.mjs.map