@interfere/types 8.1.1 → 8.1.6

package/dist/sdk/envelope.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"envelope.d.mts","names":[],"sources":["../../src/sdk/envelope.ts"],"mappings":";;;;;AA0BA;;;;;;cAAa,mBAAA,EAAmB,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,OAAA;;;;;;KAIpB,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,cAE9B,qBAAA,EAAqB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAgBhC,cAAA,EAAc,CAAA,CAAA,eAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BtB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,KAEvB,SAAA,GAAY,YAAA;AAAA,KAEZ,QAAA,WAAmB,SAAA,4BAC7B,CAAA,SAAU,SAAA,GAAY,OAAA,CAAQ,YAAA;EAAgB,IAAA,EAAM,CAAA;AAAA,KAAO,YAAA;AAAA,KAEjD,eAAA,WAA0B,SAAA,IAAa,QAAA,CAAS,CAAA"}
+{"version":3,"file":"envelope.d.mts","names":[],"sources":["../../src/sdk/envelope.ts"],"mappings":"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"}

package/dist/sdk/envelope.mjs

@@ -9,7 +9,6 @@ import { rageClickPayloadSchema } from "#sdk/plugins/payload/rage-click";
 import { replayChunkPayloadSchema } from "#sdk/plugins/payload/replay";
 import { envSchema, runtimeSchema } from "#sdk/runtime";
 //#region src/sdk/envelope.ts
-const envelopeVersion = z.union([z.literal(0)]);
 /**
 * Indicates how the sessionId was resolved on the server.
 *
@@ -23,13 +22,21 @@ const sessionSourceSchema = z.enum([
 	"async_context",
 	"fallback",
 	"client"
-]).optional();
+]).optional().meta({
+	id: "SessionSource",
+	title: "SessionSource",
+	description: "How the server resolved the sessionId for this envelope."
+});
 const envelopeContextSchema = z.discriminatedUnion("runtime", [
 	browserContextSchema,
 	nextjsContextSchema,
 	edgeContextSchema
-]);
-const envelopeSchema = z.object({
+]).meta({
+	id: "EnvelopeContext",
+	title: "EnvelopeContext",
+	description: "Runtime-specific request context attached to every envelope."
+});
+const envelopeHeadersShape = {
 	buildId: z.string(),
 	clientTs: z.int(),
 	context: envelopeContextSchema.optional(),
@@ -37,35 +44,71 @@ const envelopeSchema = z.object({
 	producerVersion: z.string().optional(),
 	releaseId: z.string().nullable(),
 	runtime: runtimeSchema,
+	sdkStack: z.array(z.string()).optional(),
 	sessionId: sessionIdSchema.nullable(),
 	sessionSource: sessionSourceSchema,
 	uuid: z.uuidv7(),
-	v: envelopeVersion
-}).and(z.discriminatedUnion("type", [
-	z.object({
-		payload: errorEnvelopePayloadSchema,
-		type: z.literal("error")
-	}),
-	z.object({
-		payload: pageviewPayloadSchema,
-		type: z.literal("pageview")
-	}),
-	z.object({
-		payload: pageleavePayloadSchema,
-		type: z.literal("pageleave")
-	}),
-	z.object({
-		payload: uiEventPayloadSchema,
-		type: z.literal("ui_event")
-	}),
-	z.object({
-		payload: replayChunkPayloadSchema,
-		type: z.literal("replay_chunk")
-	}),
-	z.object({
-		payload: rageClickPayloadSchema,
-		type: z.literal("rage_click")
-	})
-]));
+	v: z.literal(0)
+};
+const errorEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("error"),
+	payload: errorEnvelopePayloadSchema
+}).meta({
+	id: "ErrorEnvelope",
+	title: "ErrorEnvelope"
+});
+const pageviewEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("pageview"),
+	payload: pageviewPayloadSchema
+}).meta({
+	id: "PageviewEnvelope",
+	title: "PageviewEnvelope"
+});
+const pageleaveEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("pageleave"),
+	payload: pageleavePayloadSchema
+}).meta({
+	id: "PageleaveEnvelope",
+	title: "PageleaveEnvelope"
+});
+const uiEventEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("ui_event"),
+	payload: uiEventPayloadSchema
+}).meta({
+	id: "UiEventEnvelope",
+	title: "UiEventEnvelope"
+});
+const replayChunkEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("replay_chunk"),
+	payload: replayChunkPayloadSchema
+}).meta({
+	id: "ReplayChunkEnvelope",
+	title: "ReplayChunkEnvelope"
+});
+const rageClickEnvelopeSchema = z.object({
+	...envelopeHeadersShape,
+	type: z.literal("rage_click"),
+	payload: rageClickPayloadSchema
+}).meta({
+	id: "RageClickEnvelope",
+	title: "RageClickEnvelope"
+});
+const envelopeSchema = z.discriminatedUnion("type", [
+	errorEnvelopeSchema,
+	pageviewEnvelopeSchema,
+	pageleaveEnvelopeSchema,
+	uiEventEnvelopeSchema,
+	replayChunkEnvelopeSchema,
+	rageClickEnvelopeSchema
+]).meta({
+	id: "Envelope",
+	title: "Envelope",
+	description: "A single event envelope accepted by the collector."
+});
 //#endregion
-export { envelopeContextSchema, envelopeSchema, sessionSourceSchema };
+export { envelopeContextSchema, envelopeSchema, errorEnvelopeSchema, pageleaveEnvelopeSchema, pageviewEnvelopeSchema, rageClickEnvelopeSchema, replayChunkEnvelopeSchema, sessionSourceSchema, uiEventEnvelopeSchema };

package/dist/sdk/envelope.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"envelope.mjs","names":[],"sources":["../../src/sdk/envelope.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { sessionIdSchema } from \"#data/session\";\nimport { browserContextSchema } from \"#sdk/plugins/context/browser\";\nimport { edgeContextSchema } from \"#sdk/plugins/context/edge\";\nimport { nextjsContextSchema } from \"#sdk/plugins/context/next\";\nimport { errorEnvelopePayloadSchema } from \"#sdk/plugins/payload/errors\";\nimport {\n  pageleavePayloadSchema,\n  pageviewPayloadSchema,\n  uiEventPayloadSchema,\n} from \"#sdk/plugins/payload/page-events\";\nimport { rageClickPayloadSchema } from \"#sdk/plugins/payload/rage-click\";\nimport { replayChunkPayloadSchema } from \"#sdk/plugins/payload/replay\";\nimport { envSchema, runtimeSchema } from \"#sdk/runtime\";\n\nconst envelopeVersion = z.union([z.literal(0)]);\n\n/**\n * Indicates how the sessionId was resolved on the server.\n *\n * - \"header\": Extracted from x-interfere-request header (ideal case)\n * - \"async_context\": Retrieved from AsyncLocalStorage context\n * - \"fallback\": Generated as server-side fallback (breaks session continuity)\n * - \"client\": Session ID was set on the client (browser SDK)\n */\nexport const sessionSourceSchema = z\n  .enum([\"header\", \"async_context\", \"fallback\", \"client\"])\n  .optional();\n\nexport type SessionSource = z.infer<typeof sessionSourceSchema>;\n\nexport const envelopeContextSchema = z.discriminatedUnion(\"runtime\", [\n  browserContextSchema,\n  nextjsContextSchema,\n  edgeContextSchema,\n]);\n\nexport type EnvelopeContext = z.infer<typeof envelopeContextSchema>;\n\nconst envelopeHeadersSchema = z.object({\n  buildId: z.string(),\n  clientTs: z.int(),\n  context: envelopeContextSchema.optional(),\n  environment: envSchema,\n  producerVersion: z.string().optional(),\n  releaseId: z.string().nullable(),\n  runtime: runtimeSchema,\n  sessionId: sessionIdSchema.nullable(),\n  sessionSource: sessionSourceSchema,\n  uuid: z.uuidv7(),\n  v: envelopeVersion,\n});\n\nexport const envelopeSchema = envelopeHeadersSchema.and(\n  z.discriminatedUnion(\"type\", [\n    z.object({\n      payload: errorEnvelopePayloadSchema,\n      type: z.literal(\"error\"),\n    }),\n    z.object({\n      payload: pageviewPayloadSchema,\n      type: z.literal(\"pageview\"),\n    }),\n    z.object({\n      payload: pageleavePayloadSchema,\n      type: z.literal(\"pageleave\"),\n    }),\n    z.object({\n      payload: uiEventPayloadSchema,\n      type: z.literal(\"ui_event\"),\n    }),\n    z.object({\n      payload: replayChunkPayloadSchema,\n      type: z.literal(\"replay_chunk\"),\n    }),\n    z.object({\n      payload: rageClickPayloadSchema,\n      type: z.literal(\"rage_click\"),\n    }),\n  ])\n);\n\ntype EnvelopeBase = z.infer<typeof envelopeSchema>;\n\nexport type EventType = EnvelopeBase[\"type\"];\n\nexport type Envelope<T extends EventType | undefined = undefined> =\n  T extends EventType ? Extract<EnvelopeBase, { type: T }> : EnvelopeBase;\n\nexport type EnvelopePayload<T extends EventType> = Envelope<T>[\"payload\"];\n"],"mappings":";;;;;;;;;;;AAgBA,MAAM,kBAAkB,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;;;;;;;;;AAU/C,MAAa,sBAAsB,EAChC,KAAK;CAAC;CAAU;CAAiB;CAAY;CAAS,CAAC,CACvD,UAAU;AAIb,MAAa,wBAAwB,EAAE,mBAAmB,WAAW;CACnE;CACA;CACA;CACD,CAAC;AAkBF,MAAa,iBAdiB,EAAE,OAAO;CACrC,SAAS,EAAE,QAAQ;CACnB,UAAU,EAAE,KAAK;CACjB,SAAS,sBAAsB,UAAU;CACzC,aAAa;CACb,iBAAiB,EAAE,QAAQ,CAAC,UAAU;CACtC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,SAAS;CACT,WAAW,gBAAgB,UAAU;CACrC,eAAe;CACf,MAAM,EAAE,QAAQ;CAChB,GAAG;CACJ,CAAC,CAEkD,IAClD,EAAE,mBAAmB,QAAQ;CAC3B,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,QAAQ;EACzB,CAAC;CACF,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,WAAW;EAC5B,CAAC;CACF,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,YAAY;EAC7B,CAAC;CACF,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,WAAW;EAC5B,CAAC;CACF,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,eAAe;EAChC,CAAC;CACF,EAAE,OAAO;EACP,SAAS;EACT,MAAM,EAAE,QAAQ,aAAa;EAC9B,CAAC;CACH,CAAC,CACH"}
+{"version":3,"file":"envelope.mjs","names":[],"sources":["../../src/sdk/envelope.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { sessionIdSchema } from \"#data/session\";\nimport { browserContextSchema } from \"#sdk/plugins/context/browser\";\nimport { edgeContextSchema } from \"#sdk/plugins/context/edge\";\nimport { nextjsContextSchema } from \"#sdk/plugins/context/next\";\nimport { errorEnvelopePayloadSchema } from \"#sdk/plugins/payload/errors\";\nimport {\n  pageleavePayloadSchema,\n  pageviewPayloadSchema,\n  uiEventPayloadSchema,\n} from \"#sdk/plugins/payload/page-events\";\nimport { rageClickPayloadSchema } from \"#sdk/plugins/payload/rage-click\";\nimport { replayChunkPayloadSchema } from \"#sdk/plugins/payload/replay\";\nimport { envSchema, runtimeSchema } from \"#sdk/runtime\";\n\n/**\n * Indicates how the sessionId was resolved on the server.\n *\n * - \"header\": Extracted from x-interfere-request header (ideal case)\n * - \"async_context\": Retrieved from AsyncLocalStorage context\n * - \"fallback\": Generated as server-side fallback (breaks session continuity)\n * - \"client\": Session ID was set on the client (browser SDK)\n */\nexport const sessionSourceSchema = z\n  .enum([\"header\", \"async_context\", \"fallback\", \"client\"])\n  .optional()\n  .meta({\n    id: \"SessionSource\",\n    title: \"SessionSource\",\n    description: \"How the server resolved the sessionId for this envelope.\",\n  });\n\nexport type SessionSource = z.infer<typeof sessionSourceSchema>;\n\nexport const envelopeContextSchema = z\n  .discriminatedUnion(\"runtime\", [\n    browserContextSchema,\n    nextjsContextSchema,\n    edgeContextSchema,\n  ])\n  .meta({\n    id: \"EnvelopeContext\",\n    title: \"EnvelopeContext\",\n    description: \"Runtime-specific request context attached to every envelope.\",\n  });\n\nexport type EnvelopeContext = z.infer<typeof envelopeContextSchema>;\n\nconst envelopeHeadersShape = {\n  buildId: z.string(),\n  clientTs: z.int(),\n  context: envelopeContextSchema.optional(),\n  environment: envSchema,\n  producerVersion: z.string().optional(),\n  releaseId: z.string().nullable(),\n  runtime: runtimeSchema,\n  sdkStack: z.array(z.string()).optional(),\n  sessionId: sessionIdSchema.nullable(),\n  sessionSource: sessionSourceSchema,\n  uuid: z.uuidv7(),\n  v: z.literal(0),\n} as const;\n\nexport const errorEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"error\"),\n    payload: errorEnvelopePayloadSchema,\n  })\n  .meta({ id: \"ErrorEnvelope\", title: \"ErrorEnvelope\" });\n\nexport const pageviewEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"pageview\"),\n    payload: pageviewPayloadSchema,\n  })\n  .meta({ id: \"PageviewEnvelope\", title: \"PageviewEnvelope\" });\n\nexport const pageleaveEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"pageleave\"),\n    payload: pageleavePayloadSchema,\n  })\n  .meta({ id: \"PageleaveEnvelope\", title: \"PageleaveEnvelope\" });\n\nexport const uiEventEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"ui_event\"),\n    payload: uiEventPayloadSchema,\n  })\n  .meta({ id: \"UiEventEnvelope\", title: \"UiEventEnvelope\" });\n\nexport const replayChunkEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"replay_chunk\"),\n    payload: replayChunkPayloadSchema,\n  })\n  .meta({ id: \"ReplayChunkEnvelope\", title: \"ReplayChunkEnvelope\" });\n\nexport const rageClickEnvelopeSchema = z\n  .object({\n    ...envelopeHeadersShape,\n    type: z.literal(\"rage_click\"),\n    payload: rageClickPayloadSchema,\n  })\n  .meta({ id: \"RageClickEnvelope\", title: \"RageClickEnvelope\" });\n\nexport const envelopeSchema = z\n  .discriminatedUnion(\"type\", [\n    errorEnvelopeSchema,\n    pageviewEnvelopeSchema,\n    pageleaveEnvelopeSchema,\n    uiEventEnvelopeSchema,\n    replayChunkEnvelopeSchema,\n    rageClickEnvelopeSchema,\n  ])\n  .meta({\n    id: \"Envelope\",\n    title: \"Envelope\",\n    description: \"A single event envelope accepted by the collector.\",\n  });\n\ntype EnvelopeBase = z.infer<typeof envelopeSchema>;\n\nexport type EventType = EnvelopeBase[\"type\"];\n\nexport type Envelope<T extends EventType | undefined = undefined> =\n  T extends EventType ? Extract<EnvelopeBase, { type: T }> : EnvelopeBase;\n\nexport type EnvelopePayload<T extends EventType> = Envelope<T>[\"payload\"];\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAwBA,MAAa,sBAAsB,EAChC,KAAK;CAAC;CAAU;CAAiB;CAAY;CAAS,CAAC,CACvD,UAAU,CACV,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC;AAIJ,MAAa,wBAAwB,EAClC,mBAAmB,WAAW;CAC7B;CACA;CACA;CACD,CAAC,CACD,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC;AAIJ,MAAM,uBAAuB;CAC3B,SAAS,EAAE,QAAQ;CACnB,UAAU,EAAE,KAAK;CACjB,SAAS,sBAAsB,UAAU;CACzC,aAAa;CACb,iBAAiB,EAAE,QAAQ,CAAC,UAAU;CACtC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,SAAS;CACT,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CACxC,WAAW,gBAAgB,UAAU;CACrC,eAAe;CACf,MAAM,EAAE,QAAQ;CAChB,GAAG,EAAE,QAAQ,EAAE;CAChB;AAED,MAAa,sBAAsB,EAChC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,QAAQ;CACxB,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAiB,OAAO;CAAiB,CAAC;AAExD,MAAa,yBAAyB,EACnC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,WAAW;CAC3B,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAoB,OAAO;CAAoB,CAAC;AAE9D,MAAa,0BAA0B,EACpC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,YAAY;CAC5B,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAqB,OAAO;CAAqB,CAAC;AAEhE,MAAa,wBAAwB,EAClC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,WAAW;CAC3B,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAmB,OAAO;CAAmB,CAAC;AAE5D,MAAa,4BAA4B,EACtC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,eAAe;CAC/B,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAuB,OAAO;CAAuB,CAAC;AAEpE,MAAa,0BAA0B,EACpC,OAAO;CACN,GAAG;CACH,MAAM,EAAE,QAAQ,aAAa;CAC7B,SAAS;CACV,CAAC,CACD,KAAK;CAAE,IAAI;CAAqB,OAAO;CAAqB,CAAC;AAEhE,MAAa,iBAAiB,EAC3B,mBAAmB,QAAQ;CAC1B;CACA;CACA;CACA;CACA;CACA;CACD,CAAC,CACD,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC"}

package/dist/sdk/errors.d.mts

@@ -1,16 +1,96 @@
+import { IngestedFrame } from "#data/frame";
 import { ErrorMechanism, ExceptionValue } from "#sdk/plugins/payload/errors";
 
 //#region src/sdk/errors.d.ts
 /**
- * True when the root exception has at least one stack frame whose `fileName` is
- * a browser-extension script URL. Covers extension-only stacks, extension
- * interceptors (extension frames above app), and app errors whose stack still
- * includes extension code (e.g. hydration) — stacks with no filenames are
- * unchanged (returns false).
+ * Structured taxonomy of capture sources, tagged onto each
+ * `ErrorMechanism.type`. Follows the `auto.<surface>.<library>.<method>`
+ * convention Sentry also uses, so downstream analytics / classification can
+ * group on common prefixes:
+ *
+ *   `auto.browser.*`   — captured by SDK global handlers in the browser
+ *   `auto.function.*`  — captured by SDK functions (boundaries, callbacks,
+ *                        server wrappers)
+ *
+ * Leaves (`.onerror`, `.error_boundary`, `.on_request_error`, …) identify
+ * the specific capture site, which lets the agent's skill classifier reason
+ * about what "kind" of event this is without string-matching loose names.
+ */
+declare const MECHANISM_TYPE: {
+  readonly browser: {
+    readonly onerror: "auto.browser.global_handlers.onerror";
+    readonly onunhandledrejection: "auto.browser.global_handlers.onunhandledrejection";
+    readonly consoleError: "auto.browser.console.error";
+  };
+  readonly react: {
+    readonly errorBoundary: "auto.function.react.error_boundary";
+    readonly captureBoundary: "auto.function.react.capture_boundary";
+    readonly caughtError: "auto.function.react.caught_error";
+    readonly uncaughtError: "auto.function.react.uncaught_error";
+    readonly recoverableError: "auto.function.react.recoverable_error";
+  };
+  readonly nextjs: {
+    readonly onRequestError: "auto.function.nextjs.on_request_error";
+    readonly captureError: "auto.function.nextjs.capture_error";
+  };
+};
+/**
+ * True when any exception in the cause chain has at least one stack frame
+ * whose `fileName` is a browser-extension script URL. Covers extension-only
+ * stacks, extension interceptors (extension frames above app), app errors
+ * whose stack still includes extension code (e.g. hydration), and errors
+ * whose outer throw is app code but whose inner `.cause` originated in an
+ * extension. Stacks with no filenames are unchanged (returns false).
  */
 declare function shouldDropBrowserExtensionNoise(exceptions: readonly ExceptionValue[]): boolean;
+/**
+ * True when no frame across the full cause chain carries any `fileName`.
+ *
+ * Such stacks are structurally uninvestigatable: they come from inline
+ * `<script>` blocks (`at <anonymous>:N:M`), `eval()` / `new Function()`,
+ * CORS-masked cross-origin scripts (`"Script error."`), or browser-internal
+ * code with no URL. No source map can resolve them, no repo lookup can find
+ * them, and the agent has nothing to reason over. Dropping at capture time
+ * prevents them from dominating ingest volume.
+ */
+declare function shouldDropUnresolvableStack(exceptions: readonly ExceptionValue[]): boolean;
+/**
+ * Normalizes an `Error.stack` string before feeding it to the stack parser.
+ *
+ * - Truncates each line to {@link MAX_STACK_LINE_LENGTH} to prevent ReDoS on
+ *   pathological inputs (a single frame with a 100 KiB URL can stall the
+ *   main thread for seconds in a regex-based parser).
+ * - Strips the trailing `(error: *)` suffix some webpack builds emit.
+ */
+declare function preprocessStack(stack: string): string;
+/**
+ * Parses a React `errorInfo.componentStack` string into synthetic frames.
+ *
+ * React produces different formats across versions:
+ *   - React 16–18 legacy:    `    in ComponentName`
+ *                            `    in ComponentName (created by Parent)`
+ *   - React 19 owner stacks: `    at ComponentName`
+ *                            `    at ComponentName (file.tsx:10:5)`
+ *
+ * Each line becomes one frame with the component as `functionName`. When file
+ * positions are present (React 19), they're preserved.
+ */
+declare function parseReactComponentStack(componentStack: string): IngestedFrame[];
+/**
+ * Coerces any thrown value into an `Error` instance, preferring a nested
+ * `Error` inside a plain-object rejection over a stringified fallback.
+ *
+ * Motivated by the common `Promise.reject({ error: realErr })` pattern
+ * (tRPC, GraphQL clients, some fetch wrappers). Without this, the captured
+ * exception would be `new Error("[object Object]")` and the nested Error's
+ * stack/message would be lost entirely.
+ *
+ * When multiple candidate Error values exist on the object, the first one
+ * found (in declaration order) wins. `cause` is preferred if present, since
+ * it's the documented ES2022 convention.
+ */
 declare function toError(error: unknown): Error;
 declare function toExceptions(error: Error, mechanism: ErrorMechanism): ExceptionValue[];
 declare function extractFilenameFromStack(stack: string): string | null;
 //#endregion
-export { extractFilenameFromStack, shouldDropBrowserExtensionNoise, toError, toExceptions };
+export { MECHANISM_TYPE, extractFilenameFromStack, parseReactComponentStack, preprocessStack, shouldDropBrowserExtensionNoise, shouldDropUnresolvableStack, toError, toExceptions };

package/dist/sdk/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/sdk/errors.ts"],"mappings":";;;;;AA8BA;;;;;iBAAgB,+BAAA,CACd,UAAA,WAAqB,cAAA;AAAA,iBAkBP,OAAA,CAAQ,KAAA,YAAiB,KAAA;AAAA,iBAYzB,YAAA,CACd,KAAA,EAAO,KAAA,EACP,SAAA,EAAW,cAAA,GACV,cAAA;AAAA,iBAwDa,wBAAA,CAAyB,KAAA"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/sdk/errors.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;;;;cAAa,cAAA;EAAA;;;;;;;;;;;;;;;;;;;;;AAuJb;;;;iBAtGgB,+BAAA,CACd,UAAA,WAAqB,cAAA;AAkJvB;;;;;AA0BA;;;;;AA1BA,iBAjIgB,2BAAA,CACd,UAAA,WAAqB,cAAA;;;;;;;;;iBA4CP,eAAA,CAAgB,KAAA;AA8MhC;;;;;;;;;;;;AAAA,iBAvKgB,wBAAA,CACd,cAAA,WACC,aAAA;;;;;;;;;;;;;;iBA2Ca,OAAA,CAAQ,KAAA,YAAiB,KAAA;AAAA,iBA0BzB,YAAA,CACd,KAAA,EAAO,KAAA,EACP,SAAA,EAAW,cAAA,GACV,cAAA;AAAA,iBA6Fa,wBAAA,CAAyB,KAAA"}

package/dist/sdk/errors.mjs

@@ -1,36 +1,178 @@
 import { parse } from "error-stack-parser-es";
 //#region src/sdk/errors.ts
-/** URL schemes used by browser extensions in stack frame `fileName` values. */
+/**
+* Structured taxonomy of capture sources, tagged onto each
+* `ErrorMechanism.type`. Follows the `auto.<surface>.<library>.<method>`
+* convention Sentry also uses, so downstream analytics / classification can
+* group on common prefixes:
+*
+*   `auto.browser.*`   — captured by SDK global handlers in the browser
+*   `auto.function.*`  — captured by SDK functions (boundaries, callbacks,
+*                        server wrappers)
+*
+* Leaves (`.onerror`, `.error_boundary`, `.on_request_error`, …) identify
+* the specific capture site, which lets the agent's skill classifier reason
+* about what "kind" of event this is without string-matching loose names.
+*/
+const MECHANISM_TYPE = {
+	browser: {
+		onerror: "auto.browser.global_handlers.onerror",
+		onunhandledrejection: "auto.browser.global_handlers.onunhandledrejection",
+		consoleError: "auto.browser.console.error"
+	},
+	react: {
+		errorBoundary: "auto.function.react.error_boundary",
+		captureBoundary: "auto.function.react.capture_boundary",
+		caughtError: "auto.function.react.caught_error",
+		uncaughtError: "auto.function.react.uncaught_error",
+		recoverableError: "auto.function.react.recoverable_error"
+	},
+	nextjs: {
+		onRequestError: "auto.function.nextjs.on_request_error",
+		captureError: "auto.function.nextjs.capture_error"
+	}
+};
+/**
+* URL schemes used by browser extensions in stack frame `fileName` values.
+*
+* `webkit-masked-url://` is Safari's opaque scheme introduced to mask the
+* origin of content scripts under ITP — it serves the same purpose as the
+* `*-extension://` schemes from a noise-filtering perspective.
+*/
 const BROWSER_EXTENSION_SCRIPT_URL_PREFIXES = [
 	"chrome-extension://",
 	"moz-extension://",
 	"safari-web-extension://",
 	"safari-extension://",
-	"ms-browser-extension://"
+	"ms-browser-extension://",
+	"webkit-masked-url://"
 ];
 function isExtensionOriginated({ fileName }) {
 	return BROWSER_EXTENSION_SCRIPT_URL_PREFIXES.some((prefix) => fileName?.startsWith(prefix) ?? false);
 }
 /**
-* True when the root exception has at least one stack frame whose `fileName` is
-* a browser-extension script URL. Covers extension-only stacks, extension
-* interceptors (extension frames above app), and app errors whose stack still
-* includes extension code (e.g. hydration) — stacks with no filenames are
-* unchanged (returns false).
+* True when any exception in the cause chain has at least one stack frame
+* whose `fileName` is a browser-extension script URL. Covers extension-only
+* stacks, extension interceptors (extension frames above app), app errors
+* whose stack still includes extension code (e.g. hydration), and errors
+* whose outer throw is app code but whose inner `.cause` originated in an
+* extension. Stacks with no filenames are unchanged (returns false).
 */
 function shouldDropBrowserExtensionNoise(exceptions) {
-	const frames = exceptions[0]?.frames;
-	if (!frames?.length) return false;
-	return frames.some(isExtensionOriginated);
+	return exceptions.some((exception) => exception.frames?.some(isExtensionOriginated) ?? false);
+}
+/**
+* True when no frame across the full cause chain carries any `fileName`.
+*
+* Such stacks are structurally uninvestigatable: they come from inline
+* `<script>` blocks (`at <anonymous>:N:M`), `eval()` / `new Function()`,
+* CORS-masked cross-origin scripts (`"Script error."`), or browser-internal
+* code with no URL. No source map can resolve them, no repo lookup can find
+* them, and the agent has nothing to reason over. Dropping at capture time
+* prevents them from dominating ingest volume.
+*/
+function shouldDropUnresolvableStack(exceptions) {
+	for (const exception of exceptions) {
+		const frames = exception.frames;
+		if (!frames?.length) continue;
+		if (frames.some((frame) => typeof frame.fileName === "string")) return false;
+	}
+	return true;
 }
 const MAX_CAUSE_DEPTH = 5;
+/**
+* Upper bound for any single stack-trace line. Pathologically long lines can
+* trigger catastrophic backtracking in regex-based stack parsers (the
+* `error-stack-parser-es` library we depend on is regex-driven). Sentry uses
+* the same 1 KiB ceiling for the same reason.
+*/
+const MAX_STACK_LINE_LENGTH = 1024;
+/**
+* Webpack emits `(error: *)` wrappers around stack frames under certain
+* devtool configurations. The pattern is always a trailing suffix; trimming
+* it lets the downstream parser see a clean `at fn (file:L:C)`.
+*/
+const WEBPACK_ERROR_WRAPPER_RE = /\s*\(error:\s+\*\)$/;
 const PAREN_FILE_RE = /\((.+?)(?::\d+){1,2}\)/;
 const AT_FILE_RE = /at\s+(.+?)(?::\d+){1,2}$/;
 const SPIDERMONKEY_RE = /(?:^|@)((?:https?:\/\/|\/).+?)(?::\d+){1,2}$/;
 const BARE_FILE_RE = /(?:^|@)(.+?)(?::\d+){1,2}$/;
+/**
+* Normalizes an `Error.stack` string before feeding it to the stack parser.
+*
+* - Truncates each line to {@link MAX_STACK_LINE_LENGTH} to prevent ReDoS on
+*   pathological inputs (a single frame with a 100 KiB URL can stall the
+*   main thread for seconds in a regex-based parser).
+* - Strips the trailing `(error: *)` suffix some webpack builds emit.
+*/
+function preprocessStack(stack) {
+	if (!stack) return stack;
+	const out = [];
+	for (const rawLine of stack.split("\n")) {
+		const line = rawLine.length > MAX_STACK_LINE_LENGTH ? rawLine.slice(0, MAX_STACK_LINE_LENGTH) : rawLine;
+		out.push(line.replace(WEBPACK_ERROR_WRAPPER_RE, ""));
+	}
+	return out.join("\n");
+}
+/**
+* Matches one React component-stack line. Captures:
+*   1. component name
+*   2. optional file name (required to have a line number, to avoid matching
+*      "(created by Parent)" annotations emitted by React 16-18)
+*   3. optional line number
+*   4. optional column number
+*/
+const COMPONENT_STACK_RE = /^(?:in|at)\s+([^\s(]+)(?:\s+\(([^\s:)]+):(\d+)(?::(\d+))?\))?/;
+/**
+* Parses a React `errorInfo.componentStack` string into synthetic frames.
+*
+* React produces different formats across versions:
+*   - React 16–18 legacy:    `    in ComponentName`
+*                            `    in ComponentName (created by Parent)`
+*   - React 19 owner stacks: `    at ComponentName`
+*                            `    at ComponentName (file.tsx:10:5)`
+*
+* Each line becomes one frame with the component as `functionName`. When file
+* positions are present (React 19), they're preserved.
+*/
+function parseReactComponentStack(componentStack) {
+	const frames = [];
+	for (const rawLine of componentStack.split("\n")) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		const match = COMPONENT_STACK_RE.exec(line);
+		if (!match) continue;
+		const [, name, fileName, lineStr, colStr] = match;
+		if (!name) continue;
+		const frame = { functionName: name };
+		if (fileName) frame.fileName = fileName;
+		if (lineStr) frame.lineNumber = Number(lineStr);
+		if (colStr) frame.columnNumber = Number(colStr);
+		frames.push(frame);
+	}
+	return frames;
+}
+/**
+* Coerces any thrown value into an `Error` instance, preferring a nested
+* `Error` inside a plain-object rejection over a stringified fallback.
+*
+* Motivated by the common `Promise.reject({ error: realErr })` pattern
+* (tRPC, GraphQL clients, some fetch wrappers). Without this, the captured
+* exception would be `new Error("[object Object]")` and the nested Error's
+* stack/message would be lost entirely.
+*
+* When multiple candidate Error values exist on the object, the first one
+* found (in declaration order) wins. `cause` is preferred if present, since
+* it's the documented ES2022 convention.
+*/
 function toError(error) {
 	if (error instanceof Error) return error;
 	if (typeof error === "string") return new Error(error);
+	if (error !== null && typeof error === "object") {
+		const record = error;
+		if (record["cause"] instanceof Error) return record["cause"];
+		for (const value of Object.values(record)) if (value instanceof Error) return value;
+	}
 	return new Error(String(error));
 }
 function toExceptions(error, mechanism) {
@@ -42,12 +184,32 @@ function toExceptions(error, mechanism) {
 			type: current.name,
 			value: current.message,
 			mechanism: depth === 0 ? mechanism : void 0,
-			frames: parse(current, { allowEmpty: true }).map((frame) => normalizeFrame(frame, debugIdMap))
+			frames: framesFromError(current, debugIdMap)
 		});
 		current = current.cause instanceof Error ? current.cause : void 0;
 	}
 	return exceptions;
 }
+/**
+* Extracts and normalizes frames from an Error, applying:
+*   1. `preprocessStack` — line truncation and webpack-wrapper stripping.
+*   2. `error-stack-parser-es` — engine-specific stack parsing.
+*   3. `framesToPop` — honoring the documented Node convention where an
+*      Error constructor sets this field to instruct callers to drop N top
+*      frames (used by invariant libraries, assertion wrappers, etc.).
+*/
+function framesFromError(error, debugIdMap) {
+	const rawStack = error.stack ?? "";
+	const cleaned = preprocessStack(rawStack);
+	let frames = parse(cleaned === rawStack ? error : {
+		name: error.name,
+		message: error.message,
+		stack: cleaned
+	}, { allowEmpty: true }).map((frame) => normalizeFrame(frame, debugIdMap));
+	const framesToPop = error.framesToPop;
+	if (typeof framesToPop === "number" && framesToPop > 0) frames = frames.slice(Math.floor(framesToPop));
+	return frames;
+}
 let cachedDebugIdMap;
 let cachedDebugIdCount = 0;
 function getDebugIdMap() {
@@ -88,4 +250,4 @@ function normalizeFrame(frame, debugIdMap) {
 	};
 }
 //#endregion
-export { extractFilenameFromStack, shouldDropBrowserExtensionNoise, toError, toExceptions };
+export { MECHANISM_TYPE, extractFilenameFromStack, parseReactComponentStack, preprocessStack, shouldDropBrowserExtensionNoise, shouldDropUnresolvableStack, toError, toExceptions };

package/dist/sdk/errors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../../src/sdk/errors.ts"],"sourcesContent":["import { parse } from \"error-stack-parser-es\";\n\nimport type { IngestedFrame } from \"#data/frame\";\nimport type {\n  ErrorMechanism,\n  ExceptionValue,\n} from \"#sdk/plugins/payload/errors\";\n\n/** URL schemes used by browser extensions in stack frame `fileName` values. */\nconst BROWSER_EXTENSION_SCRIPT_URL_PREFIXES: readonly string[] = [\n  \"chrome-extension://\",\n  \"moz-extension://\",\n  \"safari-web-extension://\",\n  \"safari-extension://\",\n  \"ms-browser-extension://\",\n];\n\nfunction isExtensionOriginated({ fileName }: IngestedFrame): boolean {\n  return BROWSER_EXTENSION_SCRIPT_URL_PREFIXES.some(\n    (prefix) => fileName?.startsWith(prefix) ?? false\n  );\n}\n\n/**\n * True when the root exception has at least one stack frame whose `fileName` is\n * a browser-extension script URL. Covers extension-only stacks, extension\n * interceptors (extension frames above app), and app errors whose stack still\n * includes extension code (e.g. hydration) — stacks with no filenames are\n * unchanged (returns false).\n */\nexport function shouldDropBrowserExtensionNoise(\n  exceptions: readonly ExceptionValue[]\n): boolean {\n  const frames = exceptions[0]?.frames;\n\n  if (!frames?.length) {\n    return false;\n  }\n\n  return frames.some(isExtensionOriginated);\n}\n\nconst MAX_CAUSE_DEPTH = 5;\n\nconst PAREN_FILE_RE = /\\((.+?)(?::\\d+){1,2}\\)/;\nconst AT_FILE_RE = /at\\s+(.+?)(?::\\d+){1,2}$/;\nconst SPIDERMONKEY_RE = /(?:^|@)((?:https?:\\/\\/|\\/).+?)(?::\\d+){1,2}$/;\nconst BARE_FILE_RE = /(?:^|@)(.+?)(?::\\d+){1,2}$/;\n\nexport function toError(error: unknown): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n\n  if (typeof error === \"string\") {\n    return new Error(error);\n  }\n\n  return new Error(String(error));\n}\n\nexport function toExceptions(\n  error: Error,\n  mechanism: ErrorMechanism\n): ExceptionValue[] {\n  const debugIdMap = getDebugIdMap();\n  const exceptions: ExceptionValue[] = [];\n  let current: Error | undefined = error;\n\n  for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth += 1) {\n    exceptions.push({\n      type: current.name,\n      value: current.message,\n      mechanism: depth === 0 ? mechanism : undefined,\n      frames: parse(current, { allowEmpty: true }).map((frame) =>\n        normalizeFrame(frame, debugIdMap)\n      ),\n    });\n\n    current = current.cause instanceof Error ? current.cause : undefined;\n  }\n\n  return exceptions;\n}\n\nlet cachedDebugIdMap: Map<string, string> | undefined;\nlet cachedDebugIdCount = 0;\n\nfunction getDebugIdMap(): Map<string, string> {\n  const registry = (globalThis as Record<string, unknown>)[\"_debugIds\"] as\n    | Record<string, string>\n    | undefined;\n\n  if (!registry) {\n    return new Map();\n  }\n\n  const entries = Object.keys(registry);\n  if (cachedDebugIdMap && entries.length === cachedDebugIdCount) {\n    return cachedDebugIdMap;\n  }\n\n  const map = new Map<string, string>();\n  for (const stackKey of entries) {\n    const debugId = registry[stackKey];\n    if (!debugId) {\n      continue;\n    }\n\n    const filename = extractFilenameFromStack(stackKey);\n    if (filename) {\n      map.set(filename, debugId);\n    }\n  }\n\n  cachedDebugIdMap = map;\n  cachedDebugIdCount = entries.length;\n  return map;\n}\n\nexport function extractFilenameFromStack(stack: string): string | null {\n  const lines = stack.split(\"\\n\");\n  for (let i = lines.length - 1; i >= 0; i--) {\n    const line = lines[i];\n    if (!line) {\n      continue;\n    }\n    const match =\n      line.match(PAREN_FILE_RE) ??\n      line.match(AT_FILE_RE) ??\n      line.match(SPIDERMONKEY_RE) ??\n      line.match(BARE_FILE_RE);\n\n    if (match?.[1]) {\n      return match[1].trim();\n    }\n  }\n  return null;\n}\n\nfunction normalizeFrame(\n  frame: {\n    fileName?: unknown;\n    functionName?: unknown;\n    lineNumber?: unknown;\n    columnNumber?: unknown;\n    source?: unknown;\n  },\n  debugIdMap: Map<string, string>\n): IngestedFrame {\n  const fileName =\n    typeof frame.fileName === \"string\" ? frame.fileName : undefined;\n\n  return {\n    fileName,\n    functionName:\n      typeof frame.functionName === \"string\" ? frame.functionName : undefined,\n    lineNumber:\n      typeof frame.lineNumber === \"number\" ? frame.lineNumber : undefined,\n    columnNumber:\n      typeof frame.columnNumber === \"number\" ? frame.columnNumber : undefined,\n    source: typeof frame.source === \"string\" ? frame.source : undefined,\n    debugId: fileName ? debugIdMap.get(fileName) : undefined,\n  };\n}\n"],"mappings":";;;AASA,MAAM,wCAA2D;CAC/D;CACA;CACA;CACA;CACA;CACD;AAED,SAAS,sBAAsB,EAAE,YAAoC;AACnE,QAAO,sCAAsC,MAC1C,WAAW,UAAU,WAAW,OAAO,IAAI,MAC7C;;;;;;;;;AAUH,SAAgB,gCACd,YACS;CACT,MAAM,SAAS,WAAW,IAAI;AAE9B,KAAI,CAAC,QAAQ,OACX,QAAO;AAGT,QAAO,OAAO,KAAK,sBAAsB;;AAG3C,MAAM,kBAAkB;AAExB,MAAM,gBAAgB;AACtB,MAAM,aAAa;AACnB,MAAM,kBAAkB;AACxB,MAAM,eAAe;AAErB,SAAgB,QAAQ,OAAuB;AAC7C,KAAI,iBAAiB,MACnB,QAAO;AAGT,KAAI,OAAO,UAAU,SACnB,QAAO,IAAI,MAAM,MAAM;AAGzB,QAAO,IAAI,MAAM,OAAO,MAAM,CAAC;;AAGjC,SAAgB,aACd,OACA,WACkB;CAClB,MAAM,aAAa,eAAe;CAClC,MAAM,aAA+B,EAAE;CACvC,IAAI,UAA6B;AAEjC,MAAK,IAAI,QAAQ,GAAG,WAAW,QAAQ,iBAAiB,SAAS,GAAG;AAClE,aAAW,KAAK;GACd,MAAM,QAAQ;GACd,OAAO,QAAQ;GACf,WAAW,UAAU,IAAI,YAAY,KAAA;GACrC,QAAQ,MAAM,SAAS,EAAE,YAAY,MAAM,CAAC,CAAC,KAAK,UAChD,eAAe,OAAO,WAAW,CAClC;GACF,CAAC;AAEF,YAAU,QAAQ,iBAAiB,QAAQ,QAAQ,QAAQ,KAAA;;AAG7D,QAAO;;AAGT,IAAI;AACJ,IAAI,qBAAqB;AAEzB,SAAS,gBAAqC;CAC5C,MAAM,WAAY,WAAuC;AAIzD,KAAI,CAAC,SACH,wBAAO,IAAI,KAAK;CAGlB,MAAM,UAAU,OAAO,KAAK,SAAS;AACrC,KAAI,oBAAoB,QAAQ,WAAW,mBACzC,QAAO;CAGT,MAAM,sBAAM,IAAI,KAAqB;AACrC,MAAK,MAAM,YAAY,SAAS;EAC9B,MAAM,UAAU,SAAS;AACzB,MAAI,CAAC,QACH;EAGF,MAAM,WAAW,yBAAyB,SAAS;AACnD,MAAI,SACF,KAAI,IAAI,UAAU,QAAQ;;AAI9B,oBAAmB;AACnB,sBAAqB,QAAQ;AAC7B,QAAO;;AAGT,SAAgB,yBAAyB,OAA8B;CACrE,MAAM,QAAQ,MAAM,MAAM,KAAK;AAC/B,MAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;EAC1C,MAAM,OAAO,MAAM;AACnB,MAAI,CAAC,KACH;EAEF,MAAM,QACJ,KAAK,MAAM,cAAc,IACzB,KAAK,MAAM,WAAW,IACtB,KAAK,MAAM,gBAAgB,IAC3B,KAAK,MAAM,aAAa;AAE1B,MAAI,QAAQ,GACV,QAAO,MAAM,GAAG,MAAM;;AAG1B,QAAO;;AAGT,SAAS,eACP,OAOA,YACe;CACf,MAAM,WACJ,OAAO,MAAM,aAAa,WAAW,MAAM,WAAW,KAAA;AAExD,QAAO;EACL;EACA,cACE,OAAO,MAAM,iBAAiB,WAAW,MAAM,eAAe,KAAA;EAChE,YACE,OAAO,MAAM,eAAe,WAAW,MAAM,aAAa,KAAA;EAC5D,cACE,OAAO,MAAM,iBAAiB,WAAW,MAAM,eAAe,KAAA;EAChE,QAAQ,OAAO,MAAM,WAAW,WAAW,MAAM,SAAS,KAAA;EAC1D,SAAS,WAAW,WAAW,IAAI,SAAS,GAAG,KAAA;EAChD"}
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../src/sdk/errors.ts"],"sourcesContent":["import { parse } from \"error-stack-parser-es\";\n\nimport type { IngestedFrame } from \"#data/frame\";\nimport type {\n  ErrorMechanism,\n  ExceptionValue,\n} from \"#sdk/plugins/payload/errors\";\n\n/**\n * Structured taxonomy of capture sources, tagged onto each\n * `ErrorMechanism.type`. Follows the `auto.<surface>.<library>.<method>`\n * convention Sentry also uses, so downstream analytics / classification can\n * group on common prefixes:\n *\n *   `auto.browser.*`   — captured by SDK global handlers in the browser\n *   `auto.function.*`  — captured by SDK functions (boundaries, callbacks,\n *                        server wrappers)\n *\n * Leaves (`.onerror`, `.error_boundary`, `.on_request_error`, …) identify\n * the specific capture site, which lets the agent's skill classifier reason\n * about what \"kind\" of event this is without string-matching loose names.\n */\nexport const MECHANISM_TYPE = {\n  browser: {\n    onerror: \"auto.browser.global_handlers.onerror\",\n    onunhandledrejection: \"auto.browser.global_handlers.onunhandledrejection\",\n    consoleError: \"auto.browser.console.error\",\n  },\n  react: {\n    errorBoundary: \"auto.function.react.error_boundary\",\n    captureBoundary: \"auto.function.react.capture_boundary\",\n    caughtError: \"auto.function.react.caught_error\",\n    uncaughtError: \"auto.function.react.uncaught_error\",\n    recoverableError: \"auto.function.react.recoverable_error\",\n  },\n  nextjs: {\n    onRequestError: \"auto.function.nextjs.on_request_error\",\n    captureError: \"auto.function.nextjs.capture_error\",\n  },\n} as const;\n\n/**\n * URL schemes used by browser extensions in stack frame `fileName` values.\n *\n * `webkit-masked-url://` is Safari's opaque scheme introduced to mask the\n * origin of content scripts under ITP — it serves the same purpose as the\n * `*-extension://` schemes from a noise-filtering perspective.\n */\nconst BROWSER_EXTENSION_SCRIPT_URL_PREFIXES: readonly string[] = [\n  \"chrome-extension://\",\n  \"moz-extension://\",\n  \"safari-web-extension://\",\n  \"safari-extension://\",\n  \"ms-browser-extension://\",\n  \"webkit-masked-url://\",\n];\n\nfunction isExtensionOriginated({ fileName }: IngestedFrame): boolean {\n  return BROWSER_EXTENSION_SCRIPT_URL_PREFIXES.some(\n    (prefix) => fileName?.startsWith(prefix) ?? false\n  );\n}\n\n/**\n * True when any exception in the cause chain has at least one stack frame\n * whose `fileName` is a browser-extension script URL. Covers extension-only\n * stacks, extension interceptors (extension frames above app), app errors\n * whose stack still includes extension code (e.g. hydration), and errors\n * whose outer throw is app code but whose inner `.cause` originated in an\n * extension. Stacks with no filenames are unchanged (returns false).\n */\nexport function shouldDropBrowserExtensionNoise(\n  exceptions: readonly ExceptionValue[]\n): boolean {\n  return exceptions.some(\n    (exception) => exception.frames?.some(isExtensionOriginated) ?? false\n  );\n}\n\n/**\n * True when no frame across the full cause chain carries any `fileName`.\n *\n * Such stacks are structurally uninvestigatable: they come from inline\n * `<script>` blocks (`at <anonymous>:N:M`), `eval()` / `new Function()`,\n * CORS-masked cross-origin scripts (`\"Script error.\"`), or browser-internal\n * code with no URL. No source map can resolve them, no repo lookup can find\n * them, and the agent has nothing to reason over. Dropping at capture time\n * prevents them from dominating ingest volume.\n */\nexport function shouldDropUnresolvableStack(\n  exceptions: readonly ExceptionValue[]\n): boolean {\n  for (const exception of exceptions) {\n    const frames = exception.frames;\n    if (!frames?.length) {\n      continue;\n    }\n    if (frames.some((frame) => typeof frame.fileName === \"string\")) {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst MAX_CAUSE_DEPTH = 5;\n\n/**\n * Upper bound for any single stack-trace line. Pathologically long lines can\n * trigger catastrophic backtracking in regex-based stack parsers (the\n * `error-stack-parser-es` library we depend on is regex-driven). Sentry uses\n * the same 1 KiB ceiling for the same reason.\n */\nconst MAX_STACK_LINE_LENGTH = 1024;\n\n/**\n * Webpack emits `(error: *)` wrappers around stack frames under certain\n * devtool configurations. The pattern is always a trailing suffix; trimming\n * it lets the downstream parser see a clean `at fn (file:L:C)`.\n */\nconst WEBPACK_ERROR_WRAPPER_RE = /\\s*\\(error:\\s+\\*\\)$/;\n\nconst PAREN_FILE_RE = /\\((.+?)(?::\\d+){1,2}\\)/;\nconst AT_FILE_RE = /at\\s+(.+?)(?::\\d+){1,2}$/;\nconst SPIDERMONKEY_RE = /(?:^|@)((?:https?:\\/\\/|\\/).+?)(?::\\d+){1,2}$/;\nconst BARE_FILE_RE = /(?:^|@)(.+?)(?::\\d+){1,2}$/;\n\n/**\n * Normalizes an `Error.stack` string before feeding it to the stack parser.\n *\n * - Truncates each line to {@link MAX_STACK_LINE_LENGTH} to prevent ReDoS on\n *   pathological inputs (a single frame with a 100 KiB URL can stall the\n *   main thread for seconds in a regex-based parser).\n * - Strips the trailing `(error: *)` suffix some webpack builds emit.\n */\nexport function preprocessStack(stack: string): string {\n  if (!stack) {\n    return stack;\n  }\n\n  const out: string[] = [];\n  for (const rawLine of stack.split(\"\\n\")) {\n    const line =\n      rawLine.length > MAX_STACK_LINE_LENGTH\n        ? rawLine.slice(0, MAX_STACK_LINE_LENGTH)\n        : rawLine;\n    out.push(line.replace(WEBPACK_ERROR_WRAPPER_RE, \"\"));\n  }\n  return out.join(\"\\n\");\n}\n\n/**\n * Matches one React component-stack line. Captures:\n *   1. component name\n *   2. optional file name (required to have a line number, to avoid matching\n *      \"(created by Parent)\" annotations emitted by React 16-18)\n *   3. optional line number\n *   4. optional column number\n */\nconst COMPONENT_STACK_RE =\n  /^(?:in|at)\\s+([^\\s(]+)(?:\\s+\\(([^\\s:)]+):(\\d+)(?::(\\d+))?\\))?/;\n\n/**\n * Parses a React `errorInfo.componentStack` string into synthetic frames.\n *\n * React produces different formats across versions:\n *   - React 16–18 legacy:    `    in ComponentName`\n *                            `    in ComponentName (created by Parent)`\n *   - React 19 owner stacks: `    at ComponentName`\n *                            `    at ComponentName (file.tsx:10:5)`\n *\n * Each line becomes one frame with the component as `functionName`. When file\n * positions are present (React 19), they're preserved.\n */\nexport function parseReactComponentStack(\n  componentStack: string\n): IngestedFrame[] {\n  const frames: IngestedFrame[] = [];\n  for (const rawLine of componentStack.split(\"\\n\")) {\n    const line = rawLine.trim();\n    if (!line) {\n      continue;\n    }\n    const match = COMPONENT_STACK_RE.exec(line);\n    if (!match) {\n      continue;\n    }\n    const [, name, fileName, lineStr, colStr] = match;\n    if (!name) {\n      continue;\n    }\n    const frame: IngestedFrame = { functionName: name };\n    if (fileName) {\n      frame.fileName = fileName;\n    }\n    if (lineStr) {\n      frame.lineNumber = Number(lineStr);\n    }\n    if (colStr) {\n      frame.columnNumber = Number(colStr);\n    }\n    frames.push(frame);\n  }\n  return frames;\n}\n\n/**\n * Coerces any thrown value into an `Error` instance, preferring a nested\n * `Error` inside a plain-object rejection over a stringified fallback.\n *\n * Motivated by the common `Promise.reject({ error: realErr })` pattern\n * (tRPC, GraphQL clients, some fetch wrappers). Without this, the captured\n * exception would be `new Error(\"[object Object]\")` and the nested Error's\n * stack/message would be lost entirely.\n *\n * When multiple candidate Error values exist on the object, the first one\n * found (in declaration order) wins. `cause` is preferred if present, since\n * it's the documented ES2022 convention.\n */\nexport function toError(error: unknown): Error {\n  if (error instanceof Error) {\n    return error;\n  }\n\n  if (typeof error === \"string\") {\n    return new Error(error);\n  }\n\n  if (error !== null && typeof error === \"object\") {\n    const record = error as Record<string, unknown>;\n\n    if (record[\"cause\"] instanceof Error) {\n      return record[\"cause\"];\n    }\n\n    for (const value of Object.values(record)) {\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return new Error(String(error));\n}\n\nexport function toExceptions(\n  error: Error,\n  mechanism: ErrorMechanism\n): ExceptionValue[] {\n  const debugIdMap = getDebugIdMap();\n  const exceptions: ExceptionValue[] = [];\n  let current: Error | undefined = error;\n\n  for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth += 1) {\n    exceptions.push({\n      type: current.name,\n      value: current.message,\n      mechanism: depth === 0 ? mechanism : undefined,\n      frames: framesFromError(current, debugIdMap),\n    });\n\n    current = current.cause instanceof Error ? current.cause : undefined;\n  }\n\n  return exceptions;\n}\n\n/**\n * Extracts and normalizes frames from an Error, applying:\n *   1. `preprocessStack` — line truncation and webpack-wrapper stripping.\n *   2. `error-stack-parser-es` — engine-specific stack parsing.\n *   3. `framesToPop` — honoring the documented Node convention where an\n *      Error constructor sets this field to instruct callers to drop N top\n *      frames (used by invariant libraries, assertion wrappers, etc.).\n */\nfunction framesFromError(\n  error: Error,\n  debugIdMap: Map<string, string>\n): IngestedFrame[] {\n  const rawStack = error.stack ?? \"\";\n  const cleaned = preprocessStack(rawStack);\n\n  // error-stack-parser-es reads the Error's `.stack` property directly; we\n  // build a minimal parse target so preprocessing doesn't mutate the caller's\n  // Error.\n  const parseTarget =\n    cleaned === rawStack\n      ? error\n      : ({\n          name: error.name,\n          message: error.message,\n          stack: cleaned,\n        } as Error);\n\n  let frames = parse(parseTarget, { allowEmpty: true }).map((frame) =>\n    normalizeFrame(frame, debugIdMap)\n  );\n\n  const framesToPop = (error as Error & { framesToPop?: unknown }).framesToPop;\n  if (typeof framesToPop === \"number\" && framesToPop > 0) {\n    frames = frames.slice(Math.floor(framesToPop));\n  }\n\n  return frames;\n}\n\nlet cachedDebugIdMap: Map<string, string> | undefined;\nlet cachedDebugIdCount = 0;\n\nfunction getDebugIdMap(): Map<string, string> {\n  const registry = (globalThis as Record<string, unknown>)[\"_debugIds\"] as\n    | Record<string, string>\n    | undefined;\n\n  if (!registry) {\n    return new Map();\n  }\n\n  const entries = Object.keys(registry);\n  if (cachedDebugIdMap && entries.length === cachedDebugIdCount) {\n    return cachedDebugIdMap;\n  }\n\n  const map = new Map<string, string>();\n  for (const stackKey of entries) {\n    const debugId = registry[stackKey];\n    if (!debugId) {\n      continue;\n    }\n\n    const filename = extractFilenameFromStack(stackKey);\n    if (filename) {\n      map.set(filename, debugId);\n    }\n  }\n\n  cachedDebugIdMap = map;\n  cachedDebugIdCount = entries.length;\n  return map;\n}\n\nexport function extractFilenameFromStack(stack: string): string | null {\n  const lines = stack.split(\"\\n\");\n  for (let i = lines.length - 1; i >= 0; i--) {\n    const line = lines[i];\n    if (!line) {\n      continue;\n    }\n    const match =\n      line.match(PAREN_FILE_RE) ??\n      line.match(AT_FILE_RE) ??\n      line.match(SPIDERMONKEY_RE) ??\n      line.match(BARE_FILE_RE);\n\n    if (match?.[1]) {\n      return match[1].trim();\n    }\n  }\n  return null;\n}\n\nfunction normalizeFrame(\n  frame: {\n    fileName?: unknown;\n    functionName?: unknown;\n    lineNumber?: unknown;\n    columnNumber?: unknown;\n    source?: unknown;\n  },\n  debugIdMap: Map<string, string>\n): IngestedFrame {\n  const fileName =\n    typeof frame.fileName === \"string\" ? frame.fileName : undefined;\n\n  return {\n    fileName,\n    functionName:\n      typeof frame.functionName === \"string\" ? frame.functionName : undefined,\n    lineNumber:\n      typeof frame.lineNumber === \"number\" ? frame.lineNumber : undefined,\n    columnNumber:\n      typeof frame.columnNumber === \"number\" ? frame.columnNumber : undefined,\n    source: typeof frame.source === \"string\" ? frame.source : undefined,\n    debugId: fileName ? debugIdMap.get(fileName) : undefined,\n  };\n}\n"],"mappings":"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"}

package/dist/sdk/identify.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"identify.d.mts","names":[],"sources":["../../src/sdk/identify.ts"],"mappings":";;;cAEa,oBAAA,EAAoB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;KAMrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;KASrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}
+{"version":3,"file":"identify.d.mts","names":[],"sources":["../../src/sdk/identify.ts"],"mappings":";;;cAEa,oBAAA,EAAoB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;KAkBrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;KAerB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}

package/dist/sdk/identify.mjs

@@ -4,16 +4,29 @@ const identifySourceSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("clerk"),
 		name: z.literal("Clerk")
+	}).meta({
+		id: "ClerkIdentifySource",
+		title: "ClerkIdentifySource"
 	}),
 	z.object({
 		type: z.literal("auth0"),
 		name: z.literal("Auth0")
+	}).meta({
+		id: "Auth0IdentifySource",
+		title: "Auth0IdentifySource"
 	}),
 	z.object({
 		type: z.literal("custom"),
 		name: z.string()
+	}).meta({
+		id: "CustomIdentifySource",
+		title: "CustomIdentifySource"
 	})
-]);
+]).meta({
+	id: "IdentifySource",
+	title: "IdentifySource",
+	description: "Auth provider that surfaced this identification."
+});
 const identifyParamsSchema = z.object({
 	avatar: z.string().optional(),
 	email: z.string().optional(),
@@ -21,6 +34,10 @@ const identifyParamsSchema = z.object({
 	name: z.string().optional(),
 	source: identifySourceSchema,
 	traits: z.record(z.string(), z.unknown()).optional()
+}).meta({
+	id: "IdentifyParams",
+	title: "IdentifyParams",
+	description: "User attributes attached when identifying a session."
 });
 //#endregion
 export { identifyParamsSchema, identifySourceSchema };

package/dist/sdk/identify.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"identify.mjs","names":[],"sources":["../../src/sdk/identify.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const identifySourceSchema = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"clerk\"), name: z.literal(\"Clerk\") }),\n  z.object({ type: z.literal(\"auth0\"), name: z.literal(\"Auth0\") }),\n  z.object({ type: z.literal(\"custom\"), name: z.string() }),\n]);\n\nexport type IdentifySource = z.infer<typeof identifySourceSchema>;\n\nexport const identifyParamsSchema = z.object({\n  avatar: z.string().optional(),\n  email: z.string().optional(),\n  identifier: z.string(),\n  name: z.string().optional(),\n  source: identifySourceSchema,\n  traits: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type IdentifyParams = z.infer<typeof identifyParamsSchema>;\n"],"mappings":";;AAEA,MAAa,uBAAuB,EAAE,mBAAmB,QAAQ;CAC/D,EAAE,OAAO;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,CAAC;CAChE,EAAE,OAAO;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,CAAC;CAChE,EAAE,OAAO;EAAE,MAAM,EAAE,QAAQ,SAAS;EAAE,MAAM,EAAE,QAAQ;EAAE,CAAC;CAC1D,CAAC;AAIF,MAAa,uBAAuB,EAAE,OAAO;CAC3C,QAAQ,EAAE,QAAQ,CAAC,UAAU;CAC7B,OAAO,EAAE,QAAQ,CAAC,UAAU;CAC5B,YAAY,EAAE,QAAQ;CACtB,MAAM,EAAE,QAAQ,CAAC,UAAU;CAC3B,QAAQ;CACR,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACrD,CAAC"}
+{"version":3,"file":"identify.mjs","names":[],"sources":["../../src/sdk/identify.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const identifySourceSchema = z\n  .discriminatedUnion(\"type\", [\n    z\n      .object({ type: z.literal(\"clerk\"), name: z.literal(\"Clerk\") })\n      .meta({ id: \"ClerkIdentifySource\", title: \"ClerkIdentifySource\" }),\n    z\n      .object({ type: z.literal(\"auth0\"), name: z.literal(\"Auth0\") })\n      .meta({ id: \"Auth0IdentifySource\", title: \"Auth0IdentifySource\" }),\n    z\n      .object({ type: z.literal(\"custom\"), name: z.string() })\n      .meta({ id: \"CustomIdentifySource\", title: \"CustomIdentifySource\" }),\n  ])\n  .meta({\n    id: \"IdentifySource\",\n    title: \"IdentifySource\",\n    description: \"Auth provider that surfaced this identification.\",\n  });\n\nexport type IdentifySource = z.infer<typeof identifySourceSchema>;\n\nexport const identifyParamsSchema = z\n  .object({\n    avatar: z.string().optional(),\n    email: z.string().optional(),\n    identifier: z.string(),\n    name: z.string().optional(),\n    source: identifySourceSchema,\n    traits: z.record(z.string(), z.unknown()).optional(),\n  })\n  .meta({\n    id: \"IdentifyParams\",\n    title: \"IdentifyParams\",\n    description: \"User attributes attached when identifying a session.\",\n  });\n\nexport type IdentifyParams = z.infer<typeof identifyParamsSchema>;\n"],"mappings":";;AAEA,MAAa,uBAAuB,EACjC,mBAAmB,QAAQ;CAC1B,EACG,OAAO;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,CAAC,CAC9D,KAAK;EAAE,IAAI;EAAuB,OAAO;EAAuB,CAAC;CACpE,EACG,OAAO;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,MAAM,EAAE,QAAQ,QAAQ;EAAE,CAAC,CAC9D,KAAK;EAAE,IAAI;EAAuB,OAAO;EAAuB,CAAC;CACpE,EACG,OAAO;EAAE,MAAM,EAAE,QAAQ,SAAS;EAAE,MAAM,EAAE,QAAQ;EAAE,CAAC,CACvD,KAAK;EAAE,IAAI;EAAwB,OAAO;EAAwB,CAAC;CACvE,CAAC,CACD,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC;AAIJ,MAAa,uBAAuB,EACjC,OAAO;CACN,QAAQ,EAAE,QAAQ,CAAC,UAAU;CAC7B,OAAO,EAAE,QAAQ,CAAC,UAAU;CAC5B,YAAY,EAAE,QAAQ;CACtB,MAAM,EAAE,QAAQ,CAAC,UAAU;CAC3B,QAAQ;CACR,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACrD,CAAC,CACD,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC"}

package/dist/sdk/plugins/context/browser.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.mts","names":[],"sources":["../../../../src/sdk/plugins/context/browser.ts"],"mappings":";;;cAEa,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KA0BrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAEtC,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;;KAYf,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAEhC,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}
+{"version":3,"file":"browser.d.mts","names":[],"sources":["../../../../src/sdk/plugins/context/browser.ts"],"mappings":";;;cAuCa,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAerB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAgBtC,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;;KAYf,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAEhC,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAYrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}