@interfere/types 8.1.6 → 9.0.2

package/README.md

@@ -2,15 +2,15 @@
   <a href="https://interfere.com">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-dark.png">
-      <img src="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-light.png" height="64">
+      <img src="https://qyzkf4cgb8ydxtq1.public.blob.vercel-storage.com/v2/header/logo-light.png" height="64" alt="Interfere">
     </picture>
   </a>
   <h1 align="center">@interfere/types</h1>
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@interfere/types"><img src="https://img.shields.io/npm/v/@interfere/types.svg" /></a>
-  <a href="https://github.com/interfere-inc/interfere/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@interfere/types.svg" /></a>
+  <a href="https://www.npmjs.com/package/@interfere/types"><img src="https://img.shields.io/npm/v/@interfere/types.svg" alt="npm version" /></a>
+  <a href="https://github.com/interfere-inc/interfere/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@interfere/types.svg" alt="License" /></a>
 </p>
 
 <p align="center">

package/dist/data/frame.d.mts

@@ -1,11 +1,23 @@
 import { z } from "zod";
 
 //#region src/data/frame.d.ts
+/**
+ * One stack frame as it lands at the collector — pre-source-map
+ * resolution. Produced by the collector's stack parser from the OTel
+ * `exception.stacktrace` string, supplemented by SDK-side parsed
+ * frames (React component stack, `window.onerror` fallback).
+ *
+ * Field names match the post-resolution `EnrichedFrame` shape so
+ * consumers reading "the file the frame is in" don't have to remember
+ * which lifecycle stage they're at. The wire format is the same
+ * across SDK + collector + enrichment + storage.
+ */
 declare const ingestedFrame: z.ZodObject<{
-  fileName: z.ZodOptional<z.ZodString>;
-  functionName: z.ZodOptional<z.ZodString>;
-  lineNumber: z.ZodOptional<z.ZodNumber>;
-  columnNumber: z.ZodOptional<z.ZodNumber>;
+  id: z.ZodOptional<z.ZodString>;
+  file: z.ZodOptional<z.ZodString>;
+  fn: z.ZodOptional<z.ZodString>;
+  line: z.ZodOptional<z.ZodNumber>;
+  column: z.ZodOptional<z.ZodNumber>;
   source: z.ZodOptional<z.ZodString>;
   debugId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/data/frame.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"frame.d.mts","names":[],"sources":["../../src/data/frame.ts"],"mappings":";;;cAEa,aAAA,EAAa,CAAA,CAAA,SAAA;;;;;;;;KAed,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,aAAA"}
+{"version":3,"file":"frame.d.mts","names":[],"sources":["../../src/data/frame.ts"],"mappings":";;;;;AAaA;;;;;;;;;cAAa,aAAA,EAAa,CAAA,CAAA,SAAA;;;;;;;;;KA+Bd,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,aAAA"}

package/dist/data/frame.mjs

@@ -1,16 +1 @@
-import { z } from "zod";
-//#region src/data/frame.ts
-const ingestedFrame = z.object({
-	fileName: z.string().optional(),
-	functionName: z.string().optional(),
-	lineNumber: z.number().optional(),
-	columnNumber: z.number().optional(),
-	source: z.string().optional(),
-	debugId: z.string().optional()
-}).meta({
-	id: "Frame",
-	title: "Frame",
-	description: "A single stack frame captured from an error."
-});
-//#endregion
-export { ingestedFrame };
+import{z as e}from"zod";const t=e.object({id:e.string().optional(),file:e.string().optional(),fn:e.string().optional(),line:e.number().optional(),column:e.number().optional(),source:e.string().optional(),debugId:e.string().optional()}).meta({id:`Frame`,title:`Frame`,description:`A single stack frame captured from an error.`});export{t as ingestedFrame};

package/dist/data/frame.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"frame.mjs","names":[],"sources":["../../src/data/frame.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const ingestedFrame = z\n  .object({\n    fileName: z.string().optional(),\n    functionName: z.string().optional(),\n    lineNumber: z.number().optional(),\n    columnNumber: z.number().optional(),\n    source: z.string().optional(),\n    debugId: z.string().optional(),\n  })\n  .meta({\n    id: \"Frame\",\n    title: \"Frame\",\n    description: \"A single stack frame captured from an error.\",\n  });\n\nexport type IngestedFrame = z.infer<typeof ingestedFrame>;\n"],"mappings":";;AAEA,MAAa,gBAAgB,EAC1B,OAAO;CACN,UAAU,EAAE,QAAQ,CAAC,UAAU;CAC/B,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,YAAY,EAAE,QAAQ,CAAC,UAAU;CACjC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,QAAQ,EAAE,QAAQ,CAAC,UAAU;CAC7B,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC/B,CAAC,CACD,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aAAa;CACd,CAAC"}
+{"version":3,"file":"frame.mjs","names":[],"sources":["../../src/data/frame.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/**\n * One stack frame as it lands at the collector — pre-source-map\n * resolution. Produced by the collector's stack parser from the OTel\n * `exception.stacktrace` string, supplemented by SDK-side parsed\n * frames (React component stack, `window.onerror` fallback).\n *\n * Field names match the post-resolution `EnrichedFrame` shape so\n * consumers reading \"the file the frame is in\" don't have to remember\n * which lifecycle stage they're at. The wire format is the same\n * across SDK + collector + enrichment + storage.\n */\nexport const ingestedFrame = z\n  .object({\n    /**\n     * Stable id within a payload's `frames[]`. The collector mapper\n     * sets this to the array index it produced (`\"frame-0\"`,\n     * `\"frame-1\"`, ...) so post-resolution frames can reference back\n     * to their pre-resolution origin via `EnrichedFrame.ingestedId`.\n     */\n    id: z.string().optional(),\n    /** URL or path of the JS file the frame is in. */\n    file: z.string().optional(),\n    /** Function name. */\n    fn: z.string().optional(),\n    line: z.number().optional(),\n    column: z.number().optional(),\n    /** Pre-context source code line, when the SDK happened to capture it. */\n    source: z.string().optional(),\n    /**\n     * Build-time injected debug id (webpack/turbopack/rollup). When\n     * present, enrichment uses this to look up the source map from the\n     * release manifest directly; absent, it falls back to suffix-\n     * matching `file` against `manifest.files[].chunkUrl`.\n     */\n    debugId: z.string().optional(),\n  })\n  .meta({\n    id: \"Frame\",\n    title: \"Frame\",\n    description: \"A single stack frame captured from an error.\",\n  });\n\nexport type IngestedFrame = z.infer<typeof ingestedFrame>;\n"],"mappings":"wBAaA,MAAa,EAAgB,EAC1B,OAAO,CAON,GAAI,EAAE,QAAQ,CAAC,UAAU,CAEzB,KAAM,EAAE,QAAQ,CAAC,UAAU,CAE3B,GAAI,EAAE,QAAQ,CAAC,UAAU,CACzB,KAAM,EAAE,QAAQ,CAAC,UAAU,CAC3B,OAAQ,EAAE,QAAQ,CAAC,UAAU,CAE7B,OAAQ,EAAE,QAAQ,CAAC,UAAU,CAO7B,QAAS,EAAE,QAAQ,CAAC,UAAU,CAC/B,CAAC,CACD,KAAK,CACJ,GAAI,QACJ,MAAO,QACP,YAAa,+CACd,CAAC"}

package/dist/data/session.d.mts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 //#region src/data/session.d.ts
-declare const sessionIdSchema: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`server_${string}`>]>;
+declare const sessionIdSchema: z.core.$ZodBranded<z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`server_${string}`>]>, "SessionId", "out">;
 type SessionId = z.infer<typeof sessionIdSchema>;
 //#endregion
 export { SessionId, sessionIdSchema };

package/dist/data/session.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.mts","names":[],"sources":["../../src/data/session.ts"],"mappings":";;;cAKa,eAAA,EAAe,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,OAAA,EAAA,CAAA,CAAA,kBAAA;AAAA,KAShB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA"}
+{"version":3,"file":"session.d.mts","names":[],"sources":["../../src/data/session.ts"],"mappings":";;;cAKa,eAAA,EAAe,CAAA,CAAA,IAAA,CAAA,WAAA,CAAA,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,OAAA,EAAA,CAAA,CAAA,kBAAA;AAAA,KAUhB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA"}

package/dist/data/session.mjs

@@ -1,9 +1 @@
-import { z } from "zod";
-//#region src/data/session.ts
-const sessionIdSchema = z.union([z.uuidv7(), z.templateLiteral(["server_", z.uuidv7()])]).meta({
-	id: "SessionId",
-	title: "SessionId",
-	description: "UUIDv7 (from the client SDK) or server_<uuidv7> (server-side fallback)."
-});
-//#endregion
-export { sessionIdSchema };
+import{z as e}from"zod";const t=e.union([e.uuidv7(),e.templateLiteral([`server_`,e.uuidv7()])]).meta({id:`SessionId`,title:`SessionId`,description:`UUIDv7 (from the client SDK) or server_<uuidv7> (server-side fallback).`}).brand();export{t as sessionIdSchema};

package/dist/data/session.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"session.mjs","names":[],"sources":["../../src/data/session.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Session IDs can be:\n// - Plain UUIDv7 (from client SDK)\n// - \"server_\" prefixed UUIDv7 (server-side fallback when no client session exists)\nexport const sessionIdSchema = z\n  .union([z.uuidv7(), z.templateLiteral([\"server_\", z.uuidv7()])])\n  .meta({\n    id: \"SessionId\",\n    title: \"SessionId\",\n    description:\n      \"UUIDv7 (from the client SDK) or server_<uuidv7> (server-side fallback).\",\n  });\n\nexport type SessionId = z.infer<typeof sessionIdSchema>;\n"],"mappings":";;AAKA,MAAa,kBAAkB,EAC5B,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,gBAAgB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAC/D,KAAK;CACJ,IAAI;CACJ,OAAO;CACP,aACE;CACH,CAAC"}
+{"version":3,"file":"session.mjs","names":[],"sources":["../../src/data/session.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Session IDs can be:\n// - Plain UUIDv7 (from client SDK)\n// - \"server_\" prefixed UUIDv7 (server-side fallback when no client session exists)\nexport const sessionIdSchema = z\n  .union([z.uuidv7(), z.templateLiteral([\"server_\", z.uuidv7()])])\n  .meta({\n    id: \"SessionId\",\n    title: \"SessionId\",\n    description:\n      \"UUIDv7 (from the client SDK) or server_<uuidv7> (server-side fallback).\",\n  })\n  .brand<\"SessionId\">();\n\nexport type SessionId = z.infer<typeof sessionIdSchema>;\n"],"mappings":"wBAKA,MAAa,EAAkB,EAC5B,MAAM,CAAC,EAAE,QAAQ,CAAE,EAAE,gBAAgB,CAAC,UAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAC/D,KAAK,CACJ,GAAI,YACJ,MAAO,YACP,YACE,0EACH,CAAC,CACD,OAAoB"}

package/dist/data/source-maps.d.mts

@@ -1,40 +1,146 @@
 import { z } from "zod";
 
 //#region src/data/source-maps.d.ts
-declare const getSourceMapPath: ({
-  organizationId,
-  surfaceId,
-  buildId,
-  relativePath
-}: {
-  organizationId: string;
-  surfaceId: string;
-  buildId: string;
-  relativePath: string;
-}) => string;
+/**
+ * Bundler that produced this source-map upload. Reported back in the
+ * SDK `bundler` upload metric for diagnostics. Mandatory now —
+ * server-side suffix-matching against `chunkUrl` is uniform across
+ * bundlers, but knowing which bundler produced the manifest is still
+ * useful for diagnostics (different bundlers exhibit different stack
+ * shapes; we want that pivot when investigating resolution issues).
+ */
+declare const manifestBundlerSchema: z.ZodEnum<{
+  tsc: "tsc";
+  turbopack: "turbopack";
+  webpack: "webpack";
+}>;
+type ManifestBundler = z.infer<typeof manifestBundlerSchema>;
 declare const sourceMapManifestSchema: z.ZodObject<{
-  buildId: z.ZodString;
-  releaseId: z.ZodOptional<z.ZodString>;
+  releaseSlug: z.ZodString;
   surfaceId: z.ZodString;
   organizationId: z.ZodString;
+  bundler: z.ZodEnum<{
+    tsc: "tsc";
+    turbopack: "turbopack";
+    webpack: "webpack";
+  }>;
   createdAt: z.ZodNumber;
   files: z.ZodArray<z.ZodObject<{
-    relativePath: z.ZodString;
-    generatedFile: z.ZodString;
-    hash: z.ZodString;
+    chunkUrl: z.ZodString;
+    debugId: z.ZodString;
     objectKey: z.ZodString;
-    debugId: z.ZodOptional<z.ZodString>;
+    mapHash: z.ZodString;
   }, z.core.$strip>>;
 }, z.core.$strip>;
 type SourceMapManifest = z.infer<typeof sourceMapManifestSchema>;
-declare const getManifestPath: ({
-  organizationId,
-  surfaceId,
-  buildId
-}: {
-  organizationId: string;
-  surfaceId: string;
-  buildId: string;
-}) => string;
+/**
+ * Per-entry metadata for the legacy multipart upload endpoint
+ * (`POST /v1/releases/:slug/source-maps`). One entry per source-map file
+ * in the multipart body, paired by `path` matching the multipart filename.
+ *
+ * Every entry carries `chunkUrl` (the public URL the runtime loads the
+ * chunk from) and `debugId` — both mandatory now. The legacy multipart
+ * endpoint accepts the same shape as the new presigned-URL flow.
+ */
+declare const uploadSourceMapEntry: z.ZodObject<{
+  path: z.ZodString;
+  hash: z.ZodString;
+  debugId: z.ZodString;
+  chunkUrl: z.ZodString;
+}, z.core.$strip>;
+type UploadSourceMapEntry = z.infer<typeof uploadSourceMapEntry>;
+/**
+ * Multipart metadata for the legacy upload endpoint. The `files` field
+ * carries the actual JSON bodies as multipart File parts; this `metadata`
+ * object travels alongside as a JSON-encoded form field.
+ *
+ * This endpoint is deprecated in favour of the `/sign` + direct R2 PUT
+ * + `/complete` flow, which scales beyond the body-size limits of any
+ * worker / load balancer in front of the collector. Kept for backwards
+ * compatibility with deployed SDKs during the deprecation window.
+ *
+ * @deprecated
+ */
+declare const uploadSourceMapsMetadata: z.ZodObject<{
+  entries: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    hash: z.ZodString;
+    debugId: z.ZodString;
+    chunkUrl: z.ZodString;
+  }, z.core.$strip>>;
+  sourceFileCount: z.ZodOptional<z.ZodNumber>;
+  bundler: z.ZodEnum<{
+    tsc: "tsc";
+    turbopack: "turbopack";
+    webpack: "webpack";
+  }>;
+}, z.core.$strip>;
+type UploadSourceMapsMetadata = z.infer<typeof uploadSourceMapsMetadata>;
+declare const uploadSourceMapsResponse: z.ZodObject<{
+  ok: z.ZodBoolean;
+  processed: z.ZodNumber;
+  message: z.ZodString;
+  fileCount: z.ZodNumber;
+}, z.core.$strip>;
+type UploadSourceMapsResponse = z.infer<typeof uploadSourceMapsResponse>;
+declare const signSourceMapFile: z.ZodObject<{
+  path: z.ZodString;
+  sizeBytes: z.ZodNumber;
+  hasSourcesContent: z.ZodBoolean;
+  hasNames: z.ZodBoolean;
+  hasFile: z.ZodBoolean;
+  mappingsPresent: z.ZodBoolean;
+}, z.core.$strip>;
+declare const signSourceMapsRequest: z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    hasSourcesContent: z.ZodBoolean;
+    hasNames: z.ZodBoolean;
+    hasFile: z.ZodBoolean;
+    mappingsPresent: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SignSourceMapsRequest = z.infer<typeof signSourceMapsRequest>;
+declare const signSourceMapUpload: z.ZodObject<{
+  path: z.ZodString;
+  objectKey: z.ZodString;
+  presignedUrl: z.ZodString;
+}, z.core.$strip>;
+declare const signSourceMapsResponse: z.ZodObject<{
+  uploads: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    objectKey: z.ZodString;
+    presignedUrl: z.ZodString;
+  }, z.core.$strip>>;
+  expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type SignSourceMapsResponse = z.infer<typeof signSourceMapsResponse>;
+declare const completeSourceMapFile: z.ZodObject<{
+  path: z.ZodString;
+  hash: z.ZodString;
+  debugId: z.ZodString;
+  chunkUrl: z.ZodString;
+}, z.core.$strip>;
+declare const completeSourceMapsRequest: z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    hash: z.ZodString;
+    debugId: z.ZodString;
+    chunkUrl: z.ZodString;
+  }, z.core.$strip>>;
+  sourceFileCount: z.ZodOptional<z.ZodNumber>;
+  bundler: z.ZodEnum<{
+    tsc: "tsc";
+    turbopack: "turbopack";
+    webpack: "webpack";
+  }>;
+}, z.core.$strip>;
+type CompleteSourceMapsRequest = z.infer<typeof completeSourceMapsRequest>;
+declare const completeSourceMapsResponse: z.ZodObject<{
+  ok: z.ZodBoolean;
+  fileCount: z.ZodNumber;
+}, z.core.$strip>;
+type CompleteSourceMapsResponse = z.infer<typeof completeSourceMapsResponse>;
 //#endregion
-export { SourceMapManifest, getManifestPath, getSourceMapPath, sourceMapManifestSchema };
+export { CompleteSourceMapsRequest, CompleteSourceMapsResponse, ManifestBundler, SignSourceMapsRequest, SignSourceMapsResponse, SourceMapManifest, UploadSourceMapEntry, UploadSourceMapsMetadata, UploadSourceMapsResponse, completeSourceMapFile, completeSourceMapsRequest, completeSourceMapsResponse, manifestBundlerSchema, signSourceMapFile, signSourceMapUpload, signSourceMapsRequest, signSourceMapsResponse, sourceMapManifestSchema, uploadSourceMapEntry, uploadSourceMapsMetadata, uploadSourceMapsResponse };

package/dist/data/source-maps.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"source-maps.d.mts","names":[],"sources":["../../src/data/source-maps.ts"],"mappings":";;;cAEa,gBAAA;EAAoB,cAAA;EAAA,SAAA;EAAA,OAAA;EAAA;AAAA;EAM/B,cAAA;EACA,SAAA;EACA,OAAA;EACA,YAAA;AAAA;AAAA,cAYW,uBAAA,EAAuB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;KASxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;AAAA,cAElC,eAAA;EAAmB,cAAA;EAAA,SAAA;EAAA;AAAA;EAK9B,cAAA;EACA,SAAA;EACA,OAAA;AAAA"}
+{"version":3,"file":"source-maps.d.mts","names":[],"sources":["../../src/data/source-maps.ts"],"mappings":";;;;;AAkBA;;;;;;cAAa,qBAAA,EAAqB,CAAA,CAAA,OAAA;;;;;KAItB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAgChC,uBAAA,EAAuB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;KASxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;;;;;;;;;;cAWlC,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;KAcrB,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,oBAAA;;;;;;;;;;;;;cAcrC,wBAAA,EAAwB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;KAYzB,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,cAEzC,wBAAA,EAAwB,CAAA,CAAA,SAAA;;;;;;KASzB,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,cAEzC,iBAAA,EAAiB,CAAA,CAAA,SAAA;;;;;;;;cAWjB,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;KAWtB,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAEtC,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;cAQnB,sBAAA,EAAsB,CAAA,CAAA,SAAA;;;;;;;;KAUvB,sBAAA,GAAyB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,cAEvC,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;cAgBrB,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;KAa1B,yBAAA,GAA4B,CAAA,CAAE,KAAA,QACjC,yBAAA;AAAA,cAGI,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;KAU3B,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAClC,0BAAA"}

package/dist/data/source-maps.mjs

@@ -1,21 +1 @@
-import { z } from "zod";
-//#region src/data/source-maps.ts
-const getSourceMapPath = ({ organizationId, surfaceId, buildId, relativePath }) => `source-maps/orgs/${organizationId}/surfaces/${surfaceId}/builds/${buildId}/${relativePath}`;
-const sourceMapManifestEntrySchema = z.object({
-	relativePath: z.string(),
-	generatedFile: z.string(),
-	hash: z.string(),
-	objectKey: z.string(),
-	debugId: z.string().optional()
-});
-const sourceMapManifestSchema = z.object({
-	buildId: z.string(),
-	releaseId: z.string().optional(),
-	surfaceId: z.string(),
-	organizationId: z.string(),
-	createdAt: z.number(),
-	files: z.array(sourceMapManifestEntrySchema)
-});
-const getManifestPath = ({ organizationId, surfaceId, buildId }) => `source-maps/orgs/${organizationId}/surfaces/${surfaceId}/builds/${buildId}/_manifest.json`;
-//#endregion
-export { getManifestPath, getSourceMapPath, sourceMapManifestSchema };
+import{z as e}from"zod";const t=e.enum([`webpack`,`turbopack`,`tsc`]).meta({id:`ManifestBundler`,title:`ManifestBundler`}),n=e.object({chunkUrl:e.string(),debugId:e.string(),objectKey:e.string(),mapHash:e.string()}),r=e.object({releaseSlug:e.string(),surfaceId:e.string(),organizationId:e.string(),bundler:t,createdAt:e.number(),files:e.array(n)}),i=e.object({path:e.string().min(1),hash:e.string(),debugId:e.string(),chunkUrl:e.string()}).meta({id:`UploadSourceMapEntry`,title:`UploadSourceMapEntry`}),a=e.object({entries:e.array(i),sourceFileCount:e.number().int().nonnegative().optional(),bundler:t}).meta({id:`UploadSourceMapsMetadata`,title:`UploadSourceMapsMetadata`,description:`Metadata attached alongside uploaded source map files.`}),o=e.object({ok:e.boolean(),processed:e.number().int().nonnegative(),message:e.string(),fileCount:e.number().int().nonnegative()}).meta({id:`UploadSourceMapsResponse`,title:`UploadSourceMapsResponse`}),s=e.object({path:e.string().min(1),sizeBytes:e.number().int().nonnegative(),hasSourcesContent:e.boolean(),hasNames:e.boolean(),hasFile:e.boolean(),mappingsPresent:e.boolean()}).meta({id:`SignSourceMapFile`,title:`SignSourceMapFile`}),c=e.object({files:e.array(s)}).meta({id:`SignSourceMapsRequest`,title:`SignSourceMapsRequest`,description:"Per-file metadata the SDK uses to obtain presigned PUT URLs. The server validates per-file size and total file count, then issues short-lived URLs scoped to the release's R2 prefix. The SDK uploads to R2 directly and follows up with a `complete` call to materialize the manifest."}),l=e.object({path:e.string(),objectKey:e.string(),presignedUrl:e.string()}).meta({id:`SignSourceMapUpload`,title:`SignSourceMapUpload`}),u=e.object({uploads:e.array(l),expiresAt:e.number().int()}).meta({id:`SignSourceMapsResponse`,title:`SignSourceMapsResponse`}),d=e.object({path:e.string().min(1),hash:e.string(),debugId:e.string(),chunkUrl:e.string()}).meta({id:`CompleteSourceMapFile`,title:`CompleteSourceMapFile`}),f=e.object({files:e.array(d),sourceFileCount:e.number().int().nonnegative().optional(),bundler:t}).meta({id:`CompleteSourceMapsRequest`,title:`CompleteSourceMapsRequest`,description:"Finalizes a presigned-URL upload batch. Writes the source-map manifest and updates the release's `sourceMapCount` / `sourceFileCount`. Idempotent — safe to retry."}),p=e.object({ok:e.boolean(),fileCount:e.number().int().nonnegative()}).meta({id:`CompleteSourceMapsResponse`,title:`CompleteSourceMapsResponse`});export{d as completeSourceMapFile,f as completeSourceMapsRequest,p as completeSourceMapsResponse,t as manifestBundlerSchema,s as signSourceMapFile,l as signSourceMapUpload,c as signSourceMapsRequest,u as signSourceMapsResponse,r as sourceMapManifestSchema,i as uploadSourceMapEntry,a as uploadSourceMapsMetadata,o as uploadSourceMapsResponse};

package/dist/data/source-maps.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"source-maps.mjs","names":[],"sources":["../../src/data/source-maps.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const getSourceMapPath = ({\n  organizationId,\n  surfaceId,\n  buildId,\n  relativePath,\n}: {\n  organizationId: string;\n  surfaceId: string;\n  buildId: string;\n  relativePath: string;\n}) =>\n  `source-maps/orgs/${organizationId}/surfaces/${surfaceId}/builds/${buildId}/${relativePath}`;\n\nconst sourceMapManifestEntrySchema = z.object({\n  relativePath: z.string(),\n  generatedFile: z.string(),\n  hash: z.string(),\n  objectKey: z.string(),\n  debugId: z.string().optional(),\n});\n\nexport const sourceMapManifestSchema = z.object({\n  buildId: z.string(),\n  releaseId: z.string().optional(),\n  surfaceId: z.string(),\n  organizationId: z.string(),\n  createdAt: z.number(),\n  files: z.array(sourceMapManifestEntrySchema),\n});\n\nexport type SourceMapManifest = z.infer<typeof sourceMapManifestSchema>;\n\nexport const getManifestPath = ({\n  organizationId,\n  surfaceId,\n  buildId,\n}: {\n  organizationId: string;\n  surfaceId: string;\n  buildId: string;\n}) =>\n  `source-maps/orgs/${organizationId}/surfaces/${surfaceId}/builds/${buildId}/_manifest.json`;\n"],"mappings":";;AAEA,MAAa,oBAAoB,EAC/B,gBACA,WACA,SACA,mBAOA,oBAAoB,eAAe,YAAY,UAAU,UAAU,QAAQ,GAAG;AAEhF,MAAM,+BAA+B,EAAE,OAAO;CAC5C,cAAc,EAAE,QAAQ;CACxB,eAAe,EAAE,QAAQ;CACzB,MAAM,EAAE,QAAQ;CAChB,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC/B,CAAC;AAEF,MAAa,0BAA0B,EAAE,OAAO;CAC9C,SAAS,EAAE,QAAQ;CACnB,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAW,EAAE,QAAQ;CACrB,gBAAgB,EAAE,QAAQ;CAC1B,WAAW,EAAE,QAAQ;CACrB,OAAO,EAAE,MAAM,6BAA6B;CAC7C,CAAC;AAIF,MAAa,mBAAmB,EAC9B,gBACA,WACA,cAMA,oBAAoB,eAAe,YAAY,UAAU,UAAU,QAAQ"}
+{"version":3,"file":"source-maps.mjs","names":[],"sources":["../../src/data/source-maps.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Source-map / manifest R2 keys live in\n// `@interfere/internal-schemas/pipeline/r2-keys` now — they're internal\n// to the producer/consumer contract between the collector and the\n// enrichment service, not part of the public SDK surface. Anything in\n// this package that needed them imported the old `getSourceMapPath` /\n// `getManifestPath` helpers; those have been removed and call sites\n// reach for `r2Keys.sourceMaps.{file,manifest}` directly.\n\n/**\n * Bundler that produced this source-map upload. Reported back in the\n * SDK `bundler` upload metric for diagnostics. Mandatory now —\n * server-side suffix-matching against `chunkUrl` is uniform across\n * bundlers, but knowing which bundler produced the manifest is still\n * useful for diagnostics (different bundlers exhibit different stack\n * shapes; we want that pivot when investigating resolution issues).\n */\nexport const manifestBundlerSchema = z\n  .enum([\"webpack\", \"turbopack\", \"tsc\"])\n  .meta({ id: \"ManifestBundler\", title: \"ManifestBundler\" });\n\nexport type ManifestBundler = z.infer<typeof manifestBundlerSchema>;\n\nconst sourceMapManifestEntrySchema = z.object({\n  /**\n   * Public path the runtime loads this chunk from — `_next/static/\n   * chunks/<hash>.js` for Next, or any deploy-relative path the\n   * bundler emits. Stored as the build-time relative path (not the\n   * fully-qualified deployed URL) because preview / production /\n   * branch deploys all share the same dist tree but resolve to\n   * different origins, so the build can't know the runtime URL up\n   * front. The server-side resolver pairs `frame.fileName` (an\n   * absolute runtime URL) to this field by suffix-matching the\n   * content-hashed filename, which works on either form. Always\n   * populated for both bundlers; turbopack discovery extends to\n   * walk JS chunks (in addition to .map files) so it can record\n   * this. Replaces the old `generatedFile` field, whose semantics\n   * differed by bundler.\n   */\n  chunkUrl: z.string(),\n  /**\n   * UUID injected into the chunk content (`//# debugId=…` comment) and\n   * the source-map JSON (`debugId` field) at build time. Mandatory\n   * now — server-side parsing depends on a chunk-side debugId comment\n   * being present so the manifest can resolve every chunk uniquely.\n   */\n  debugId: z.string(),\n  /** R2 object key for the source-map content. */\n  objectKey: z.string(),\n  /** sha256 of the source-map content for integrity / cache validation. */\n  mapHash: z.string(),\n});\n\nexport const sourceMapManifestSchema = z.object({\n  releaseSlug: z.string(),\n  surfaceId: z.string(),\n  organizationId: z.string(),\n  bundler: manifestBundlerSchema,\n  createdAt: z.number(),\n  files: z.array(sourceMapManifestEntrySchema),\n});\n\nexport type SourceMapManifest = z.infer<typeof sourceMapManifestSchema>;\n\n/**\n * Per-entry metadata for the legacy multipart upload endpoint\n * (`POST /v1/releases/:slug/source-maps`). One entry per source-map file\n * in the multipart body, paired by `path` matching the multipart filename.\n *\n * Every entry carries `chunkUrl` (the public URL the runtime loads the\n * chunk from) and `debugId` — both mandatory now. The legacy multipart\n * endpoint accepts the same shape as the new presigned-URL flow.\n */\nexport const uploadSourceMapEntry = z\n  .object({\n    path: z.string().min(1),\n    hash: z.string(),\n    debugId: z.string(),\n    /**\n     * Build-time relative chunk path (`_next/static/chunks/<hash>.js`,\n     * etc.) — see `sourceMapManifestEntrySchema.chunkUrl` for why\n     * this isn't an absolute URL.\n     */\n    chunkUrl: z.string(),\n  })\n  .meta({ id: \"UploadSourceMapEntry\", title: \"UploadSourceMapEntry\" });\n\nexport type UploadSourceMapEntry = z.infer<typeof uploadSourceMapEntry>;\n\n/**\n * Multipart metadata for the legacy upload endpoint. The `files` field\n * carries the actual JSON bodies as multipart File parts; this `metadata`\n * object travels alongside as a JSON-encoded form field.\n *\n * This endpoint is deprecated in favour of the `/sign` + direct R2 PUT\n * + `/complete` flow, which scales beyond the body-size limits of any\n * worker / load balancer in front of the collector. Kept for backwards\n * compatibility with deployed SDKs during the deprecation window.\n *\n * @deprecated\n */\nexport const uploadSourceMapsMetadata = z\n  .object({\n    entries: z.array(uploadSourceMapEntry),\n    sourceFileCount: z.number().int().nonnegative().optional(),\n    bundler: manifestBundlerSchema,\n  })\n  .meta({\n    id: \"UploadSourceMapsMetadata\",\n    title: \"UploadSourceMapsMetadata\",\n    description: \"Metadata attached alongside uploaded source map files.\",\n  });\n\nexport type UploadSourceMapsMetadata = z.infer<typeof uploadSourceMapsMetadata>;\n\nexport const uploadSourceMapsResponse = z\n  .object({\n    ok: z.boolean(),\n    processed: z.number().int().nonnegative(),\n    message: z.string(),\n    fileCount: z.number().int().nonnegative(),\n  })\n  .meta({ id: \"UploadSourceMapsResponse\", title: \"UploadSourceMapsResponse\" });\n\nexport type UploadSourceMapsResponse = z.infer<typeof uploadSourceMapsResponse>;\n\nexport const signSourceMapFile = z\n  .object({\n    path: z.string().min(1),\n    sizeBytes: z.number().int().nonnegative(),\n    hasSourcesContent: z.boolean(),\n    hasNames: z.boolean(),\n    hasFile: z.boolean(),\n    mappingsPresent: z.boolean(),\n  })\n  .meta({ id: \"SignSourceMapFile\", title: \"SignSourceMapFile\" });\n\nexport const signSourceMapsRequest = z\n  .object({\n    files: z.array(signSourceMapFile),\n  })\n  .meta({\n    id: \"SignSourceMapsRequest\",\n    title: \"SignSourceMapsRequest\",\n    description:\n      \"Per-file metadata the SDK uses to obtain presigned PUT URLs. The server validates per-file size and total file count, then issues short-lived URLs scoped to the release's R2 prefix. The SDK uploads to R2 directly and follows up with a `complete` call to materialize the manifest.\",\n  });\n\nexport type SignSourceMapsRequest = z.infer<typeof signSourceMapsRequest>;\n\nexport const signSourceMapUpload = z\n  .object({\n    path: z.string(),\n    objectKey: z.string(),\n    presignedUrl: z.string(),\n  })\n  .meta({ id: \"SignSourceMapUpload\", title: \"SignSourceMapUpload\" });\n\nexport const signSourceMapsResponse = z\n  .object({\n    uploads: z.array(signSourceMapUpload),\n    expiresAt: z.number().int(),\n  })\n  .meta({\n    id: \"SignSourceMapsResponse\",\n    title: \"SignSourceMapsResponse\",\n  });\n\nexport type SignSourceMapsResponse = z.infer<typeof signSourceMapsResponse>;\n\nexport const completeSourceMapFile = z\n  .object({\n    path: z.string().min(1),\n    hash: z.string(),\n    debugId: z.string(),\n    /**\n     * Build-time relative chunk path. See\n     * `sourceMapManifestEntrySchema.chunkUrl` for the rationale —\n     * preview / prod / branch deploys share dist trees but resolve\n     * to different runtime origins, and the build doesn't know\n     * which one it'll be.\n     */\n    chunkUrl: z.string(),\n  })\n  .meta({ id: \"CompleteSourceMapFile\", title: \"CompleteSourceMapFile\" });\n\nexport const completeSourceMapsRequest = z\n  .object({\n    files: z.array(completeSourceMapFile),\n    sourceFileCount: z.number().int().nonnegative().optional(),\n    bundler: manifestBundlerSchema,\n  })\n  .meta({\n    id: \"CompleteSourceMapsRequest\",\n    title: \"CompleteSourceMapsRequest\",\n    description:\n      \"Finalizes a presigned-URL upload batch. Writes the source-map manifest and updates the release's `sourceMapCount` / `sourceFileCount`. Idempotent — safe to retry.\",\n  });\n\nexport type CompleteSourceMapsRequest = z.infer<\n  typeof completeSourceMapsRequest\n>;\n\nexport const completeSourceMapsResponse = z\n  .object({\n    ok: z.boolean(),\n    fileCount: z.number().int().nonnegative(),\n  })\n  .meta({\n    id: \"CompleteSourceMapsResponse\",\n    title: \"CompleteSourceMapsResponse\",\n  });\n\nexport type CompleteSourceMapsResponse = z.infer<\n  typeof completeSourceMapsResponse\n>;\n"],"mappings":"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"}

package/dist/events/error.d.mts

@@ -1,52 +1,145 @@
 import { z } from "zod";
 
 //#region src/events/error.d.ts
-declare const enrichedFrameSchema: z.ZodObject<{
+declare const resolvedFrameSchema: z.ZodObject<{
+  ingestedId: z.ZodString;
+  inApp: z.ZodBoolean;
   file: z.ZodNullable<z.ZodString>;
   line: z.ZodNullable<z.ZodNumber>;
   column: z.ZodNullable<z.ZodNumber>;
   fn: z.ZodNullable<z.ZodString>;
+  resolved: z.ZodLiteral<true>;
   originalFile: z.ZodNullable<z.ZodString>;
   originalLine: z.ZodNullable<z.ZodNumber>;
   originalColumn: z.ZodNullable<z.ZodNumber>;
   originalName: z.ZodNullable<z.ZodString>;
-  sourceMapFound: z.ZodBoolean;
+}, z.core.$strip>;
+declare const unresolvedFrameSchema: z.ZodObject<{
+  ingestedId: z.ZodString;
   inApp: z.ZodBoolean;
-  rawId: z.ZodString;
+  file: z.ZodNullable<z.ZodString>;
+  line: z.ZodNullable<z.ZodNumber>;
+  column: z.ZodNullable<z.ZodNumber>;
+  fn: z.ZodNullable<z.ZodString>;
+  resolved: z.ZodLiteral<false>;
 }, z.core.$strip>;
+declare const enrichedFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  ingestedId: z.ZodString;
+  inApp: z.ZodBoolean;
+  file: z.ZodNullable<z.ZodString>;
+  line: z.ZodNullable<z.ZodNumber>;
+  column: z.ZodNullable<z.ZodNumber>;
+  fn: z.ZodNullable<z.ZodString>;
+  resolved: z.ZodLiteral<true>;
+  originalFile: z.ZodNullable<z.ZodString>;
+  originalLine: z.ZodNullable<z.ZodNumber>;
+  originalColumn: z.ZodNullable<z.ZodNumber>;
+  originalName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  ingestedId: z.ZodString;
+  inApp: z.ZodBoolean;
+  file: z.ZodNullable<z.ZodString>;
+  line: z.ZodNullable<z.ZodNumber>;
+  column: z.ZodNullable<z.ZodNumber>;
+  fn: z.ZodNullable<z.ZodString>;
+  resolved: z.ZodLiteral<false>;
+}, z.core.$strip>], "resolved">;
 type EnrichedFrame = z.infer<typeof enrichedFrameSchema>;
-declare const errorFactsPayloadSchema: z.ZodObject<{
-  frames: z.ZodArray<z.ZodObject<{
-    fileName: z.ZodOptional<z.ZodString>;
-    functionName: z.ZodOptional<z.ZodString>;
-    lineNumber: z.ZodOptional<z.ZodNumber>;
-    columnNumber: z.ZodOptional<z.ZodNumber>;
-    source: z.ZodOptional<z.ZodString>;
-    debugId: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>>;
-  enrichedFrames: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    file: z.ZodNullable<z.ZodString>;
-    line: z.ZodNullable<z.ZodNumber>;
-    column: z.ZodNullable<z.ZodNumber>;
-    fn: z.ZodNullable<z.ZodString>;
-    originalFile: z.ZodNullable<z.ZodString>;
-    originalLine: z.ZodNullable<z.ZodNumber>;
-    originalColumn: z.ZodNullable<z.ZodNumber>;
-    originalName: z.ZodNullable<z.ZodString>;
-    sourceMapFound: z.ZodBoolean;
-    inApp: z.ZodBoolean;
-    rawId: z.ZodString;
-  }, z.core.$strip>>>;
-  frameCount: z.ZodOptional<z.ZodNumber>;
-  enrichedFrameCount: z.ZodOptional<z.ZodNumber>;
+type ResolvedFrame = z.infer<typeof resolvedFrameSchema>;
+type UnresolvedFrame = z.infer<typeof unresolvedFrameSchema>;
+declare const errorMechanismSchema: z.ZodObject<{
+  type: z.ZodString;
+  handled: z.ZodBoolean;
+  synthetic: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ErrorMechanism = z.infer<typeof errorMechanismSchema>;
+declare const errorContextSchema: z.ZodObject<{
+  framework: z.ZodOptional<z.ZodString>;
+  routerKind: z.ZodOptional<z.ZodEnum<{
+    "App Router": "App Router";
+    "Pages Router": "Pages Router";
+  }>>;
+  routePath: z.ZodOptional<z.ZodString>;
+  routeType: z.ZodOptional<z.ZodEnum<{
+    action: "action";
+    middleware: "middleware";
+    proxy: "proxy";
+    render: "render";
+    route: "route";
+  }>>;
+  renderSource: z.ZodOptional<z.ZodEnum<{
+    "react-server-components": "react-server-components";
+    "react-server-components-payload": "react-server-components-payload";
+    "server-rendering": "server-rendering";
+  }>>;
+  revalidateReason: z.ZodOptional<z.ZodEnum<{
+    "on-demand": "on-demand";
+    stale: "stale";
+  }>>;
+  renderType: z.ZodOptional<z.ZodEnum<{
+    dynamic: "dynamic";
+    "dynamic-resume": "dynamic-resume";
+  }>>;
+  requestPath: z.ZodOptional<z.ZodString>;
+  requestMethod: z.ZodOptional<z.ZodString>;
+  errorDigest: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const errorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   message: z.ZodNullable<z.ZodString>;
   name: z.ZodNullable<z.ZodString>;
   stack: z.ZodNullable<z.ZodString>;
+  context: z.ZodOptional<z.ZodObject<{
+    framework: z.ZodOptional<z.ZodString>;
+    routerKind: z.ZodOptional<z.ZodEnum<{
+      "App Router": "App Router";
+      "Pages Router": "Pages Router";
+    }>>;
+    routePath: z.ZodOptional<z.ZodString>;
+    routeType: z.ZodOptional<z.ZodEnum<{
+      action: "action";
+      middleware: "middleware";
+      proxy: "proxy";
+      render: "render";
+      route: "route";
+    }>>;
+    renderSource: z.ZodOptional<z.ZodEnum<{
+      "react-server-components": "react-server-components";
+      "react-server-components-payload": "react-server-components-payload";
+      "server-rendering": "server-rendering";
+    }>>;
+    revalidateReason: z.ZodOptional<z.ZodEnum<{
+      "on-demand": "on-demand";
+      stale: "stale";
+    }>>;
+    renderType: z.ZodOptional<z.ZodEnum<{
+      dynamic: "dynamic";
+      "dynamic-resume": "dynamic-resume";
+    }>>;
+    requestPath: z.ZodOptional<z.ZodString>;
+    requestMethod: z.ZodOptional<z.ZodString>;
+    errorDigest: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
   mechanism: z.ZodOptional<z.ZodObject<{
     type: z.ZodString;
     handled: z.ZodBoolean;
     synthetic: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>>;
+  captureSource: z.ZodOptional<z.ZodString>;
+  runtime: z.ZodOptional<z.ZodString>;
+  frames: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    fn: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodString>;
+    debugId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  capture: z.ZodLiteral<"error">;
+}, z.core.$strip>, z.ZodObject<{
+  message: z.ZodNullable<z.ZodString>;
+  name: z.ZodNullable<z.ZodString>;
+  stack: z.ZodNullable<z.ZodString>;
   context: z.ZodOptional<z.ZodObject<{
     framework: z.ZodOptional<z.ZodString>;
     routerKind: z.ZodOptional<z.ZodEnum<{
@@ -78,14 +171,25 @@ declare const errorFactsPayloadSchema: z.ZodObject<{
     requestMethod: z.ZodOptional<z.ZodString>;
     errorDigest: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
-  captureSource: z.ZodOptional<z.ZodString>;
-  fingerprintComponents: z.ZodOptional<z.ZodObject<{
-    hash: z.ZodString;
-    components: z.ZodArray<z.ZodString>;
+  mechanism: z.ZodOptional<z.ZodObject<{
+    type: z.ZodString;
+    handled: z.ZodBoolean;
+    synthetic: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>>;
+  captureSource: z.ZodOptional<z.ZodString>;
   runtime: z.ZodOptional<z.ZodString>;
-  releaseId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-type ErrorFactsPayload = z.infer<typeof errorFactsPayloadSchema>;
+  frames: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    fn: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodString>;
+    debugId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  capture: z.ZodLiteral<"non-error">;
+  serialized: z.ZodJSONSchema;
+}, z.core.$strip>], "capture">;
+type ErrorPayload = z.infer<typeof errorPayloadSchema>;
 //#endregion
-export { EnrichedFrame, ErrorFactsPayload, errorFactsPayloadSchema };
+export { EnrichedFrame, ErrorMechanism, ErrorPayload, ResolvedFrame, UnresolvedFrame, enrichedFrameSchema, errorContextSchema, errorMechanismSchema, errorPayloadSchema };

package/dist/events/error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.mts","names":[],"sources":["../../src/events/error.ts"],"mappings":";;;cAIM,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;KAcb,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,cAkC9B,uBAAA,EAAuB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgBxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA"}
+{"version":3,"file":"error.d.mts","names":[],"sources":["../../src/events/error.ts"],"mappings":";;;cA4BM,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;cAQnB,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;cAId,mBAAA,EAAmB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;KAKpB,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAEhC,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;KAMrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyElB,kBAAA,EAAkB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}

package/dist/events/error.mjs

@@ -1,64 +1 @@
-import { z } from "zod";
-import { ingestedFrame } from "#data/frame";
-//#region src/events/error.ts
-const enrichedFrameSchema = z.object({
-	file: z.string().nullable(),
-	line: z.number().nullable(),
-	column: z.number().nullable(),
-	fn: z.string().nullable(),
-	originalFile: z.string().nullable(),
-	originalLine: z.number().nullable(),
-	originalColumn: z.number().nullable(),
-	originalName: z.string().nullable(),
-	sourceMapFound: z.boolean(),
-	inApp: z.boolean(),
-	rawId: z.string()
-});
-const errorMechanismSchema = z.object({
-	type: z.string(),
-	handled: z.boolean(),
-	synthetic: z.boolean().optional()
-});
-const errorContextSchema = z.object({
-	framework: z.string().optional(),
-	routerKind: z.enum(["Pages Router", "App Router"]).optional(),
-	routePath: z.string().optional(),
-	routeType: z.enum([
-		"render",
-		"route",
-		"action",
-		"middleware",
-		"proxy"
-	]).optional(),
-	renderSource: z.enum([
-		"react-server-components",
-		"react-server-components-payload",
-		"server-rendering"
-	]).optional(),
-	revalidateReason: z.enum(["on-demand", "stale"]).optional(),
-	renderType: z.enum(["dynamic", "dynamic-resume"]).optional(),
-	requestPath: z.string().optional(),
-	requestMethod: z.string().optional(),
-	errorDigest: z.string().optional()
-});
-const fingerprintSchema = z.object({
-	hash: z.string(),
-	components: z.array(z.string())
-});
-const errorFactsPayloadSchema = z.object({
-	frames: z.array(ingestedFrame),
-	enrichedFrames: z.array(enrichedFrameSchema).optional(),
-	frameCount: z.number().optional(),
-	enrichedFrameCount: z.number().optional(),
-	message: z.string().nullable(),
-	name: z.string().nullable(),
-	stack: z.string().nullable(),
-	mechanism: errorMechanismSchema.optional(),
-	context: errorContextSchema.optional(),
-	captureSource: z.string().optional(),
-	fingerprintComponents: fingerprintSchema.optional(),
-	runtime: z.string().optional(),
-	releaseId: z.string().nullable().optional()
-});
-//#endregion
-export { errorFactsPayloadSchema };
+import{z as e}from"zod";import{ingestedFrame as t}from"#data/frame";const n=e.object({ingestedId:e.string(),inApp:e.boolean(),file:e.string().nullable(),line:e.number().nullable(),column:e.number().nullable(),fn:e.string().nullable()}),r=n.extend({resolved:e.literal(!0),originalFile:e.string().nullable(),originalLine:e.number().nullable(),originalColumn:e.number().nullable(),originalName:e.string().nullable()}),i=n.extend({resolved:e.literal(!1)}),a=e.discriminatedUnion(`resolved`,[r,i]),o=e.object({type:e.string(),handled:e.boolean(),synthetic:e.boolean().optional()}),s=e.object({framework:e.string().optional(),routerKind:e.enum([`Pages Router`,`App Router`]).optional(),routePath:e.string().optional(),routeType:e.enum([`render`,`route`,`action`,`middleware`,`proxy`]).optional(),renderSource:e.enum([`react-server-components`,`react-server-components-payload`,`server-rendering`]).optional(),revalidateReason:e.enum([`on-demand`,`stale`]).optional(),renderType:e.enum([`dynamic`,`dynamic-resume`]).optional(),requestPath:e.string().optional(),requestMethod:e.string().optional(),errorDigest:e.string().optional()}),c=e.object({message:e.string().nullable(),name:e.string().nullable(),stack:e.string().nullable(),context:s.optional(),mechanism:o.optional(),captureSource:e.string().optional(),runtime:e.string().optional(),frames:e.array(t)}),l=c.extend({capture:e.literal(`error`)}),u=c.extend({capture:e.literal(`non-error`),serialized:e.json()}),d=e.discriminatedUnion(`capture`,[l,u]);export{a as enrichedFrameSchema,s as errorContextSchema,o as errorMechanismSchema,d as errorPayloadSchema};