@keystrokehq/sentry 0.0.15 → 0.0.16-integration-id-canonicalization.0

package/dist/alerts.mjs

@@ -1,300 +0,0 @@
-import { orgProjectScopeInputSchema, orgScopeInputSchema, sentryIdSchema, sentryIssueAlertRuleSchema, sentryJsonObjectSchema, sentryListInputSchema, sentryMetricAlertRuleSchema } from "./schemas.mjs";
-import { t as defineSentryEndpoint } from "./endpoint-factory-DcT49a8O.mjs";
-import { t as SENTRY_SCOPE } from "./scopes-RRU0vt-a.mjs";
-import { z } from "zod";
-
-//#region src/alerts.ts
-/**
-* Sentry alert-rule operations (metric + issue alert rules).
-* Maps to PLAN.md §6.11 (11 actions).
-*/
-const ORG = [{
-	name: "organization_slug",
-	placeholder: "{organization_slug}"
-}];
-const ORG_RULE = [...ORG, {
-	name: "alert_rule_id",
-	placeholder: "{alert_rule_id}"
-}];
-const ORG_PROJECT = [...ORG, {
-	name: "project_slug",
-	placeholder: "{project_slug}"
-}];
-const ORG_PROJECT_RULE = [...ORG_PROJECT, {
-	name: "rule_id",
-	placeholder: "{rule_id}"
-}];
-const createOrganizationAlertRule = defineSentryEndpoint({
-	id: "sentry.create-organization-alert-rule",
-	name: "Create Metric Alert Rule",
-	description: "Create a new organization metric alert rule.",
-	method: "POST",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/",
-	pathParams: ORG,
-	input: orgScopeInputSchema.extend({
-		name: z.string().min(1),
-		dataset: z.string().optional(),
-		query: z.string().optional(),
-		aggregate: z.string().min(1),
-		timeWindow: z.number().int(),
-		projects: z.array(z.string()).min(1),
-		environment: z.string().optional(),
-		comparisonDelta: z.number().int().optional(),
-		resolveThreshold: z.number().optional(),
-		thresholdType: z.number().int().optional(),
-		triggers: z.array(sentryJsonObjectSchema).min(1),
-		owner: z.string().nullable().optional()
-	}),
-	bodyFields: [
-		"name",
-		"dataset",
-		"query",
-		"aggregate",
-		"timeWindow",
-		"projects",
-		"environment",
-		"comparisonDelta",
-		"resolveThreshold",
-		"thresholdType",
-		"triggers",
-		"owner"
-	],
-	output: sentryMetricAlertRuleSchema,
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const fetchOrganizationAlertRules = defineSentryEndpoint({
-	id: "sentry.fetch-organization-alert-rules",
-	name: "List Metric Alert Rules",
-	description: "List organization metric alert rules.",
-	method: "GET",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/",
-	pathParams: ORG,
-	input: sentryListInputSchema.merge(orgScopeInputSchema),
-	queryFields: [
-		"cursor",
-		"per_page",
-		"query"
-	],
-	output: z.array(sentryMetricAlertRuleSchema),
-	pagination: "cursor",
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsRead]
-});
-const retrieveAlertRuleDetails = defineSentryEndpoint({
-	id: "sentry.retrieve-alert-rule-details",
-	name: "Retrieve Metric Alert Rule",
-	description: "Fetch a metric alert rule by id.",
-	method: "GET",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/{alert_rule_id}/",
-	pathParams: ORG_RULE,
-	input: orgScopeInputSchema.extend({ alert_rule_id: sentryIdSchema }),
-	output: sentryMetricAlertRuleSchema,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsRead]
-});
-const updateOrganizationAlertRules = defineSentryEndpoint({
-	id: "sentry.update-organization-alert-rules",
-	name: "Update Metric Alert Rule",
-	description: "Update a metric alert rule in place.",
-	method: "PUT",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/{alert_rule_id}/",
-	pathParams: ORG_RULE,
-	input: orgScopeInputSchema.extend({
-		alert_rule_id: sentryIdSchema,
-		name: z.string().optional(),
-		dataset: z.string().optional(),
-		query: z.string().optional(),
-		aggregate: z.string().optional(),
-		timeWindow: z.number().int().optional(),
-		projects: z.array(z.string()).optional(),
-		environment: z.string().optional(),
-		comparisonDelta: z.number().int().optional(),
-		resolveThreshold: z.number().optional(),
-		thresholdType: z.number().int().optional(),
-		triggers: z.array(sentryJsonObjectSchema).optional(),
-		owner: z.string().nullable().optional()
-	}),
-	bodyFields: [
-		"name",
-		"dataset",
-		"query",
-		"aggregate",
-		"timeWindow",
-		"projects",
-		"environment",
-		"comparisonDelta",
-		"resolveThreshold",
-		"thresholdType",
-		"triggers",
-		"owner"
-	],
-	output: sentryMetricAlertRuleSchema,
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const deleteOrganizationAlertRule = defineSentryEndpoint({
-	id: "sentry.delete-organization-alert-rule",
-	name: "Delete Metric Alert Rule",
-	description: "Delete a metric alert rule by id.",
-	method: "DELETE",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/{alert_rule_id}/",
-	pathParams: ORG_RULE,
-	input: orgScopeInputSchema.extend({ alert_rule_id: sentryIdSchema }),
-	output: z.unknown(),
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const getActivationOfAlertRuleForOrganization = defineSentryEndpoint({
-	id: "sentry.get-activation-of-alert-rule-for-organization",
-	name: "Get Alert Rule Activation",
-	description: "Fetch the activation history for a metric alert rule.",
-	method: "GET",
-	path: "/api/0/organizations/{organization_slug}/alert-rules/{alert_rule_id}/activations/",
-	pathParams: ORG_RULE,
-	input: orgScopeInputSchema.extend({
-		alert_rule_id: sentryIdSchema,
-		cursor: z.string().optional(),
-		per_page: z.number().int().optional()
-	}),
-	queryFields: ["cursor", "per_page"],
-	output: z.array(sentryJsonObjectSchema),
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsRead]
-});
-const createProjectRuleForAlerts = defineSentryEndpoint({
-	id: "sentry.create-project-rule-for-alerts",
-	name: "Create Issue Alert Rule",
-	description: "Create a project issue alert rule.",
-	method: "POST",
-	path: "/api/0/projects/{organization_slug}/{project_slug}/rules/",
-	pathParams: ORG_PROJECT,
-	input: orgProjectScopeInputSchema.extend({
-		name: z.string().min(1),
-		actionMatch: z.enum([
-			"all",
-			"any",
-			"none"
-		]),
-		filterMatch: z.enum([
-			"all",
-			"any",
-			"none"
-		]).optional(),
-		frequency: z.number().int(),
-		conditions: z.array(sentryJsonObjectSchema),
-		filters: z.array(sentryJsonObjectSchema).optional(),
-		actions: z.array(sentryJsonObjectSchema),
-		environment: z.string().nullable().optional(),
-		owner: z.string().nullable().optional()
-	}),
-	bodyFields: [
-		"name",
-		"actionMatch",
-		"filterMatch",
-		"frequency",
-		"conditions",
-		"filters",
-		"actions",
-		"environment",
-		"owner"
-	],
-	output: sentryIssueAlertRuleSchema,
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const retrieveProjectRulesByOrgAndProjectId = defineSentryEndpoint({
-	id: "sentry.retrieve-project-rules-by-org-and-project-id",
-	name: "List Issue Alert Rules",
-	description: "List project issue alert rules.",
-	method: "GET",
-	path: "/api/0/projects/{organization_slug}/{project_slug}/rules/",
-	pathParams: ORG_PROJECT,
-	input: sentryListInputSchema.merge(orgProjectScopeInputSchema),
-	queryFields: [
-		"cursor",
-		"per_page",
-		"query"
-	],
-	output: z.array(sentryIssueAlertRuleSchema),
-	pagination: "cursor",
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsRead]
-});
-const getProjectRuleDetails = defineSentryEndpoint({
-	id: "sentry.get-project-rule-details",
-	name: "Get Issue Alert Rule",
-	description: "Fetch a single issue alert rule by id.",
-	method: "GET",
-	path: "/api/0/projects/{organization_slug}/{project_slug}/rules/{rule_id}/",
-	pathParams: ORG_PROJECT_RULE,
-	input: orgProjectScopeInputSchema.extend({ rule_id: sentryIdSchema }),
-	output: sentryIssueAlertRuleSchema,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsRead]
-});
-const updateProjectRuleById = defineSentryEndpoint({
-	id: "sentry.update-project-rule-by-id",
-	name: "Update Issue Alert Rule",
-	description: "Update a project issue alert rule.",
-	method: "PUT",
-	path: "/api/0/projects/{organization_slug}/{project_slug}/rules/{rule_id}/",
-	pathParams: ORG_PROJECT_RULE,
-	input: orgProjectScopeInputSchema.extend({
-		rule_id: sentryIdSchema,
-		name: z.string().optional(),
-		actionMatch: z.enum([
-			"all",
-			"any",
-			"none"
-		]).optional(),
-		filterMatch: z.enum([
-			"all",
-			"any",
-			"none"
-		]).optional(),
-		frequency: z.number().int().optional(),
-		conditions: z.array(sentryJsonObjectSchema).optional(),
-		filters: z.array(sentryJsonObjectSchema).optional(),
-		actions: z.array(sentryJsonObjectSchema).optional(),
-		environment: z.string().nullable().optional(),
-		owner: z.string().nullable().optional()
-	}),
-	bodyFields: [
-		"name",
-		"actionMatch",
-		"filterMatch",
-		"frequency",
-		"conditions",
-		"filters",
-		"actions",
-		"environment",
-		"owner"
-	],
-	output: sentryIssueAlertRuleSchema,
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const deleteProjectRule = defineSentryEndpoint({
-	id: "sentry.delete-project-rule",
-	name: "Delete Issue Alert Rule",
-	description: "Delete a project issue alert rule.",
-	method: "DELETE",
-	path: "/api/0/projects/{organization_slug}/{project_slug}/rules/{rule_id}/",
-	pathParams: ORG_PROJECT_RULE,
-	input: orgProjectScopeInputSchema.extend({ rule_id: sentryIdSchema }),
-	output: z.unknown(),
-	needsApproval: true,
-	requiredOAuthScopes: [...SENTRY_SCOPE.alertsWrite]
-});
-const sentryAlertOperations = {
-	createOrganizationAlertRule,
-	fetchOrganizationAlertRules,
-	retrieveAlertRuleDetails,
-	updateOrganizationAlertRules,
-	deleteOrganizationAlertRule,
-	getActivationOfAlertRuleForOrganization,
-	createProjectRuleForAlerts,
-	retrieveProjectRulesByOrgAndProjectId,
-	getProjectRuleDetails,
-	updateProjectRuleById,
-	deleteProjectRule
-};
-
-//#endregion
-export { createOrganizationAlertRule, createProjectRuleForAlerts, deleteOrganizationAlertRule, deleteProjectRule, fetchOrganizationAlertRules, getActivationOfAlertRuleForOrganization, getProjectRuleDetails, retrieveAlertRuleDetails, retrieveProjectRulesByOrgAndProjectId, sentryAlertOperations, updateOrganizationAlertRules, updateProjectRuleById };

package/dist/client.d.mts

@@ -1,86 +0,0 @@
-//#region src/client.d.ts
-/**
- * Typed fetch-based client for the Sentry management API.
- *
- * The factory accepts the public connection credentials
- * (`SentryCredentials`) and returns a thin object with one method per HTTP
- * verb, plus a `paginate` helper that walks Sentry's `Link`-header cursor
- * chain and yields decoded results one batch at a time.
- *
- * Design notes:
- * - All requests go through `request()` so retry, DSN rejection, and error
- *   normalization live in one place.
- * - Retry policy: honours `Retry-After` on 429 and does exponential backoff
- *   with jitter on 5xx; all other 4xx responses throw immediately.
- * - Base URL: `SENTRY_REGION_URL` (persisted at install time by the OAuth
- *   hook) wins; otherwise default `https://sentry.io`. Self-hosted deployments
- *   override the region URL.
- * - The SDK path is `/api/0/` on whatever base URL the caller resolved.
- */
-interface SentryCredentials {
-  readonly SENTRY_ACCESS_TOKEN: string;
-  readonly SENTRY_REGION_URL?: string;
-  readonly SENTRY_ORG_SLUG?: string;
-}
-interface SentryClientOptions {
-  /** Override the fetch implementation. Used by tests and by edge runtimes. */
-  readonly fetch?: typeof fetch;
-  /** Max retry attempts on retryable status codes (default 3). */
-  readonly maxRetries?: number;
-  /** Base backoff in ms for 5xx retries (default 250). */
-  readonly retryBaseDelayMs?: number;
-  /**
-   * Max delay (ms) between retries. Clamps the exponential backoff so one
-   * request does not block the caller for more than `maxDelayMs` per wait.
-   * Default 30 seconds.
-   */
-  readonly maxDelayMs?: number;
-  /** Per-request timeout in ms (default 30_000). */
-  readonly timeoutMs?: number;
-  /** Hook used to sleep between retries; overridden by tests. */
-  readonly sleep?: (ms: number) => Promise<void>;
-}
-interface SentryRequestInit {
-  readonly method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  readonly path: string;
-  readonly query?: Readonly<Record<string, unknown>>;
-  readonly body?: unknown;
-  readonly headers?: Readonly<Record<string, string>>;
-  /** Tell the client to return the raw `Response` instead of parsing JSON. */
-  readonly parseAs?: 'json' | 'text' | 'none';
-  /** Override the default content type. */
-  readonly contentType?: string;
-  /** Pre-encoded body (used for multipart/form uploads). */
-  readonly rawBody?: RequestInit['body'];
-}
-interface SentryResponseEnvelope<T = unknown> {
-  readonly data: T;
-  readonly status: number;
-  readonly headers: Headers;
-  readonly nextCursor: string | null;
-  readonly previousCursor: string | null;
-}
-declare const SENTRY_DEFAULT_BASE_URL = "https://sentry.io";
-interface SentryClient {
-  readonly get: <T>(path: string, query?: Readonly<Record<string, unknown>>) => Promise<SentryResponseEnvelope<T>>;
-  readonly post: <T>(path: string, body?: unknown, query?: Readonly<Record<string, unknown>>) => Promise<SentryResponseEnvelope<T>>;
-  readonly put: <T>(path: string, body?: unknown, query?: Readonly<Record<string, unknown>>) => Promise<SentryResponseEnvelope<T>>;
-  readonly patch: <T>(path: string, body?: unknown, query?: Readonly<Record<string, unknown>>) => Promise<SentryResponseEnvelope<T>>;
-  readonly delete: <T>(path: string, query?: Readonly<Record<string, unknown>>) => Promise<SentryResponseEnvelope<T>>;
-  /** Iterates every page yielded by a `GET` list endpoint. */
-  readonly paginate: <T>(path: string, query?: Readonly<Record<string, unknown>>) => AsyncGenerator<SentryResponseEnvelope<T>, void, void>;
-  /**
-   * Concatenates all pages of a list endpoint into a single array. Use this
-   * for endpoints where the full resource fits in memory (most Sentry list
-   * endpoints have small natural bounds: teams, projects, members, alert
-   * rules).
-   */
-  readonly listAll: <TItem>(path: string, query?: Readonly<Record<string, unknown>>) => Promise<readonly TItem[]>;
-  /** Escape hatch for multipart uploads and callers who need the full init shape. */
-  readonly request: <T>(init: SentryRequestInit) => Promise<SentryResponseEnvelope<T>>;
-  /** Resolves the base URL that credentials would use. Exposed for tests. */
-  readonly resolveBaseUrl: () => string;
-}
-declare function createSentryClient(credentials: SentryCredentials, options?: SentryClientOptions): SentryClient;
-//#endregion
-export { SENTRY_DEFAULT_BASE_URL, SentryClient, SentryClientOptions, SentryCredentials, SentryRequestInit, SentryResponseEnvelope, createSentryClient };

package/dist/client.mjs

@@ -1,233 +0,0 @@
-import { r as classifyHttpResponse, t as SentryApiError } from "./errors-DfEFwcTe.mjs";
-import { n as parseSentryLinkHeader, t as looksLikeSentryDsn } from "./pagination-PlgAqbZt.mjs";
-
-//#region src/client.ts
-/**
-* Typed fetch-based client for the Sentry management API.
-*
-* The factory accepts the public connection credentials
-* (`SentryCredentials`) and returns a thin object with one method per HTTP
-* verb, plus a `paginate` helper that walks Sentry's `Link`-header cursor
-* chain and yields decoded results one batch at a time.
-*
-* Design notes:
-* - All requests go through `request()` so retry, DSN rejection, and error
-*   normalization live in one place.
-* - Retry policy: honours `Retry-After` on 429 and does exponential backoff
-*   with jitter on 5xx; all other 4xx responses throw immediately.
-* - Base URL: `SENTRY_REGION_URL` (persisted at install time by the OAuth
-*   hook) wins; otherwise default `https://sentry.io`. Self-hosted deployments
-*   override the region URL.
-* - The SDK path is `/api/0/` on whatever base URL the caller resolved.
-*/
-const SENTRY_DEFAULT_BASE_URL = "https://sentry.io";
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_BASE_DELAY_MS = 250;
-const DEFAULT_MAX_DELAY_MS = 3e4;
-const DEFAULT_TIMEOUT_MS = 3e4;
-function createSentryClient(credentials, options = {}) {
-	const token = credentials.SENTRY_ACCESS_TOKEN;
-	if (looksLikeSentryDsn(token)) throw new SentryApiError({
-		kind: "dsn_detected",
-		message: "A Sentry DSN was passed in place of a management-API bearer token. DSNs can only be used to send events; the management API requires an OAuth access token, auth token, or internal integration token.",
-		status: null,
-		providerCode: null,
-		requestId: null,
-		retryable: false,
-		retryAfterSec: null
-	});
-	const baseUrl = (credentials.SENTRY_REGION_URL ?? SENTRY_DEFAULT_BASE_URL).replace(/\/$/u, "");
-	const fetchImpl = options.fetch ?? fetch;
-	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-	const retryBaseDelayMs = options.retryBaseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-	const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-	async function request(init) {
-		const url = buildUrl(baseUrl, init.path, init.query);
-		const headers = {
-			Authorization: `Bearer ${token}`,
-			Accept: "application/json",
-			...init.headers ?? {}
-		};
-		let body;
-		if (init.rawBody !== void 0) body = init.rawBody;
-		else if (init.body !== void 0 && init.method !== "GET" && init.method !== "DELETE") if (init.contentType === "application/x-www-form-urlencoded") {
-			headers["Content-Type"] = "application/x-www-form-urlencoded";
-			body = new URLSearchParams(init.body).toString();
-		} else {
-			headers["Content-Type"] = init.contentType ?? "application/json";
-			body = typeof init.body === "string" || init.body instanceof ArrayBuffer ? init.body : JSON.stringify(init.body);
-		}
-		let attempt = 0;
-		while (true) {
-			attempt += 1;
-			const controller = new AbortController();
-			const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
-			let response;
-			try {
-				response = await fetchImpl(url, {
-					method: init.method,
-					headers,
-					body,
-					signal: controller.signal
-				});
-			} catch (cause) {
-				clearTimeout(timeoutHandle);
-				if (attempt > maxRetries) throw new SentryApiError({
-					kind: "network",
-					message: `Sentry API network error: ${extractCauseMessage(cause)}`,
-					status: null,
-					providerCode: null,
-					requestId: null,
-					retryable: true,
-					retryAfterSec: null,
-					cause
-				});
-				await sleep(computeBackoffDelay(attempt, retryBaseDelayMs, maxDelayMs));
-				continue;
-			}
-			clearTimeout(timeoutHandle);
-			if (response.ok) {
-				const data = await parseResponseBody(response, init.parseAs ?? "json");
-				const links = parseSentryLinkHeader(response.headers.get("link"));
-				return {
-					data,
-					status: response.status,
-					headers: response.headers,
-					nextCursor: links.next?.results ? links.next.cursor : null,
-					previousCursor: links.previous?.results ? links.previous.cursor : null
-				};
-			}
-			const errorBody = await parseErrorBody(response);
-			const error = classifyHttpResponse(response, errorBody);
-			if (!error.retryable || attempt > maxRetries) throw error;
-			await sleep(error.retryAfterSec != null ? Math.min(error.retryAfterSec * 1e3, maxDelayMs) : computeBackoffDelay(attempt, retryBaseDelayMs, maxDelayMs));
-		}
-	}
-	async function get(path, query) {
-		return request({
-			method: "GET",
-			path,
-			query
-		});
-	}
-	async function post(path, bodyValue, query) {
-		return request({
-			method: "POST",
-			path,
-			body: bodyValue,
-			query
-		});
-	}
-	async function put(path, bodyValue, query) {
-		return request({
-			method: "PUT",
-			path,
-			body: bodyValue,
-			query
-		});
-	}
-	async function patch(path, bodyValue, query) {
-		return request({
-			method: "PATCH",
-			path,
-			body: bodyValue,
-			query
-		});
-	}
-	async function del(path, query) {
-		return request({
-			method: "DELETE",
-			path,
-			query,
-			parseAs: "none"
-		});
-	}
-	async function* paginate(path, query = {}) {
-		let cursor = null;
-		do {
-			const merged = { ...query };
-			if (cursor != null) merged.cursor = cursor;
-			const page = await get(path, merged);
-			yield page;
-			cursor = page.nextCursor;
-		} while (cursor !== null);
-	}
-	async function listAll(path, query) {
-		const acc = [];
-		for await (const page of paginate(path, query)) acc.push(...page.data);
-		return acc;
-	}
-	return {
-		get,
-		post,
-		put,
-		patch,
-		delete: del,
-		paginate,
-		listAll,
-		request,
-		resolveBaseUrl: () => baseUrl
-	};
-}
-function buildUrl(baseUrl, path, query) {
-	const base = `${baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
-	if (!query) return base;
-	const params = new URLSearchParams();
-	for (const [key, value] of Object.entries(query)) {
-		if (value == null) continue;
-		if (Array.isArray(value)) for (const v of value) {
-			if (v == null) continue;
-			params.append(key, String(v));
-		}
-		else if (typeof value === "boolean") params.append(key, value ? "true" : "false");
-		else params.append(key, String(value));
-	}
-	const qs = params.toString();
-	return qs ? `${base}?${qs}` : base;
-}
-async function parseResponseBody(response, mode) {
-	if (mode === "none") return void 0;
-	if (mode === "text") return await response.text();
-	if (response.status === 204) return void 0;
-	const raw = await response.text();
-	if (raw.length === 0) return void 0;
-	try {
-		return JSON.parse(raw);
-	} catch (cause) {
-		throw new SentryApiError({
-			kind: "http",
-			message: `Sentry API returned non-JSON body (status ${response.status})`,
-			status: response.status,
-			providerCode: null,
-			requestId: response.headers.get("x-request-id"),
-			retryable: false,
-			retryAfterSec: null,
-			responseBody: raw,
-			cause
-		});
-	}
-}
-async function parseErrorBody(response) {
-	const raw = await response.text();
-	if (raw.length === 0) return null;
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return raw;
-	}
-}
-function computeBackoffDelay(attempt, baseMs, maxMs) {
-	const exponential = baseMs * 2 ** Math.max(0, attempt - 1);
-	const jitter = Math.random() * baseMs;
-	return Math.min(exponential + jitter, maxMs);
-}
-function extractCauseMessage(cause) {
-	if (cause instanceof Error) return cause.message;
-	if (typeof cause === "string") return cause;
-	return "unknown network error";
-}
-
-//#endregion
-export { SENTRY_DEFAULT_BASE_URL, createSentryClient };

package/dist/connection.d.mts

@@ -1,3 +0,0 @@
-import { n as sentry, t as SentryIntegrationCredentials } from "./integration-veqa_7yB.mjs";
-import { SentryCredentials } from "./client.mjs";
-export { type SentryCredentials, type SentryIntegrationCredentials, sentry };

package/dist/connection.mjs

@@ -1,3 +0,0 @@
-import { t as sentry } from "./integration-D7KCM1-p.mjs";
-
-export { sentry };