@debugbundle/sdk-browser 0.1.8 → 0.1.10

package/README.md

@@ -2,17 +2,20 @@
 
 Browser SDK for DebugBundle.
 
-Use this package to capture frontend exceptions, breadcrumbs, probe data, and browser device context. The recommended transport is the same-origin browser relay served by your backend.
+![npm](https://img.shields.io/npm/v/%40debugbundle%2Fsdk-browser?label=npm)
+![License](https://img.shields.io/badge/license-AGPL--3.0--only-blue)
 
-## Install
+Use this package to capture frontend exceptions, breadcrumbs, first-party request failures, browser device context, trace headers, and probe data. The recommended transport is a same-origin browser relay served by your backend.
 
-Stable npm release:
+## Installation
 
 ```bash
 npm install @debugbundle/sdk-browser
 ```
 
-## Example
+Keep `@debugbundle/sdk-browser` and `@debugbundle/sdk-node` on the same release version. If you pin the core-owned support packages directly, keep `@debugbundle/shared-types` and `@debugbundle/redaction` on the same version too.
+
+## Quick Start
 
 ```ts
 import { createDebugBundleBrowserSdk } from "@debugbundle/sdk-browser";
@@ -21,12 +24,137 @@ const debugbundle = createDebugBundleBrowserSdk();
 
 debugbundle.init({
   endpoint: "/debugbundle/browser",
-  service: "example-web",
+  service: "web",
   environment: "production"
 });
 ```
 
-## Notes
+The browser SDK starts capture only after `init()` is called. Importing the package has no side effects.
+
+## Transport Modes
+
+| Mode | Configuration | Use when |
+| --- | --- | --- |
+| Relay | `endpoint: "/debugbundle/browser"` | Recommended for full-stack apps. Browser events go to your backend first. |
+| Direct cloud | `projectToken` plus the hosted endpoint | Frontend-only apps without a backend. Use a dedicated write-only token with allowed-origin restrictions. |
+
+For relay setup, see <https://debugbundle.com/docs/sdks/browser-relay>.
+
+### Configuration source precedence
+
+1. Explicit `init(...)` fields win.
+2. Omitted values fall back to package defaults such as `service: "browser-app"` and `environment: "development"`.
+3. Capture-policy fields are server-owned and arrive from `GET /v1/sdk/config`; they are not accepted from local browser config.
+
+Relay mode should configure only the same-origin path plus the service/environment names. Direct-cloud mode requires a dedicated public write-only token and a real ingestion endpoint URL.
+
+## What It Captures
+
+- Frontend exceptions and unhandled promise rejections
+- Recent breadcrumbs from clicks, route changes, console warnings/errors, and first-party network requests
+- First-party request failures that should become incident signals
+- Browser and device context such as user agent, viewport, screen, locale, connection type, and color scheme
+- `X-DebugBundle-Trace-Id` headers on allowed outgoing requests for frontend/backend correlation
+- Always-on probe ring buffers that flush with exceptions
+
+Breadcrumbs are kept in memory and attached to frontend exceptions by default. They are not independently shipped unless configured.
+
+## Configuration
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `endpoint` | derived from transport | Relay or ingestion endpoint. |
+| `projectToken` | none | Direct cloud write-only token for frontend-only deployments. Omit when using relay. |
+| `service` | `browser-app` | Frontend service name shown on incidents and bundles. |
+| `environment` | `development` | Runtime environment such as `production`, `staging`, or `development`. |
+| `enabled` | `true` | Disable all capture without removing instrumentation. |
+| `redactFields` | common sensitive fields | Additional field names to redact. |
+| `sampleRate` | `1.0` | Per-event sampling rate. |
+| `sessionSampleRate` | `1.0` | Per-session capture sampling rate. |
+| `batchSize` | `10` | Events per batch before flushing. |
+| `flushInterval` | `3000` | Flush interval in milliseconds. |
+| `logLevel` | `warning` | Minimum captured browser log severity. |
+| `maxBreadcrumbs` | `10` | Breadcrumb ring-buffer size. |
+| `breadcrumbsOnErrorOnly` | `true` | Attach breadcrumbs to exceptions instead of shipping them independently. |
+| `captureNetwork` | `true` | Capture first-party network breadcrumbs and failure signals. |
+| `captureClicks` | `true` | Capture click breadcrumbs. |
+| `captureRouteChanges` | `true` | Capture route-change breadcrumbs. |
+| `captureConsole` | `false` | Capture console warnings and errors. |
+| `networkFilter` | default failure filtering | Include or exclude requests by URL, status, or response time. |
+| `maxEventsPerSession` | `100` | Cap non-exception events per browser session. |
+| `tracePropagationTargets` | same-origin | URLs allowed to receive `X-DebugBundle-Trace-Id`. |
+| `maxProbeLabels` | `50` | Maximum distinct probe labels buffered in memory. |
+| `maxProbeEntriesPerLabel` | `10` | Maximum entries retained per probe label. |
+| `probeFlushOnError` | `true` | Attach buffered probe data to captured exceptions. |
+| `requestTimeoutMs` | `5000` | Transport timeout in milliseconds. |
+| `transport` | fetch transport | Custom transport function for tests or advanced routing. |
+
+## Service naming guidance
+
+Keep the browser service name distinct from backend deployables inside the same DebugBundle project. A common pattern is `checkout-web` for the browser frontend and `checkout-api` for the backend relay host.
+
+When you send through a same-origin relay, the browser service name should stay browser-owned. The backend relay should not overwrite it unless you intentionally want a shared surface name.
+
+## Explicit Capture
+
+```ts
+debugbundle.captureException(error, { route: window.location.pathname });
+debugbundle.captureLog("checkout warning", "warning", { cartId });
+debugbundle.captureMessage("user started checkout");
+debugbundle.probe("checkout.cart", { itemCount: cart.items.length });
+
+await debugbundle.flush();
+```
+
+## Safety and Privacy
+
+- SDK failures are caught internally and do not break the host page.
+- Sensitive fields are redacted before transport.
+- Duplicate event storms are suppressed locally.
+- Browser project tokens are never needed when using the same-origin relay.
+- Breadcrumb and probe buffers are in-memory only.
+
+## Safe startup behavior
+
+- Relay mode keeps browser-visible credentials out of the page and does not require a token in frontend config.
+- Invalid relay paths or missing direct-cloud credentials fail closed without crashing the host page.
+- `status()` exposes whether the SDK is healthy, degraded, or disconnected.
+- Auth-rejected direct-cloud responses stop pretending capture is healthy and clear buffered events only after the endpoint explicitly rejects the token.
+
+## First-event verification
+
+Minimal application check:
+
+```ts
+import { createDebugBundleBrowserSdk } from "@debugbundle/sdk-browser";
+
+const debugbundle = createDebugBundleBrowserSdk();
+
+debugbundle.init({
+  endpoint: "/debugbundle/browser",
+  service: "checkout-web",
+  environment: "development"
+});
+
+debugbundle.captureException(new Error("debugbundle browser smoke"));
+await debugbundle.flush();
+console.log(debugbundle.status());
+```
+
+Repository-level verification runs the same clean-install smoke used by CI and release:
+
+```bash
+pnpm build
+pnpm smoke:packed
+```
+
+## Documentation
+
+- Browser SDK docs: <https://debugbundle.com/docs/sdks/browser>
+- Browser relay: <https://debugbundle.com/docs/sdks/browser-relay>
+- SDK overview: <https://debugbundle.com/docs/sdks>
+- Repository: <https://github.com/debugbundle/debugbundle-js>
+
+## License
 
-- Published from the standalone `debugbundle/debugbundle-js` repository.
-- Depends on the core-owned published `@debugbundle/shared-types` and `@debugbundle/redaction` packages.
+AGPL-3.0-only.

package/dist/capture-rules.d.ts

@@ -0,0 +1,4 @@
+import type { BrowserCaptureRule, BrowserCaptureRuleEvaluationResult, EventEnvelope } from "./types.js";
+export declare function parseRemoteCaptureRulesPayload(payload: unknown): BrowserCaptureRule[];
+export declare function evaluateBrowserCaptureRulesForEvent(rules: readonly BrowserCaptureRule[], projectId: string, event: EventEnvelope, now: string): BrowserCaptureRuleEvaluationResult | null;
+//# sourceMappingURL=capture-rules.d.ts.map

package/dist/capture-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-rules.d.ts","sourceRoot":"","sources":["../src/capture-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAElB,kCAAkC,EAKlC,aAAa,EACd,MAAM,YAAY,CAAC;AAmUpB,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,OAAO,GAAG,kBAAkB,EAAE,CASrF;AAuQD,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,SAAS,kBAAkB,EAAE,EACpC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,GACV,kCAAkC,GAAG,IAAI,CA0C3C"}

package/dist/capture-rules.js

@@ -0,0 +1,515 @@
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function asInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeRuntime(value) {
+    switch (value?.trim().toLowerCase()) {
+        case "browser":
+            return "browser";
+        case "node":
+        case "nodejs":
+            return "node";
+        case "python":
+            return "python";
+        case "php":
+            return "php";
+        case "java":
+            return "java";
+        case "go":
+        case "golang":
+            return "go";
+        case "ruby":
+            return "ruby";
+        default:
+            return "unknown";
+    }
+}
+function normalizePath(value) {
+    const path = value.split(/[?#]/, 1)[0] ?? "";
+    if (path.length === 0) {
+        return "/";
+    }
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function normalizeEvaluationUrl(value) {
+    const trimmed = value?.trim();
+    if (trimmed === undefined || trimmed.length === 0) {
+        return {};
+    }
+    if (trimmed.startsWith("/")) {
+        return {
+            url: { path: normalizePath(trimmed) },
+            first_party: true
+        };
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+            return {
+                url: {
+                    ...(parsed.hostname.length > 0 ? { host: parsed.hostname.toLowerCase() } : {}),
+                    path: normalizePath(parsed.pathname)
+                },
+                first_party: false
+            };
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const values = value
+        .map((entry) => asString(entry))
+        .filter((entry) => entry !== null);
+    return values.length > 0 ? Array.from(new Set(values)) : undefined;
+}
+function parseNumberArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const values = value
+        .map((entry) => asInteger(entry))
+        .filter((entry) => entry !== null);
+    return values.length > 0 ? Array.from(new Set(values)).sort((left, right) => left - right) : undefined;
+}
+function parseStatusRanges(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const ranges = value
+        .map((entry) => {
+        const record = asRecord(entry);
+        const start = asInteger(record?.["start"]);
+        const end = asInteger(record?.["end"]);
+        if (start === null || end === null || start > end) {
+            return null;
+        }
+        return { start, end };
+    })
+        .filter((entry) => entry !== null);
+    return ranges.length > 0 ? ranges : undefined;
+}
+function parseUrlMatcher(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return undefined;
+    }
+    const host = asString(record["host"])?.toLowerCase();
+    const hostSuffix = asString(record["host_suffix"])?.toLowerCase();
+    const pathPrefix = asString(record["path_prefix"]);
+    const pathEquals = asString(record["path_equals"]);
+    if (host === undefined && hostSuffix === undefined && pathPrefix === undefined && pathEquals === undefined) {
+        return undefined;
+    }
+    return {
+        ...(host === undefined ? {} : { host }),
+        ...(hostSuffix === undefined ? {} : { host_suffix: hostSuffix }),
+        ...(pathPrefix === null ? {} : { path_prefix: normalizePath(pathPrefix) }),
+        ...(pathEquals === null ? {} : { path_equals: normalizePath(pathEquals) })
+    };
+}
+function parseMatcher(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const eventTypes = parseStringArray(record["event_types"]);
+    const services = parseStringArray(record["services"]);
+    const environments = parseStringArray(record["environments"]);
+    const runtimeValues = parseStringArray(record["runtime"]);
+    const firstParty = asBoolean(record["first_party"]);
+    const errorName = asString(record["error_name"]);
+    const messageContains = asString(record["message_contains"]);
+    const messageEquals = asString(record["message_equals"]);
+    const resourceUrl = parseUrlMatcher(record["resource_url"]);
+    const requestUrl = parseUrlMatcher(record["request_url"]);
+    const statusCodes = parseNumberArray(record["status_codes"]);
+    const statusRanges = parseStatusRanges(record["status_ranges"]);
+    const matcher = {
+        ...(eventTypes === undefined ? {} : { event_types: eventTypes }),
+        ...(services === undefined ? {} : { services }),
+        ...(environments === undefined ? {} : { environments }),
+        ...(runtimeValues === undefined ? {} : { runtime: runtimeValues.map((entry) => normalizeRuntime(entry)) }),
+        ...(firstParty === null ? {} : { first_party: firstParty }),
+        ...(errorName === null ? {} : { error_name: errorName }),
+        ...(messageContains === null ? {} : { message_contains: messageContains }),
+        ...(messageEquals === null ? {} : { message_equals: messageEquals }),
+        ...(record["browser_event_kind"] === "window_error" || record["browser_event_kind"] === "resource_error"
+            ? { browser_event_kind: record["browser_event_kind"] }
+            : {}),
+        ...(resourceUrl === undefined ? {} : { resource_url: resourceUrl }),
+        ...(requestUrl === undefined ? {} : { request_url: requestUrl }),
+        ...(statusCodes === undefined ? {} : { status_codes: statusCodes }),
+        ...(statusRanges === undefined ? {} : { status_ranges: statusRanges })
+    };
+    const fingerprintRecord = asRecord(record["fingerprint"]);
+    const fingerprintVersion = asString(fingerprintRecord?.["version"]);
+    const fingerprintValue = asString(fingerprintRecord?.["value"]);
+    if (fingerprintVersion !== null && fingerprintValue !== null) {
+        matcher.fingerprint = {
+            version: fingerprintVersion,
+            value: fingerprintValue
+        };
+    }
+    const narrowingKeys = [
+        matcher.services,
+        matcher.environments,
+        matcher.runtime,
+        matcher.first_party,
+        matcher.error_name,
+        matcher.message_contains,
+        matcher.message_equals,
+        matcher.browser_event_kind,
+        matcher.resource_url,
+        matcher.request_url,
+        matcher.status_codes,
+        matcher.status_ranges,
+        matcher.fingerprint
+    ];
+    if (!narrowingKeys.some((entry) => entry !== undefined)) {
+        return null;
+    }
+    if (matcher.browser_event_kind === "resource_error" &&
+        matcher.resource_url === undefined &&
+        matcher.fingerprint === undefined) {
+        return null;
+    }
+    return matcher;
+}
+function parseCaptureRule(value) {
+    const record = asRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const id = asString(record["id"]);
+    const projectId = asString(record["project_id"]);
+    const name = asString(record["name"]);
+    const actionValue = record["action"];
+    const matcher = parseMatcher(record["matcher"]);
+    const enabled = asBoolean(record["enabled"]);
+    const updatedAt = asString(record["updated_at"]);
+    const createdAt = asString(record["created_at"]);
+    const action = actionValue === "demote" || actionValue === "sample" || actionValue === "drop"
+        ? actionValue
+        : null;
+    if (id === null || projectId === null || name === null || action === null || matcher === null || enabled === null || updatedAt === null || createdAt === null) {
+        return null;
+    }
+    const sampleRate = record["sample_rate"] === null ? null : asNumber(record["sample_rate"]);
+    const sampleEventClass = record["sample_event_class"] === "preserve" || record["sample_event_class"] === "context"
+        ? record["sample_event_class"]
+        : record["sample_event_class"] === null || record["sample_event_class"] === undefined
+            ? null
+            : null;
+    if (action === "sample" && (sampleRate === null || sampleEventClass === null)) {
+        return null;
+    }
+    if (action !== "sample" && (sampleRate !== null || sampleEventClass !== null)) {
+        return null;
+    }
+    return {
+        id,
+        project_id: projectId,
+        name,
+        description: record["description"] === null ? null : asString(record["description"]),
+        enabled,
+        action,
+        matcher,
+        sample_rate: sampleRate,
+        sample_event_class: sampleEventClass,
+        created_by_user_id: record["created_by_user_id"] === null ? null : asString(record["created_by_user_id"]),
+        created_from_incident_id: record["created_from_incident_id"] === null ? null : asString(record["created_from_incident_id"]),
+        created_from_event_id: record["created_from_event_id"] === null ? null : asString(record["created_from_event_id"]),
+        expires_at: record["expires_at"] === null ? null : asString(record["expires_at"]),
+        hit_count: asInteger(record["hit_count"]) ?? 0,
+        last_matched_at: record["last_matched_at"] === null ? null : asString(record["last_matched_at"]),
+        created_at: createdAt,
+        updated_at: updatedAt
+    };
+}
+export function parseRemoteCaptureRulesPayload(payload) {
+    const record = asRecord(payload);
+    if (record === null || !Array.isArray(record["capture_rules"])) {
+        return [];
+    }
+    return record["capture_rules"]
+        .map((candidate) => parseCaptureRule(candidate))
+        .filter((rule) => rule !== null);
+}
+function buildEvaluationContext(projectId, event) {
+    const base = {
+        project_id: projectId,
+        event_id: event.event_id,
+        event_type: event.event_type,
+        service: event.service.name,
+        environment: event.service.environment,
+        runtime: normalizeRuntime(event.service.runtime)
+    };
+    if (event.event_type === "frontend_exception") {
+        const payload = event.payload;
+        const browserEvent = typeof payload["browser_event"] === "object" && payload["browser_event"] !== null
+            ? payload["browser_event"]
+            : null;
+        const target = typeof browserEvent?.["target"] === "object" && browserEvent["target"] !== null
+            ? browserEvent["target"]
+            : null;
+        const sourceUrl = typeof target?.["source_url"] === "string"
+            ? target["source_url"]
+            : typeof browserEvent?.["file_name"] === "string"
+                ? browserEvent["file_name"]
+                : null;
+        const browserEventKind = browserEvent?.["kind"] === "window_error" || browserEvent?.["kind"] === "resource_error"
+            ? browserEvent["kind"]
+            : undefined;
+        const resourceUrl = normalizeEvaluationUrl(sourceUrl);
+        return {
+            ...base,
+            ...(resourceUrl.first_party === undefined ? {} : { first_party: resourceUrl.first_party }),
+            error_name: event.payload.name,
+            message: event.payload.message,
+            ...(browserEventKind === undefined ? {} : { browser_event_kind: browserEventKind }),
+            ...(resourceUrl.url === undefined ? {} : { resource_url: resourceUrl.url })
+        };
+    }
+    if (event.event_type === "request_event") {
+        const requestUrl = normalizeEvaluationUrl(event.payload.path);
+        return {
+            ...base,
+            first_party: requestUrl.first_party ?? true,
+            ...(requestUrl.url === undefined ? {} : { request_url: requestUrl.url }),
+            status_code: event.payload.response_status
+        };
+    }
+    if (event.event_type === "frontend_breadcrumb" && event.payload.breadcrumb_type === "network_request") {
+        const rawUrl = typeof event.payload.data["url"] === "string" ? event.payload.data["url"] : null;
+        const requestUrl = normalizeEvaluationUrl(rawUrl);
+        const statusCode = typeof event.payload.data["status_code"] === "number" ? event.payload.data["status_code"] : undefined;
+        return {
+            ...base,
+            ...(requestUrl.first_party === undefined ? {} : { first_party: requestUrl.first_party }),
+            ...(requestUrl.url === undefined ? {} : { request_url: requestUrl.url }),
+            ...(statusCode === undefined ? {} : { status_code: statusCode })
+        };
+    }
+    if (event.event_type === "log_event") {
+        return {
+            ...base,
+            message: event.payload.message
+        };
+    }
+    return base;
+}
+function matchesUrlMatcher(matcher, value) {
+    if (matcher === undefined) {
+        return true;
+    }
+    if (value === undefined) {
+        return false;
+    }
+    if (matcher.host !== undefined && value.host !== matcher.host) {
+        return false;
+    }
+    if (matcher.host_suffix !== undefined && (value.host === undefined || !value.host.endsWith(matcher.host_suffix))) {
+        return false;
+    }
+    if (matcher.path_equals !== undefined && value.path !== matcher.path_equals) {
+        return false;
+    }
+    if (matcher.path_prefix !== undefined && !value.path.startsWith(matcher.path_prefix)) {
+        return false;
+    }
+    return true;
+}
+function matchesRule(rule, context) {
+    const matcher = rule.matcher;
+    if (matcher.event_types !== undefined && !matcher.event_types.includes(context.event_type)) {
+        return false;
+    }
+    if (matcher.services !== undefined && (context.service === undefined || !matcher.services.includes(context.service))) {
+        return false;
+    }
+    if (matcher.environments !== undefined && (context.environment === undefined || !matcher.environments.includes(context.environment))) {
+        return false;
+    }
+    if (matcher.runtime !== undefined && !matcher.runtime.includes(context.runtime)) {
+        return false;
+    }
+    if (matcher.first_party !== undefined && matcher.first_party !== context.first_party) {
+        return false;
+    }
+    if (matcher.error_name !== undefined && matcher.error_name !== context.error_name) {
+        return false;
+    }
+    if (matcher.message_equals !== undefined && matcher.message_equals !== context.message) {
+        return false;
+    }
+    if (matcher.message_contains !== undefined && (context.message === undefined || !context.message.includes(matcher.message_contains))) {
+        return false;
+    }
+    if (matcher.browser_event_kind !== undefined && matcher.browser_event_kind !== context.browser_event_kind) {
+        return false;
+    }
+    if (!matchesUrlMatcher(matcher.resource_url, context.resource_url)) {
+        return false;
+    }
+    if (!matchesUrlMatcher(matcher.request_url, context.request_url)) {
+        return false;
+    }
+    if (matcher.status_codes !== undefined && (context.status_code === undefined || !matcher.status_codes.includes(context.status_code))) {
+        return false;
+    }
+    if (matcher.status_ranges !== undefined &&
+        (context.status_code === undefined ||
+            !matcher.status_ranges.some((range) => {
+                const statusCode = context.status_code;
+                return statusCode !== undefined && statusCode >= range.start && statusCode <= range.end;
+            }))) {
+        return false;
+    }
+    if (matcher.fingerprint !== undefined &&
+        (context.fingerprint === undefined ||
+            context.fingerprint.version !== matcher.fingerprint.version ||
+            context.fingerprint.value !== matcher.fingerprint.value)) {
+        return false;
+    }
+    return true;
+}
+function getSpecificityScore(rule) {
+    const matcher = rule.matcher;
+    let score = 0;
+    if (matcher.fingerprint !== undefined) {
+        score += 1000;
+    }
+    if (matcher.resource_url?.host !== undefined) {
+        score += 250;
+    }
+    if (matcher.request_url?.host !== undefined) {
+        score += 250;
+    }
+    if (matcher.resource_url?.path_equals !== undefined || matcher.request_url?.path_equals !== undefined) {
+        score += 200;
+    }
+    if (matcher.status_codes !== undefined) {
+        score += 150;
+    }
+    if (matcher.browser_event_kind !== undefined) {
+        score += 100;
+    }
+    if (matcher.resource_url?.host_suffix !== undefined || matcher.request_url?.host_suffix !== undefined) {
+        score += 90;
+    }
+    if (matcher.resource_url?.path_prefix !== undefined || matcher.request_url?.path_prefix !== undefined) {
+        score += 80;
+    }
+    if (matcher.error_name !== undefined) {
+        score += 70;
+    }
+    if (matcher.message_equals !== undefined) {
+        score += 60;
+    }
+    if (matcher.message_contains !== undefined) {
+        score += 50;
+    }
+    if (matcher.first_party !== undefined) {
+        score += 40;
+    }
+    if (matcher.services !== undefined) {
+        score += 30;
+    }
+    if (matcher.environments !== undefined) {
+        score += 20;
+    }
+    if (matcher.runtime !== undefined) {
+        score += 10;
+    }
+    if (matcher.event_types !== undefined) {
+        score += 5;
+    }
+    return score;
+}
+function compareRules(left, right) {
+    const specificityDifference = getSpecificityScore(right) - getSpecificityScore(left);
+    if (specificityDifference !== 0) {
+        return specificityDifference;
+    }
+    const updatedDifference = Date.parse(right.updated_at) - Date.parse(left.updated_at);
+    if (updatedDifference !== 0) {
+        return updatedDifference;
+    }
+    return left.id.localeCompare(right.id);
+}
+function stableUnitFloat(seed) {
+    let hash = 2166136261;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash ^= seed.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0) / 0x100000000;
+}
+function shouldSample(projectId, ruleId, eventId, sampleRate) {
+    if (sampleRate <= 0) {
+        return false;
+    }
+    if (sampleRate >= 1) {
+        return true;
+    }
+    return stableUnitFloat(`${projectId}:${ruleId}:${eventId}`) < sampleRate;
+}
+export function evaluateBrowserCaptureRulesForEvent(rules, projectId, event, now) {
+    const context = buildEvaluationContext(projectId, event);
+    const activeRules = rules
+        .filter((rule) => rule.enabled && (rule.expires_at === null || Date.parse(rule.expires_at) > Date.parse(now)))
+        .sort(compareRules);
+    for (const rule of activeRules) {
+        if (!matchesRule(rule, context)) {
+            continue;
+        }
+        if (rule.action === "demote") {
+            return {
+                rule_id: rule.id,
+                action: "demote",
+                outcome: "demote",
+                sample_rate: null,
+                sample_event_class: null
+            };
+        }
+        if (rule.action === "drop") {
+            return {
+                rule_id: rule.id,
+                action: "drop",
+                outcome: "drop",
+                sample_rate: null,
+                sample_event_class: null
+            };
+        }
+        const sampledIn = shouldSample(projectId, rule.id, event.event_id, rule.sample_rate ?? 0);
+        return {
+            rule_id: rule.id,
+            action: "sample",
+            outcome: sampledIn ? "sampled_in" : "sampled_out",
+            sample_rate: rule.sample_rate,
+            sample_event_class: rule.sample_event_class
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=capture-rules.js.map