@brunyee-studio/onus-sdk 0.1.0 → 1.0.0

package/dist/index.cjs

@@ -128,18 +128,39 @@ async function gzipText(text) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function untilAborted(operation, signal) {
+  if (!signal) return operation;
+  if (signal.aborted) return Promise.resolve(void 0);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => resolve(void 0);
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
 async function sendEnvelope(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const maxRetries = opts.maxRetries ?? 1;
   const backoffMs = opts.backoffMs ?? 500;
   const sleep = opts.delayImpl ?? delay;
-  const gz = await gzipText(opts.body);
+  if (opts.signal?.aborted) return { ok: false, error: "aborted" };
+  const gz = await untilAborted(gzipText(opts.body), opts.signal);
+  if (opts.signal?.aborted) return { ok: false, error: "aborted" };
   const headers = {
     "Content-Type": "application/x-sentry-envelope",
     "X-Sentry-Auth": opts.authHeader,
     ...gz ? { "Content-Encoding": "gzip" } : {}
   };
   for (let attempt = 0; ; attempt++) {
+    if (opts.signal?.aborted) return { ok: false, error: "aborted" };
     let res;
     try {
       res = await fetchImpl(opts.url, {
@@ -147,11 +168,13 @@ async function sendEnvelope(opts) {
         headers,
         body: gz ?? opts.body,
         // Analytics-style telemetry: never block page unload on the response.
-        keepalive: true
+        keepalive: true,
+        signal: opts.signal
       });
     } catch (e) {
       return { ok: false, error: e instanceof Error ? e.message : "network error" };
     }
+    if (opts.signal?.aborted) return { ok: false, error: "aborted" };
     if (res.ok) return { ok: true, status: res.status };
     if (res.status === 429 && attempt < maxRetries) {
       const retryAfter = Number(res.headers.get("retry-after") ?? "");
@@ -159,7 +182,8 @@ async function sendEnvelope(opts) {
         Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : backoffMs * (attempt + 1),
         1e4
       );
-      await sleep(wait);
+      await untilAborted(sleep(wait), opts.signal);
+      if (opts.signal?.aborted) return { ok: false, error: "aborted" };
       continue;
     }
     if (res.status === 429) {
@@ -180,6 +204,152 @@ var init_transport = __esm({
   }
 });
 
+// src/capture-gate.ts
+function isReplayCaptureAllowed() {
+  return allowed;
+}
+function deferAutoStart(start) {
+  pendingAutoStart = start;
+  const generation = ++autoStartGeneration;
+  releaseStaleAutoReplay?.(generation);
+  return generation;
+}
+function clearAutoStart() {
+  pendingAutoStart = null;
+  releaseStaleAutoReplay?.(++autoStartGeneration);
+}
+function isAutoStartGenerationCurrent(generation) {
+  return generation === autoStartGeneration && pendingAutoStart !== null;
+}
+function getReplayCaptureGrantEpoch() {
+  return grantEpoch;
+}
+function registerReplayLinkClear(clear) {
+  clearReplayLink = clear;
+}
+function registerStaleAutoReplayRelease(release) {
+  releaseStaleAutoReplay = release;
+}
+function registerReplayStop(stop) {
+  stopReplay = stop;
+}
+async function setReplayCaptureAllowed(next) {
+  if (next === allowed) return;
+  allowed = next;
+  grantEpoch++;
+  if (!next) {
+    const stop = stopReplay;
+    stopReplay = null;
+    stop?.();
+    clearReplayLink?.();
+    return;
+  }
+  const start = pendingAutoStart;
+  if (start) await start();
+}
+function resetCaptureGateForTest() {
+  allowed = false;
+  grantEpoch++;
+  clearAutoStart();
+  releaseStaleAutoReplay = null;
+  const stop = stopReplay;
+  stopReplay = null;
+  stop?.();
+  clearReplayLink?.();
+  clearReplayLink = null;
+}
+var allowed, pendingAutoStart, autoStartGeneration, grantEpoch, stopReplay, clearReplayLink, releaseStaleAutoReplay;
+var init_capture_gate = __esm({
+  "src/capture-gate.ts"() {
+    "use strict";
+    allowed = false;
+    pendingAutoStart = null;
+    autoStartGeneration = 0;
+    grantEpoch = 0;
+    stopReplay = null;
+    clearReplayLink = null;
+    releaseStaleAutoReplay = null;
+  }
+});
+
+// src/replay-privacy.ts
+function isValidCssSelector(raw) {
+  if (typeof document === "undefined") return false;
+  try {
+    document.querySelector(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validSelectorExtra(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) return "";
+  return isValidCssSelector(raw) ? raw : "";
+}
+function maskTextSelectorOrFallback(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) return PRIVACY_DEFAULTS.maskTextSelector;
+  return isValidCssSelector(raw) ? raw : PRIVACY_DEFAULTS.maskTextSelector;
+}
+function blockSelectorWithExtra(extra) {
+  const extra_ = validSelectorExtra(extra);
+  return extra_ ? `${PRIVACY_DEFAULTS.blockSelector}, ${extra_}` : PRIVACY_DEFAULTS.blockSelector;
+}
+function resolveRecordPrivacy(recordOptions, privacy) {
+  const passthrough = {};
+  for (const [key, value] of Object.entries(recordOptions ?? {})) {
+    if (!PRIVACY_CONTROLLED_KEYS.has(key)) passthrough[key] = value;
+  }
+  const effective = {
+    ...passthrough,
+    maskAllInputs: privacy?.maskAllInputs ?? PRIVACY_DEFAULTS.maskAllInputs,
+    maskTextSelector: maskTextSelectorOrFallback(privacy?.maskTextSelector),
+    blockSelector: blockSelectorWithExtra(privacy?.blockSelector),
+    recordCanvas: false,
+    recordCrossOriginIframes: false,
+    inlineImages: false,
+    // Password masking is non-negotiable, regardless of opt-downs above.
+    maskInputOptions: {
+      ...privacy?.maskInputOptions ?? {},
+      password: true
+    }
+  };
+  if (privacy?.maskTextFn) effective["maskTextFn"] = privacy.maskTextFn;
+  if (privacy?.ignoreSelector) effective["ignoreSelector"] = privacy.ignoreSelector;
+  return effective;
+}
+var PRIVACY_CONTROLLED_KEYS, PRIVACY_DEFAULTS;
+var init_replay_privacy = __esm({
+  "src/replay-privacy.ts"() {
+    "use strict";
+    PRIVACY_CONTROLLED_KEYS = /* @__PURE__ */ new Set([
+      "emit",
+      "maskAllInputs",
+      "maskTextSelector",
+      "maskTextClass",
+      "maskInputOptions",
+      "maskInputFn",
+      "maskTextFn",
+      "blockSelector",
+      "blockClass",
+      "ignoreClass",
+      "ignoreSelector",
+      // rrweb runs packers/plugins BEFORE the emit callback, so an allowed
+      // passthrough could serialize events that never pass through the SDK's
+      // Meta href sanitization. They are SDK-controlled, never passthrough.
+      "packFn",
+      "plugins",
+      "recordCanvas",
+      "recordCrossOriginIframes",
+      "inlineImages"
+    ]);
+    PRIVACY_DEFAULTS = {
+      maskAllInputs: true,
+      maskTextSelector: "*",
+      blockSelector: '[data-onus-private], input[type="hidden"], input[type="radio"], input[type="checkbox"]'
+    };
+  }
+});
+
 // src/replay.ts
 var replay_exports = {};
 __export(replay_exports, {
@@ -188,27 +358,89 @@ __export(replay_exports, {
   emitSegment: () => emitSegment,
   parseDsn: () => parseDsn,
   resetReplayForTest: () => resetReplayForTest,
+  revokeActiveReplay: () => revokeActiveReplay,
+  sanitizeRecordedEvent: () => sanitizeRecordedEvent,
+  startAutoSessionReplay: () => startAutoSessionReplay,
   startSessionReplay: () => startSessionReplay,
-  stopSessionReplay: () => stopSessionReplay
+  stopSessionReplay: () => stopSessionReplay,
+  stripUrlQueryAndFragment: () => stripUrlQueryAndFragment
 });
-async function startSessionReplay(options = {}) {
+function stripUrlQueryAndFragment(raw) {
+  try {
+    const url = new URL(raw);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    const noHash = raw.split("#")[0] ?? raw;
+    return noHash.split("?")[0] ?? noHash;
+  }
+}
+function sanitizeRecordedEvent(event) {
+  const candidate = event;
+  if (!candidate || typeof candidate !== "object" || candidate.type !== 4 || !candidate.data || typeof candidate.data !== "object") {
+    return event;
+  }
+  const data = { ...candidate.data };
+  if (typeof data["href"] === "string") data["href"] = stripUrlQueryAndFragment(data["href"]);
+  return { ...candidate, data };
+}
+function retainPendingTail(state2) {
+  pendingTails.add(state2);
+  if (pendingTails.size <= MAX_PENDING_TAILS) return;
+  const oldest = pendingTails.values().next().value;
+  if (!oldest) return;
+  pendingTails.delete(oldest);
+  oldest.abort?.abort();
+  oldest.buffer.length = 0;
+}
+function clearFailedClaim(state2) {
+  if (active === state2) active = null;
+  if (getActiveReplayId() === state2.replayId) setActiveReplayId(null);
+}
+function releaseStaleAutoReplay2(generation) {
+  if (active?.origin.kind === "auto" && active.origin.generation !== generation) {
+    dropActiveReplay();
+  }
+}
+function startSessionReplay(options = {}) {
+  return startRecording(options, { kind: "manual" });
+}
+function startAutoSessionReplay(options, generation) {
+  return startRecording(options, { kind: "auto", generation });
+}
+async function startRecording(options, origin) {
+  if (!isReplayCaptureAllowed() || options.shouldProceed?.() === false) return null;
+  registerStaleAutoReplayRelease(releaseStaleAutoReplay2);
   if (active) return active.replayId;
   const dsn = parseDsn(options.dsn);
   if (!dsn) return null;
   const replayId = eventId().replace(/-/g, "");
-  const state2 = { replayId, stop: null, buffer: [], timer: null };
+  const state2 = {
+    replayId,
+    origin,
+    stop: null,
+    rawStop: null,
+    abort: new AbortController(),
+    pendingSends: 0,
+    buffer: [],
+    timer: null
+  };
   active = state2;
+  registerReplayStop(revokeActiveReplay);
   let record = null;
   if (options.recorderFactory) {
     let recorder;
     try {
       recorder = await options.recorderFactory();
     } catch {
-      active = null;
+      clearFailedClaim(state2);
       return null;
     }
     if (!recorder) {
-      active = null;
+      clearFailedClaim(state2);
       return null;
     }
     record = (_opts) => {
@@ -220,15 +452,19 @@ async function startSessionReplay(options = {}) {
       const mod = await import("rrweb");
       const fn = mod.record;
       if (typeof fn !== "function") {
-        active = null;
+        clearFailedClaim(state2);
         return null;
       }
       record = fn;
     } catch {
-      active = null;
+      clearFailedClaim(state2);
       return null;
     }
   }
+  if (active !== state2 || !isReplayCaptureAllowed() || options.shouldProceed?.() === false) {
+    clearFailedClaim(state2);
+    return null;
+  }
   const segmentIntervalMs = options.segmentIntervalMs ?? 5e3;
   const maxEventsPerSegment = options.maxEventsPerSegment ?? 100;
   const narrowedDsn = dsn;
@@ -237,21 +473,36 @@ async function startSessionReplay(options = {}) {
       clearTimeout(state2.timer);
       state2.timer = null;
     }
+    if (state2.abort?.signal.aborted || options.shouldProceed?.() === false) {
+      state2.buffer.length = 0;
+      return;
+    }
     if (state2.buffer.length === 0) return;
     const events = state2.buffer;
     state2.buffer = [];
-    await emitSegment(
-      narrowedDsn,
-      options,
-      state2,
-      events,
-      ++segmentCounter,
-      (/* @__PURE__ */ new Date()).toISOString()
-    );
+    state2.pendingSends++;
+    try {
+      await emitSegment(
+        narrowedDsn,
+        options,
+        state2,
+        events,
+        ++segmentCounter,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    } finally {
+      state2.pendingSends--;
+      if (state2.pendingSends === 0 && active !== state2) pendingTails.delete(state2);
+    }
   }
+  const effectiveRecordOptions = resolveRecordPrivacy(options.recordOptions, options.privacy);
   const stop = record({
+    ...effectiveRecordOptions,
     emit: (event) => {
-      state2.buffer.push(event);
+      if (active !== state2 || !isReplayCaptureAllowed() || options.shouldProceed?.() === false) {
+        return;
+      }
+      state2.buffer.push(sanitizeRecordedEvent(event));
       if (state2.buffer.length >= maxEventsPerSegment) {
         void flushBuffer();
         return;
@@ -262,9 +513,16 @@ async function startSessionReplay(options = {}) {
           void flushBuffer();
         }, segmentIntervalMs);
       }
-    },
-    ...options.recordOptions
+    }
   });
+  if (active !== state2 || !isReplayCaptureAllowed() || options.shouldProceed?.() === false) {
+    stop?.();
+    state2.abort?.abort();
+    state2.buffer.length = 0;
+    clearFailedClaim(state2);
+    return null;
+  }
+  state2.rawStop = typeof stop === "function" ? stop : null;
   state2.stop = typeof stop === "function" ? () => {
     stop();
     void flushBuffer();
@@ -284,19 +542,48 @@ function stopSessionReplay() {
   const stopping = active;
   active = null;
   if (!stopping) return;
+  retainPendingTail(stopping);
   stopping.stop?.();
   if (stopping.timer !== null) {
     clearTimeout(stopping.timer);
     stopping.timer = null;
   }
   stopping.buffer.length = 0;
+  stopping.rawStop = null;
+  if (stopping.pendingSends === 0) pendingTails.delete(stopping);
+  setActiveReplayId(null);
+}
+function dropActiveReplay() {
+  const stopping = active;
+  active = null;
+  if (!stopping) return;
+  try {
+    stopping.rawStop?.();
+  } catch {
+  }
+  if (stopping.timer !== null) {
+    clearTimeout(stopping.timer);
+    stopping.timer = null;
+  }
+  stopping.abort?.abort();
+  stopping.buffer.length = 0;
+  setActiveReplayId(null);
+}
+function revokeActiveReplay() {
+  dropActiveReplay();
+  for (const tail of pendingTails) {
+    tail.abort?.abort();
+    tail.buffer.length = 0;
+  }
+  pendingTails.clear();
+  setActiveReplayId(null);
 }
 function activeReplayId() {
   return active?.replayId ?? null;
 }
 function resetReplayForTest() {
-  active?.stop?.();
-  active = null;
+  revokeActiveReplay();
+  resetCaptureGateForTest();
   segmentCounter = 0;
 }
 function resolveSessionId(options) {
@@ -340,11 +627,12 @@ ${JSON.stringify(event ?? [])}`;
     url: dsn.envelopeUrl,
     authHeader: `Sentry sentry_key=${dsn.key}, sentry_version=7, sentry_client=onus.javascript/0.1.0`,
     body: serialized,
-    fetchImpl: options.fetchImpl
+    fetchImpl: options.fetchImpl,
+    signal: state2.abort?.signal
   });
   return result.ok;
 }
-var active, segmentCounter;
+var active, pendingTails, MAX_PENDING_TAILS, segmentCounter;
 var init_replay = __esm({
   "src/replay.ts"() {
     "use strict";
@@ -352,9 +640,13 @@ var init_replay = __esm({
     init_transport();
     init_dsn();
     init_client();
+    init_capture_gate();
+    init_replay_privacy();
     init_envelope();
     init_dsn();
     active = null;
+    pendingTails = /* @__PURE__ */ new Set();
+    MAX_PENDING_TAILS = 8;
     segmentCounter = 0;
   }
 });
@@ -404,28 +696,50 @@ function init(options) {
     authHeader: dsn ? buildSentryAuthHeader(dsn, SDK_VERSION) : "",
     replayId: null
   };
+  registerReplayLinkClear(() => setActiveReplayId(null));
   autoReplayStart = null;
-  if (options.replays && options.replays.enabled !== false && dsn) {
-    autoReplayStart = startAutoReplay(options.replays, options);
+  const replays = options.replays;
+  if (replays && replays.enabled !== false && dsn) {
+    let generation;
+    const start = () => {
+      if (!isAutoStartGenerationCurrent(generation) || !isReplayCaptureAllowed()) {
+        return Promise.resolve();
+      }
+      autoReplayStart = startAutoReplay(replays, options, generation, getReplayCaptureGrantEpoch());
+      return autoReplayStart;
+    };
+    generation = deferAutoStart(start);
+    if (isReplayCaptureAllowed()) void start();
+  } else {
+    clearAutoStart();
   }
 }
-async function startAutoReplay(replays, options) {
+async function startAutoReplay(replays, options, generation, grantEpoch2) {
+  const shouldProceed = () => isAutoStartGenerationCurrent(generation) && isReplayCaptureAllowed() && getReplayCaptureGrantEpoch() === grantEpoch2;
   try {
     const rate = typeof replays.sampleRate === "number" && replays.sampleRate >= 0 && replays.sampleRate <= 1 ? replays.sampleRate : 1;
     if (Math.random() >= rate) return;
     const replay = await Promise.resolve().then(() => (init_replay(), replay_exports));
-    const replayId = await replay.startSessionReplay({
-      dsn: options.dsn,
-      environment: replays.environment ?? options.environment,
-      release: replays.release ?? options.release,
-      sessionId: replays.sessionId,
-      segmentIntervalMs: replays.segmentIntervalMs,
-      maxEventsPerSegment: replays.maxEventsPerSegment,
-      recordOptions: replays.recordOptions,
-      recorderFactory: replays.recorderFactory,
-      fetchImpl: replays.fetchImpl ?? options.fetchImpl
-    });
-    if (replayId) setActiveReplayId(replayId);
+    if (!shouldProceed()) return;
+    const replayId = await replay.startAutoSessionReplay(
+      {
+        shouldProceed,
+        dsn: options.dsn,
+        environment: replays.environment ?? options.environment,
+        release: replays.release ?? options.release,
+        sessionId: replays.sessionId,
+        segmentIntervalMs: replays.segmentIntervalMs,
+        maxEventsPerSegment: replays.maxEventsPerSegment,
+        recordOptions: replays.recordOptions,
+        privacy: replays.privacy,
+        recorderFactory: replays.recorderFactory,
+        fetchImpl: replays.fetchImpl ?? options.fetchImpl
+      },
+      generation
+    );
+    if (replayId && shouldProceed() && replay.activeReplayId() === replayId) {
+      setActiveReplayId(replayId);
+    }
   } catch (e) {
     debugLog("replay auto-start failed", e);
   }
@@ -434,6 +748,7 @@ function isEnabled() {
   return state?.dsn !== null && state?.dsn !== void 0;
 }
 function resetForTest() {
+  resetCaptureGateForTest();
   state = null;
   pending.length = 0;
   autoReplayStart = null;
@@ -513,7 +828,8 @@ function captureCustomEvent(name, props) {
   return id;
 }
 function setActiveReplayId(replayId) {
-  if (state) state.replayId = replayId && /^[a-zA-Z0-9_-]{1,64}$/.test(replayId) ? replayId : null;
+  if (!state || replayId && !isReplayCaptureAllowed()) return;
+  state.replayId = replayId && /^[a-zA-Z0-9_-]{1,64}$/.test(replayId) ? replayId : null;
 }
 function getActiveReplayId() {
   return state?.replayId ?? null;
@@ -530,6 +846,7 @@ var init_client = __esm({
     init_dsn();
     init_envelope();
     init_transport();
+    init_capture_gate();
     SDK_NAME = "onus.javascript";
     SDK_VERSION = "0.1.0";
     autoReplayStart = null;
@@ -557,9 +874,11 @@ __export(src_exports, {
   getActiveReplayId: () => getActiveReplayId,
   init: () => init,
   isEnabled: () => isEnabled,
+  isReplayCaptureAllowed: () => isReplayCaptureAllowed,
   parseDsn: () => parseDsn,
   resetForTest: () => resetForTest,
-  setActiveReplayId: () => setActiveReplayId
+  setActiveReplayId: () => setActiveReplayId,
+  setReplayCaptureAllowed: () => setReplayCaptureAllowed
 });
 module.exports = __toCommonJS(src_exports);
 init_client();
@@ -582,7 +901,9 @@ init_envelope();
   getActiveReplayId,
   init,
   isEnabled,
+  isReplayCaptureAllowed,
   parseDsn,
   resetForTest,
-  setActiveReplayId
+  setActiveReplayId,
+  setReplayCaptureAllowed
 });

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import { R as Recorder } from './replay-D7ejwI0s.js';
-export { E as EnvelopeItem, M as MAX_ENVELOPE_BYTES, P as ParsedDsn, a as REPLAY_ID_RE, b as buildEnvelope, c as buildSentryAuthHeader, e as eventId, p as parseDsn } from './replay-D7ejwI0s.js';
+import { R as ReplayPrivacyOptions, a as Recorder } from './replay-BElhLiw8.js';
+export { E as EnvelopeItem, M as MAX_ENVELOPE_BYTES, P as ParsedDsn, b as REPLAY_ID_RE, c as buildEnvelope, d as buildSentryAuthHeader, e as eventId, p as parseDsn } from './replay-BElhLiw8.js';
+
+declare function isReplayCaptureAllowed(): boolean;
+declare function setReplayCaptureAllowed(next: boolean): Promise<void>;
 
 declare const SDK_NAME = "onus.javascript";
 declare const SDK_VERSION = "0.1.0";
 /**
  * Session-replay capture config (ONUS-155). Passing this block opts the app
- * into automatic replay recording from `init()`; within the block, capture
+ * into automatic replay recording after host authorization; within the block, capture
  * defaults to **all sessions** (`sampleRate` 1) — sampling is an opt-down.
- * rrweb itself stays behind the lazy `@onus/sdk/replay` subpath, so the
+ * rrweb itself stays behind the lazy `@brunyee-studio/onus-sdk/replay` subpath, so the
  * recorder chunk only downloads once recording actually starts.
  */
 interface ReplaysOptions {
@@ -16,7 +19,7 @@ interface ReplaysOptions {
     /** Fraction of sessions recorded, 0..1 (default 1 — capture all users). */
     sampleRate?: number;
     /**
-     * @onus/analytics session id (or getter) attached to each replay_event so
+     * @brunyee-studio/onus-analytics session id (or getter) attached to each replay_event so
      * the sessions surface can deep-link playback. A getter is evaluated per
      * segment flush so rotated session ids stay fresh.
      */
@@ -29,8 +32,11 @@ interface ReplaysOptions {
     segmentIntervalMs?: number;
     /** Buffered events that force an immediate segment flush (default 100). */
     maxEventsPerSegment?: number;
-    /** rrweb record options passthrough (privacy masking, etc.). */
+    /** Non-privacy rrweb record tuning (sampling caps, etc.); privacy-controlled
+     * keys (masking, emit, packFn/plugins, canvas/iframe) are stripped here. */
     recordOptions?: Record<string, unknown>;
+    /** Deliberate privacy opt-downs; forwarded to the recorder. */
+    privacy?: ReplayPrivacyOptions;
     /** Test seam: recorder injection (defaults to lazy rrweb import). */
     recorderFactory?: () => Promise<Recorder | null>;
     /** Test seam: fetch implementation (defaults to the core `fetchImpl`). */
@@ -62,6 +68,7 @@ declare function init(options: OnusSdkOptions): void;
 declare function isEnabled(): boolean;
 /** Test seam: reset module state. */
 declare function resetForTest(): void;
+
 /** Capture a handled/unhandled exception. Returns the event id. */
 declare function captureException(exception: unknown, hint?: OnusErrorEvent): string;
 /** Capture a textual message (level defaults to info). */
@@ -71,7 +78,7 @@ declare function captureEvent(event: OnusErrorEvent): string;
 /**
  * Capture a custom analytics event. Routed through the error envelope as an
  * `event` item with `tags.__onus_custom` marker so the same ingest path
- * serves both surfaces (the @onus/analytics SDK remains the PostHog-style
+ * serves both surfaces (the @brunyee-studio/onus-analytics SDK remains the PostHog-style
  * events pipeline; this is for lightweight app-level breadcrumbs).
  */
 declare function captureCustomEvent(name: string, props?: Record<string, unknown>): string;
@@ -83,7 +90,7 @@ declare function getActiveReplayId(): string | null;
 declare function flush(): Promise<boolean>;
 
 /**
- * Envelope transport for @onus/sdk (ONUS-68).
+ * Envelope transport for @brunyee-studio/onus-sdk (ONUS-68).
  *
  * POSTs a serialized envelope to the ingest route with `X-Sentry-Auth`.
  * Honors the server contract: 429 + `retry-after` (rate limits, migration 34),
@@ -99,4 +106,4 @@ interface SendResult {
     error?: string;
 }
 
-export { type OnusErrorEvent, type OnusSdkOptions, type ReplaysOptions, SDK_NAME, SDK_VERSION, type SendResult, captureCustomEvent, captureEvent, captureException, captureMessage, flush, getActiveReplayId, init, isEnabled, resetForTest, setActiveReplayId };
+export { type OnusErrorEvent, type OnusSdkOptions, ReplayPrivacyOptions, type ReplaysOptions, SDK_NAME, SDK_VERSION, type SendResult, captureCustomEvent, captureEvent, captureException, captureMessage, flush, getActiveReplayId, init, isEnabled, isReplayCaptureAllowed, resetForTest, setActiveReplayId, setReplayCaptureAllowed };

package/dist/index.js

@@ -14,10 +14,12 @@ import {
   getActiveReplayId,
   init,
   isEnabled,
+  isReplayCaptureAllowed,
   parseDsn,
   resetForTest,
-  setActiveReplayId
-} from "./chunk-SLWBPQ6C.js";
+  setActiveReplayId,
+  setReplayCaptureAllowed
+} from "./chunk-YPQXIZ4X.js";
 export {
   MAX_ENVELOPE_BYTES,
   REPLAY_ID_RE,
@@ -34,7 +36,9 @@ export {
   getActiveReplayId,
   init,
   isEnabled,
+  isReplayCaptureAllowed,
   parseDsn,
   resetForTest,
-  setActiveReplayId
+  setActiveReplayId,
+  setReplayCaptureAllowed
 };