@prism-analytics/browser 0.0.1

package/dist/index.mjs

@@ -0,0 +1,804 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import {
+  createPrismClient
+} from "@prism-analytics/core";
+
+// src/browser-runtime.ts
+function browserCreateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `prism-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}
+function createBrowserStorage() {
+  try {
+    const probe = "__prism_storage_probe__";
+    window.sessionStorage.setItem(probe, "1");
+    window.sessionStorage.removeItem(probe);
+    window.localStorage.setItem(probe, "1");
+    window.localStorage.removeItem(probe);
+  } catch (e) {
+    return void 0;
+  }
+  const storeFor = (key) => (
+    // R3-F2: queue snapshots, session globals, and SESSION-scoped identity
+    // live in sessionStorage (per execution context); persistent-scope
+    // identity and globals live in localStorage (cross-launch).
+    key.startsWith("prism:queue:") || key.includes(":globals:session:") || key.includes("prism:identity:session:") ? window.sessionStorage : window.localStorage
+  );
+  return {
+    getItem: (key) => __async(null, null, function* () {
+      try {
+        return storeFor(key).getItem(key);
+      } catch (e) {
+        return null;
+      }
+    }),
+    setItem: (key, value) => __async(null, null, function* () {
+      storeFor(key).setItem(key, value);
+    }),
+    removeItem: (key) => __async(null, null, function* () {
+      storeFor(key).removeItem(key);
+    })
+  };
+}
+function createBrowserLifecycle() {
+  const listeners = {
+    foreground: /* @__PURE__ */ new Set(),
+    background: /* @__PURE__ */ new Set(),
+    "before-unload": /* @__PURE__ */ new Set()
+  };
+  const fire = (event) => {
+    for (const listener of listeners[event]) listener();
+  };
+  const onVisibility = () => {
+    fire(document.visibilityState === "visible" ? "foreground" : "background");
+  };
+  const onBeforeUnload = () => fire("before-unload");
+  document.addEventListener("visibilitychange", onVisibility);
+  window.addEventListener("beforeunload", onBeforeUnload);
+  return {
+    on(event, listener) {
+      listeners[event].add(listener);
+      let removed = false;
+      return () => {
+        if (removed) return;
+        removed = true;
+        listeners[event].delete(listener);
+      };
+    }
+  };
+}
+function captureBrowserContext() {
+  var _a, _b;
+  const context = {
+    platform: "browser",
+    kind: "web"
+  };
+  const width = window.innerWidth || ((_a = window.screen) == null ? void 0 : _a.width) || 0;
+  const height = window.innerHeight || ((_b = window.screen) == null ? void 0 : _b.height) || 0;
+  if (width > 0 && height > 0) {
+    context.screenSize = { width, height };
+  }
+  const locale = navigator.language;
+  if (locale) context.locale = locale;
+  try {
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (timezone) context.timezone = timezone;
+  } catch (e) {
+  }
+  return context;
+}
+function capturePageContext() {
+  let path = "/";
+  try {
+    path = window.location.pathname || "/";
+  } catch (e) {
+  }
+  let referrer = null;
+  try {
+    const raw = document.referrer;
+    if (raw) referrer = new URL(raw).origin;
+  } catch (e) {
+    referrer = null;
+  }
+  return { path, referrer };
+}
+function createBrowserRuntime() {
+  const storage = createBrowserStorage();
+  return __spreadValues({
+    name: "browser",
+    now: () => Date.now(),
+    createId: browserCreateId,
+    transport: {
+      post: (url, request) => {
+        const controller = new AbortController();
+        const onCoreAbort = () => controller.abort();
+        request.signal.addEventListener("abort", onCoreAbort);
+        const timer = window.setTimeout(
+          () => controller.abort(),
+          request.timeoutMs
+        );
+        const bodyBytes = new TextEncoder().encode(request.body).length;
+        const keepalive = bodyBytes <= 64 * 1024;
+        return fetch(url, {
+          method: "POST",
+          headers: __spreadValues({}, request.headers),
+          body: request.body,
+          signal: controller.signal,
+          keepalive
+        }).then((response) => __async(null, null, function* () {
+          return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            text: () => response.text()
+          };
+        })).finally(() => {
+          window.clearTimeout(timer);
+          request.signal.removeEventListener("abort", onCoreAbort);
+        });
+      }
+    },
+    schedule: (delayMs, callback) => {
+      const handle = window.setTimeout(callback, delayMs);
+      return () => window.clearTimeout(handle);
+    },
+    context: captureBrowserContext(),
+    lifecycle: createBrowserLifecycle()
+  }, storage ? { storage } : {});
+}
+
+// src/page-tracker.ts
+import {
+  INTERNAL_SEAM,
+  PAGE_VIEW_EVENT_NAME,
+  PAGE_VIEW_LIMITS
+} from "@prism-analytics/core";
+function dropped(reason) {
+  return { status: "dropped", reason };
+}
+function hashString(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+function safeSessionStorage() {
+  try {
+    const probe = "__prism_probe__";
+    window.sessionStorage.setItem(probe, "1");
+    window.sessionStorage.removeItem(probe);
+    return window.sessionStorage;
+  } catch (e) {
+    return null;
+  }
+}
+function stableId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `wsess-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+var historyPatch = null;
+function notify(navigation) {
+  if (!historyPatch) return;
+  for (const listener of [...historyPatch.listeners]) {
+    try {
+      listener(navigation);
+    } catch (e) {
+    }
+  }
+}
+function acquireHistoryPatch(listener) {
+  if (!historyPatch) {
+    const originalPush = window.history.pushState.bind(window.history);
+    const originalReplace = window.history.replaceState.bind(window.history);
+    const patch = {
+      count: 0,
+      originalPush,
+      originalReplace,
+      listeners: /* @__PURE__ */ new Set()
+    };
+    window.history.pushState = function patchedPush(...args) {
+      const result = originalPush.apply(this, args);
+      notify("push");
+      return result;
+    };
+    window.history.replaceState = function patchedReplace(...args) {
+      const result = originalReplace.apply(this, args);
+      notify("replace");
+      return result;
+    };
+    window.addEventListener("popstate", () => notify("pop"));
+    historyPatch = patch;
+  }
+  historyPatch.count += 1;
+  historyPatch.listeners.add(listener);
+  return () => {
+    const current = historyPatch;
+    if (!current) return;
+    current.listeners.delete(listener);
+    current.count -= 1;
+    if (current.count <= 0) {
+      window.history.pushState = current.originalPush;
+      window.history.replaceState = current.originalReplace;
+      historyPatch = null;
+    }
+  };
+}
+function createPageTracker(args) {
+  var _a;
+  const { client, options } = args;
+  const seam = (_a = client[INTERNAL_SEAM]) != null ? _a : null;
+  const storage = safeSessionStorage();
+  const stateKey = `prism:web-session:${hashString(args.sourceKey)}:${hashString(args.endpoint)}`;
+  let disposed = false;
+  let removeHistory = null;
+  let lastCapturedPath = null;
+  let lastManualSignature = null;
+  let lastManualAt = 0;
+  function loadState() {
+    if (!storage) return null;
+    try {
+      const raw = storage.getItem(stateKey);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if ((parsed == null ? void 0 : parsed.v) !== 1 || !parsed.sessionId) return null;
+      return parsed;
+    } catch (e) {
+      return null;
+    }
+  }
+  function saveState(state) {
+    if (!storage) return;
+    try {
+      storage.setItem(stateKey, JSON.stringify(state));
+    } catch (e) {
+    }
+  }
+  function clearState() {
+    if (!storage) return;
+    try {
+      storage.removeItem(stateKey);
+    } catch (e) {
+    }
+  }
+  function ensureWebSession(now) {
+    const stored = loadState();
+    if (stored && now - stored.lastActivityAt <= PAGE_VIEW_LIMITS.webSessionInactivityTimeoutMs) {
+      seam == null ? void 0 : seam.resumeWebSession({
+        sessionId: stored.sessionId,
+        startedAt: stored.startedAt
+      });
+      const sequence = stored.sequence + 1;
+      saveState(__spreadProps(__spreadValues({}, stored), { lastActivityAt: now, sequence }));
+      return sequence;
+    }
+    const handle = client.startSession();
+    const sessionId = handle.status === "started" ? handle.session.sessionId : stableId();
+    const startedAt = now;
+    saveState({
+      v: 1,
+      sessionId,
+      startedAt,
+      lastActivityAt: now,
+      sequence: 1
+    });
+    return 1;
+  }
+  function buildCandidate(navigation, override) {
+    var _a2;
+    let host = "";
+    let path = "/";
+    try {
+      host = window.location.hostname.toLowerCase();
+      path = window.location.pathname || "/";
+    } catch (e) {
+      return null;
+    }
+    if ((override == null ? void 0 : override.path) && override.path.startsWith("/")) {
+      path = override.path;
+    }
+    if (!host || !isValidPath(path)) return null;
+    const stored = loadState();
+    const candidate = __spreadValues(__spreadValues({
+      host,
+      path,
+      navigation,
+      sequence: stored ? stored.sequence + 1 : 1
+    }, stored && lastCapturedPath ? { previousPath: lastCapturedPath } : {}), options.captureTitle ? {
+      title: ((_a2 = override == null ? void 0 : override.title) != null ? _a2 : documentTitle()).slice(
+        0,
+        PAGE_VIEW_LIMITS.maxTitleLength
+      )
+    } : {});
+    if (typeof options.beforeCapture === "function") {
+      try {
+        const next = options.beforeCapture(candidate);
+        if (!next) return null;
+        return next;
+      } catch (e) {
+        return null;
+      }
+    }
+    return candidate;
+  }
+  function isValidPath(path) {
+    return path.startsWith("/") && path.length <= PAGE_VIEW_LIMITS.maxPathLength && !path.includes("?") && !path.includes("#");
+  }
+  function documentTitle() {
+    var _a2;
+    try {
+      return typeof document !== "undefined" ? (_a2 = document.title) != null ? _a2 : "" : "";
+    } catch (e) {
+      return "";
+    }
+  }
+  function externalReferrerHost(host) {
+    try {
+      const raw = document.referrer;
+      if (!raw) return void 0;
+      const parsed = new URL(raw);
+      const referrerHost = parsed.hostname.toLowerCase();
+      if (!referrerHost || referrerHost === host) return void 0;
+      return referrerHost.slice(0, PAGE_VIEW_LIMITS.maxAttributionValueLength);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  function campaignFromQuery() {
+    var _a2;
+    try {
+      const search = window.location.search;
+      if (!search) return void 0;
+      const params = new URLSearchParams(search);
+      const allow = new Set(
+        (_a2 = options.campaignParameters) != null ? _a2 : [
+          "utm_source",
+          "utm_medium",
+          "utm_campaign"
+        ]
+      );
+      const bound = (key) => {
+        const value = params.get(key);
+        if (!value) return void 0;
+        return value.slice(0, PAGE_VIEW_LIMITS.maxAttributionValueLength);
+      };
+      const out = {};
+      if (allow.has("utm_source")) out.source = bound("utm_source");
+      if (allow.has("utm_medium")) out.medium = bound("utm_medium");
+      if (allow.has("utm_campaign")) out.name = bound("utm_campaign");
+      if (!out.source && !out.medium && !out.name) return void 0;
+      return out;
+    } catch (e) {
+      return void 0;
+    }
+  }
+  function deliver(candidate) {
+    const now = Date.now();
+    if (client.collectionState !== "granted") {
+      return {
+        status: "dropped",
+        reason: client.collectionState === "pending" ? "consent-pending" : "consent-denied"
+      };
+    }
+    const sequence = ensureWebSession(now);
+    const withSequence = __spreadProps(__spreadValues({}, candidate), { sequence });
+    lastCapturedPath = withSequence.path;
+    const properties = {
+      $page: __spreadValues(__spreadValues({
+        host: withSequence.host,
+        path: withSequence.path,
+        navigation: withSequence.navigation,
+        sequence: withSequence.sequence
+      }, withSequence.previousPath ? { previousPath: withSequence.previousPath } : {}), withSequence.title ? { title: withSequence.title } : {})
+    };
+    const referrer = externalReferrerHost(withSequence.host);
+    if (referrer) properties.$referrer = { host: referrer };
+    const campaign = campaignFromQuery();
+    if (campaign) properties.$campaign = campaign;
+    const result = seam == null ? void 0 : seam.createReservedEvent(PAGE_VIEW_EVENT_NAME, properties);
+    if (!result) {
+      return dropped("shutdown");
+    }
+    if (result.status === "queued") {
+      return { status: "queued", eventId: result.eventId };
+    }
+    if (result.status === "rejected") {
+      return { status: "dropped", reason: result.reason };
+    }
+    return { status: "dropped", reason: result.reason };
+  }
+  function captureNavigation(navigation, override) {
+    if (disposed) {
+      return dropped("shutdown");
+    }
+    const candidate = buildCandidate(navigation, override);
+    if (!candidate) {
+      return dropped("invalid-page-context");
+    }
+    if (candidate.path === lastCapturedPath && (navigation === "replace" || navigation === "push" || navigation === "manual")) {
+      return dropped("same-path-suppressed");
+    }
+    return deliver(candidate);
+  }
+  if (options.mode === "history") {
+    removeHistory = acquireHistoryPatch((navigation) => {
+      captureNavigation(navigation);
+    });
+    captureNavigation("initial");
+  }
+  const controller = {
+    mode: options.mode,
+    capture(input) {
+      var _a2;
+      if (disposed) {
+        return dropped("shutdown");
+      }
+      if (options.mode === "history") {
+        throw new Error(
+          "pageViews.capture() is unavailable in history mode \u2014 navigation is captured automatically"
+        );
+      }
+      const signature = `${window.location.hostname}|${(_a2 = input == null ? void 0 : input.path) != null ? _a2 : window.location.pathname}`;
+      const now = Date.now();
+      if (signature === lastManualSignature && now - lastManualAt < 500) {
+        lastManualAt = now;
+        return dropped("duplicate-manual-capture");
+      }
+      lastManualSignature = signature;
+      lastManualAt = now;
+      return captureNavigation("manual", input);
+    },
+    resetForTests() {
+      clearState();
+      lastCapturedPath = null;
+      lastManualSignature = null;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (removeHistory) {
+        removeHistory();
+        removeHistory = null;
+      }
+    }
+  };
+  return controller;
+}
+
+// src/error-reporter.ts
+import {
+  createPrismErrorReporter,
+  framesFromStack
+} from "@prism-analytics/core";
+function describeUnknown(value, depth = 0) {
+  if (depth > 2) return "[object]";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0)
+    return String(value);
+  if (depth === 0 && Array.isArray(value)) return "UnhandledRejection";
+  try {
+    const seen = /* @__PURE__ */ new Set();
+    const text = JSON.stringify(value, (_k, v) => {
+      if (typeof v === "object" && v !== null) {
+        if (seen.has(v)) return "[Circular]";
+        seen.add(v);
+      }
+      if (typeof v === "function") return "[Function]";
+      return v;
+    });
+    if (text && text.length <= 256) return text;
+    return "[object]";
+  } catch (e) {
+    return "[object]";
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function looksLikeErrorReportInput(value) {
+  return isPlainRecord(value) && isPlainRecord(value.exception) && typeof value.exception.type === "string";
+}
+function safeMessage(message, fallback = "Error") {
+  const text = typeof message === "string" && message.length > 0 ? message : fallback;
+  return text.length > 2048 ? `${text.slice(0, 2048)}\u2026` : text;
+}
+function normalizeErrorValue(value) {
+  var _a;
+  if (typeof value === "string") {
+    return { exception: { type: "Error", message: value } };
+  }
+  if (value instanceof Error) {
+    return {
+      exception: {
+        type: value.name || "Error",
+        message: safeMessage(value.message),
+        frames: framesFromStack(value.stack)
+      }
+    };
+  }
+  if (isPlainRecord(value)) {
+    const record = value;
+    if (record.type === "unhandledrejection") {
+      return normalizeErrorValue((_a = record.reason) != null ? _a : "Unhandled rejection");
+    }
+    if (looksLikeErrorReportInput(record)) {
+      return record;
+    }
+    const name = record.name;
+    const message = record.message;
+    if (typeof name === "string" && name.length > 0 && typeof message === "string") {
+      return {
+        exception: {
+          type: name,
+          message: safeMessage(message),
+          frames: framesFromStack(
+            typeof record.stack === "string" ? record.stack : void 0
+          )
+        }
+      };
+    }
+    if (typeof message === "string" && message.length > 0) {
+      return __spreadValues({
+        exception: {
+          type: message === "Script error." ? "ScriptError" : "Error",
+          message: safeMessage(message)
+        }
+      }, message === "Script error." ? { context: { extras: { scriptError: true } } } : {});
+    }
+    return {
+      exception: {
+        type: "UnhandledRejection",
+        message: describeUnknown(record)
+      }
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    return {
+      exception: { type: "Error", message: describeUnknown(value) }
+    };
+  }
+  return {
+    exception: { type: "Error", message: describeUnknown(value) }
+  };
+}
+var DEDUPE_DEFAULT_MS = 1e3;
+var DEDUPE_MAX_ENTRIES = 100;
+function createBrowserErrorReporter(options) {
+  return __async(this, null, function* () {
+    var _a;
+    if (typeof window === "undefined") {
+      throw new Error(
+        "@prism-analytics/browser error reporter requires a browser (window is undefined)"
+      );
+    }
+    if (!options.endpoint || options.endpoint.trim().length === 0) {
+      throw new Error(
+        "endpoint is required \u2014 choose the ingestion origin at runtime"
+      );
+    }
+    if (!options.share || typeof options.share.consent !== "function") {
+      throw new Error("share is required \u2014 wire the analytics client's consent");
+    }
+    const runtime = createBrowserRuntime();
+    const reporter = yield createPrismErrorReporter(__spreadValues({
+      sourceKey: options.sourceKey,
+      endpoint: options.endpoint,
+      runtime,
+      share: options.share,
+      beforeSend: options.beforeSend,
+      queue: options.queue
+    }, "onDiagnostic" in options && options.onDiagnostic ? { onDiagnostic: options.onDiagnostic } : {}));
+    const dedupeMs = (_a = options.dedupeMs) != null ? _a : DEDUPE_DEFAULT_MS;
+    const seen = /* @__PURE__ */ new Map();
+    let installed = false;
+    let handleError = null;
+    let handleRejection = null;
+    const capture = (value, captureOptions) => {
+      var _a2, _b, _c, _d, _e;
+      let input;
+      try {
+        input = normalizeErrorValue(value);
+      } catch (error) {
+        throw error instanceof Error ? error : new Error("invalid error report");
+      }
+      const release = (_b = (_a2 = captureOptions == null ? void 0 : captureOptions.release) != null ? _a2 : options.release) != null ? _b : input.release;
+      const environment = (_d = (_c = captureOptions == null ? void 0 : captureOptions.environment) != null ? _c : options.environment) != null ? _d : input.environment;
+      input = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, input), release ? { release } : {}), environment ? { environment } : {}), (captureOptions == null ? void 0 : captureOptions.level) ? { level: captureOptions.level } : {}), (captureOptions == null ? void 0 : captureOptions.context) ? { context: captureOptions.context } : {}), (captureOptions == null ? void 0 : captureOptions.breadcrumbs) ? { breadcrumbs: captureOptions.breadcrumbs } : {}), "handled" in (captureOptions != null ? captureOptions : {}) ? { handled: captureOptions == null ? void 0 : captureOptions.handled } : { handled: true });
+      const type = input.exception.type;
+      const key = `${type}\0${(_e = input.exception.message) != null ? _e : ""}`;
+      const now = runtime.now();
+      const prior = seen.get(key);
+      if (prior && now - prior.ts < dedupeMs) {
+        return { status: "deduped", id: prior.id };
+      }
+      if (seen.size >= DEDUPE_MAX_ENTRIES) {
+        for (const k of seen.keys()) {
+          seen.delete(k);
+          if (seen.size < DEDUPE_MAX_ENTRIES) break;
+        }
+      }
+      const result = reporter.captureException(input);
+      if (result.status === "queued") {
+        seen.set(key, { ts: now, id: result.id });
+      }
+      return result;
+    };
+    const install = () => {
+      if (installed) return;
+      installed = true;
+      handleError = (event) => {
+        var _a2, _b;
+        const errorEvent = event;
+        const message = errorEvent.message;
+        const error = errorEvent.error;
+        try {
+          if (error && error instanceof Error) {
+            capture(error, { handled: false });
+          } else if (typeof message === "string" && message.length > 0) {
+            capture(
+              {
+                exception: { type: "ScriptError", message },
+                context: { extras: { scriptError: message === "Script error." } }
+              },
+              { handled: false }
+            );
+          } else {
+            const target = errorEvent.target;
+            capture(
+              {
+                exception: {
+                  type: "ResourceError",
+                  message: (_b = (_a2 = target == null ? void 0 : target.src) != null ? _a2 : target == null ? void 0 : target.tagName) != null ? _b : "Resource load failed"
+                }
+              },
+              { handled: false }
+            );
+          }
+        } catch (e) {
+        }
+      };
+      handleRejection = (event) => {
+        const reason = event.reason;
+        try {
+          capture(reason != null ? reason : "Unhandled rejection", { handled: false });
+        } catch (e) {
+        }
+      };
+      window.addEventListener("error", handleError, true);
+      window.addEventListener("unhandledrejection", handleRejection);
+    };
+    const uninstall = () => {
+      if (!installed) return;
+      installed = false;
+      if (handleError) window.removeEventListener("error", handleError, true);
+      if (handleRejection)
+        window.removeEventListener("unhandledrejection", handleRejection);
+      handleError = null;
+      handleRejection = null;
+    };
+    const bound = {
+      reporter,
+      get pendingCount() {
+        return reporter.pendingCount;
+      },
+      get installed() {
+        return installed;
+      },
+      captureException: capture,
+      install,
+      uninstall,
+      flush: () => reporter.flush(),
+      shutdown: (opts) => __async(null, null, function* () {
+        uninstall();
+        yield reporter.shutdown(opts);
+      }),
+      onDiagnostic: (listener) => reporter.onDiagnostic(listener)
+    };
+    if (options.captureGlobalErrors) install();
+    return bound;
+  });
+}
+
+// src/index.ts
+import { framesFromStack as framesFromStack2 } from "@prism-analytics/core";
+function createBrowserClient(options) {
+  return __async(this, null, function* () {
+    if (typeof window === "undefined") {
+      throw new Error(
+        "@prism-analytics/browser requires a browser environment (window is undefined)"
+      );
+    }
+    if (!options.endpoint || options.endpoint.trim().length === 0) {
+      throw new Error(
+        "endpoint is required \u2014 choose the ingestion origin at runtime"
+      );
+    }
+    const runtime = createBrowserRuntime();
+    const client = yield createPrismClient({
+      sourceKey: options.sourceKey,
+      endpoint: options.endpoint.replace(/\/$/, ""),
+      runtime,
+      collection: __spreadValues({
+        // Session-scoped identity by default (§4): the browser default
+        // keeps the anonymous ID for the client lifetime unless the caller
+        // explicitly asks for persistent identity.
+        anonymousPersistence: "session"
+      }, options.collection),
+      queue: options.queue,
+      sanitize: options.sanitize
+    });
+    const browserClient = client;
+    if (!options.pageViews) {
+      browserClient.pageViews = null;
+      return browserClient;
+    }
+    const coreClient = client;
+    const tracker = createPageTracker({
+      client: coreClient,
+      options: options.pageViews,
+      sourceKey: options.sourceKey,
+      endpoint: options.endpoint.replace(/\/$/, "")
+    });
+    browserClient.pageViews = {
+      mode: tracker.mode,
+      capture: (input) => tracker.capture(input)
+    };
+    const originalShutdown = client.shutdown.bind(client);
+    browserClient.shutdown = (shutdownOptions) => __async(null, null, function* () {
+      tracker.dispose();
+      return originalShutdown(shutdownOptions);
+    });
+    return browserClient;
+  });
+}
+export {
+  capturePageContext,
+  createBrowserClient,
+  createBrowserErrorReporter,
+  framesFromStack2 as framesFromStack,
+  normalizeErrorValue
+};