@interfere/types 0.0.3 → 0.1.0-alpha.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.mts","names":[],"sources":["../../src/sdk/env.ts"],"mappings":";;;cAEa,uBAAA,EAAuB,CAAA,CAAA,SAAA;AAAA,KACxB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,uBAAA;AAAA,iBAE/B,aAAA,CAAc,KAAA,YAAiB,iBAAA;AAAA,iBAS/B,iBAAA,CACd,GAAA,EAAK,MAAA,8BACL,IAAA,sBACC,iBAAA"}

package/dist/sdk/env.mjs

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+//#region src/sdk/env.ts
+const interfereEnvValueSchema = z.string().trim().min(1);
+function parseEnvValue(value) {
+	const parsed = interfereEnvValueSchema.safeParse(value);
+	if (!parsed.success) return null;
+	return parsed.data;
+}
+function readFirstEnvValue(env, keys) {
+	for (const key of keys) {
+		const value = parseEnvValue(env[key]);
+		if (value !== null) return value;
+	}
+	return null;
+}
+//#endregion
+export { interfereEnvValueSchema, parseEnvValue, readFirstEnvValue };

package/dist/sdk/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","names":[],"sources":["../../src/sdk/env.ts"],"sourcesContent":["import { z } from \"zod/v4\";\n\nexport const interfereEnvValueSchema = z.string().trim().min(1);\nexport type InterfereEnvValue = z.infer<typeof interfereEnvValueSchema>;\n\nexport function parseEnvValue(value: unknown): InterfereEnvValue | null {\n  const parsed = interfereEnvValueSchema.safeParse(value);\n  if (!parsed.success) {\n    return null;\n  }\n\n  return parsed.data;\n}\n\nexport function readFirstEnvValue(\n  env: Record<string, string | undefined>,\n  keys: readonly string[]\n): InterfereEnvValue | null {\n  for (const key of keys) {\n    const value = parseEnvValue(env[key]);\n    if (value !== null) {\n      return value;\n    }\n  }\n\n  return null;\n}\n"],"mappings":";;AAEA,MAAa,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;AAG/D,SAAgB,cAAc,OAA0C;CACtE,MAAM,SAAS,wBAAwB,UAAU,MAAM;AACvD,KAAI,CAAC,OAAO,QACV,QAAO;AAGT,QAAO,OAAO;;AAGhB,SAAgB,kBACd,KACA,MAC0B;AAC1B,MAAK,MAAM,OAAO,MAAM;EACtB,MAAM,QAAQ,cAAc,IAAI,KAAK;AACrC,MAAI,UAAU,KACZ,QAAO;;AAIX,QAAO"}

package/dist/sdk/envelope.d.mts

@@ -0,0 +1,407 @@
+import { z } from "zod/v4";
+
+//#region src/sdk/envelope.d.ts
+declare const envelopeVersion: z.ZodUnion<readonly [z.ZodLiteral<0>]>;
+type EnvelopeVersion = z.infer<typeof envelopeVersion>;
+/**
+ * Indicates how the sessionId was resolved on the server.
+ *
+ * - "header": Extracted from x-interfere-request header (ideal case)
+ * - "async_context": Retrieved from AsyncLocalStorage context
+ * - "fallback": Generated as server-side fallback (breaks session continuity)
+ * - "client": Session ID was set on the client (browser SDK)
+ */
+declare const sessionSourceSchema: z.ZodOptional<z.ZodEnum<{
+  client: "client";
+  header: "header";
+  async_context: "async_context";
+  fallback: "fallback";
+}>>;
+type SessionSource = z.infer<typeof sessionSourceSchema>;
+declare const envelopeContextSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  runtime: z.ZodLiteral<"browser">;
+  browser: z.ZodNullable<z.ZodObject<{
+    language: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    display: z.ZodObject<{
+      screen: z.ZodObject<{
+        height: z.ZodNumber;
+        width: z.ZodNumber;
+        orientation: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  device: z.ZodNullable<z.ZodObject<{
+    browser: z.ZodObject<{
+      major: z.ZodOptional<z.ZodString>;
+      name: z.ZodOptional<z.ZodString>;
+      type: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    cpu: z.ZodObject<{
+      architecture: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    device: z.ZodObject<{
+      model: z.ZodOptional<z.ZodString>;
+      type: z.ZodOptional<z.ZodString>;
+      vendor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    engine: z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    os: z.ZodObject<{
+      name: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    ua: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  errorDigest: z.ZodOptional<z.ZodString>;
+  renderSource: z.ZodOptional<z.ZodEnum<{
+    "react-server-components": "react-server-components";
+    "react-server-components-payload": "react-server-components-payload";
+    "server-rendering": "server-rendering";
+  }>>;
+  renderType: z.ZodOptional<z.ZodEnum<{
+    dynamic: "dynamic";
+    "dynamic-resume": "dynamic-resume";
+  }>>;
+  requestMethod: z.ZodOptional<z.ZodString>;
+  requestPath: z.ZodOptional<z.ZodString>;
+  revalidateReason: z.ZodOptional<z.ZodEnum<{
+    "on-demand": "on-demand";
+    stale: "stale";
+  }>>;
+  routePath: z.ZodOptional<z.ZodString>;
+  routeType: z.ZodOptional<z.ZodEnum<{
+    render: "render";
+    route: "route";
+    action: "action";
+    middleware: "middleware";
+    proxy: "proxy";
+  }>>;
+  routerKind: z.ZodOptional<z.ZodEnum<{
+    "Pages Router": "Pages Router";
+    "App Router": "App Router";
+  }>>;
+  runtime: z.ZodLiteral<"nextjs">;
+}, z.core.$strip>, z.ZodObject<{
+  runtime: z.ZodLiteral<"edge">;
+}, z.core.$strip>], "runtime">;
+type EnvelopeContext = z.infer<typeof envelopeContextSchema>;
+declare const envelopeSchema: z.ZodIntersection<z.ZodObject<{
+  buildId: z.ZodString;
+  clientTs: z.ZodInt;
+  context: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    runtime: z.ZodLiteral<"browser">;
+    browser: z.ZodNullable<z.ZodObject<{
+      language: z.ZodOptional<z.ZodString>;
+      timezone: z.ZodOptional<z.ZodString>;
+      display: z.ZodObject<{
+        screen: z.ZodObject<{
+          height: z.ZodNumber;
+          width: z.ZodNumber;
+          orientation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    device: z.ZodNullable<z.ZodObject<{
+      browser: z.ZodObject<{
+        major: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      cpu: z.ZodObject<{
+        architecture: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      device: z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        vendor: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      engine: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      os: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      ua: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    errorDigest: z.ZodOptional<z.ZodString>;
+    renderSource: z.ZodOptional<z.ZodEnum<{
+      "react-server-components": "react-server-components";
+      "react-server-components-payload": "react-server-components-payload";
+      "server-rendering": "server-rendering";
+    }>>;
+    renderType: z.ZodOptional<z.ZodEnum<{
+      dynamic: "dynamic";
+      "dynamic-resume": "dynamic-resume";
+    }>>;
+    requestMethod: z.ZodOptional<z.ZodString>;
+    requestPath: z.ZodOptional<z.ZodString>;
+    revalidateReason: z.ZodOptional<z.ZodEnum<{
+      "on-demand": "on-demand";
+      stale: "stale";
+    }>>;
+    routePath: z.ZodOptional<z.ZodString>;
+    routeType: z.ZodOptional<z.ZodEnum<{
+      render: "render";
+      route: "route";
+      action: "action";
+      middleware: "middleware";
+      proxy: "proxy";
+    }>>;
+    routerKind: z.ZodOptional<z.ZodEnum<{
+      "Pages Router": "Pages Router";
+      "App Router": "App Router";
+    }>>;
+    runtime: z.ZodLiteral<"nextjs">;
+  }, z.core.$strip>, z.ZodObject<{
+    runtime: z.ZodLiteral<"edge">;
+  }, z.core.$strip>], "runtime">>;
+  environment: z.ZodNullable<z.ZodEnum<{
+    development: "development";
+    preview: "preview";
+    production: "production";
+  }>>;
+  releaseId: z.ZodNullable<z.ZodString>;
+  runtime: z.ZodNullable<z.ZodEnum<{
+    edge: "edge";
+    browser: "browser";
+    node: "node";
+  }>>;
+  sessionId: z.ZodNullable<z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`server_${string}`>]>>;
+  sessionSource: z.ZodOptional<z.ZodEnum<{
+    client: "client";
+    header: "header";
+    async_context: "async_context";
+    fallback: "fallback";
+  }>>;
+  uuid: z.ZodUUID;
+  v: z.ZodUnion<readonly [z.ZodLiteral<0>]>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+  payload: z.ZodObject<{
+    exceptions: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      value: z.ZodString;
+      mechanism: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        handled: z.ZodBoolean;
+        synthetic: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      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>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"error">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"pageview">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"pageleave">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"ui_event">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    ts: z.ZodNumber;
+    count: z.ZodNumber;
+    events: z.ZodArray<z.ZodString>;
+    first_event_ts: z.ZodOptional<z.ZodNumber>;
+    last_event_ts: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"replay_chunk">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    count: z.ZodNumber;
+    timeWindow: z.ZodNumber;
+    selector: z.ZodString;
+    text: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"rage_click">;
+}, z.core.$strip>], "type">>;
+type EnvelopeBase = z.infer<typeof envelopeSchema>;
+type EventType = EnvelopeBase["type"];
+type Envelope<T extends EventType | undefined = undefined> = T extends EventType ? Extract<EnvelopeBase, {
+  type: T;
+}> : EnvelopeBase;
+type EnvelopePayload<T extends EventType> = Envelope<T>["payload"];
+declare const stampedEnvelopeSchema: z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+  buildId: z.ZodString;
+  clientTs: z.ZodInt;
+  context: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    runtime: z.ZodLiteral<"browser">;
+    browser: z.ZodNullable<z.ZodObject<{
+      language: z.ZodOptional<z.ZodString>;
+      timezone: z.ZodOptional<z.ZodString>;
+      display: z.ZodObject<{
+        screen: z.ZodObject<{
+          height: z.ZodNumber;
+          width: z.ZodNumber;
+          orientation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    device: z.ZodNullable<z.ZodObject<{
+      browser: z.ZodObject<{
+        major: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      cpu: z.ZodObject<{
+        architecture: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      device: z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        vendor: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      engine: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      os: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      ua: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    errorDigest: z.ZodOptional<z.ZodString>;
+    renderSource: z.ZodOptional<z.ZodEnum<{
+      "react-server-components": "react-server-components";
+      "react-server-components-payload": "react-server-components-payload";
+      "server-rendering": "server-rendering";
+    }>>;
+    renderType: z.ZodOptional<z.ZodEnum<{
+      dynamic: "dynamic";
+      "dynamic-resume": "dynamic-resume";
+    }>>;
+    requestMethod: z.ZodOptional<z.ZodString>;
+    requestPath: z.ZodOptional<z.ZodString>;
+    revalidateReason: z.ZodOptional<z.ZodEnum<{
+      "on-demand": "on-demand";
+      stale: "stale";
+    }>>;
+    routePath: z.ZodOptional<z.ZodString>;
+    routeType: z.ZodOptional<z.ZodEnum<{
+      render: "render";
+      route: "route";
+      action: "action";
+      middleware: "middleware";
+      proxy: "proxy";
+    }>>;
+    routerKind: z.ZodOptional<z.ZodEnum<{
+      "Pages Router": "Pages Router";
+      "App Router": "App Router";
+    }>>;
+    runtime: z.ZodLiteral<"nextjs">;
+  }, z.core.$strip>, z.ZodObject<{
+    runtime: z.ZodLiteral<"edge">;
+  }, z.core.$strip>], "runtime">>;
+  environment: z.ZodNullable<z.ZodEnum<{
+    development: "development";
+    preview: "preview";
+    production: "production";
+  }>>;
+  releaseId: z.ZodNullable<z.ZodString>;
+  runtime: z.ZodNullable<z.ZodEnum<{
+    edge: "edge";
+    browser: "browser";
+    node: "node";
+  }>>;
+  sessionId: z.ZodNullable<z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`server_${string}`>]>>;
+  sessionSource: z.ZodOptional<z.ZodEnum<{
+    client: "client";
+    header: "header";
+    async_context: "async_context";
+    fallback: "fallback";
+  }>>;
+  uuid: z.ZodUUID;
+  v: z.ZodUnion<readonly [z.ZodLiteral<0>]>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+  payload: z.ZodObject<{
+    exceptions: z.ZodArray<z.ZodObject<{
+      type: z.ZodString;
+      value: z.ZodString;
+      mechanism: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        handled: z.ZodBoolean;
+        synthetic: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      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>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"error">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"pageview">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"pageleave">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"ui_event">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    ts: z.ZodNumber;
+    count: z.ZodNumber;
+    events: z.ZodArray<z.ZodString>;
+    first_event_ts: z.ZodOptional<z.ZodNumber>;
+    last_event_ts: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"replay_chunk">;
+}, z.core.$strip>, z.ZodObject<{
+  payload: z.ZodObject<{
+    count: z.ZodNumber;
+    timeWindow: z.ZodNumber;
+    selector: z.ZodString;
+    text: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"rage_click">;
+}, z.core.$strip>], "type">>, z.ZodObject<{
+  surfaceSlug: z.ZodString;
+}, z.core.$strip>>;
+type StampedEnvelope = z.infer<typeof stampedEnvelopeSchema>;
+//#endregion
+export { Envelope, EnvelopeContext, EnvelopePayload, EnvelopeVersion, EventType, SessionSource, StampedEnvelope, envelopeContextSchema, envelopeSchema, sessionSourceSchema, stampedEnvelopeSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.mts","names":[],"sources":["../../src/sdk/envelope.ts"],"mappings":";;;cAiBM,eAAA,EAAe,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,UAAA;AAAA,KAET,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,eAAA;AAnBlB;;;;;;;;AAAA,cA6Bd,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,cAehC,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;AAAA,cAE/C,qBAAA,EAAqB,CAAA,CAAA,eAAA,CAAA,CAAA,CAAA,eAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/sdk/envelope.mjs

@@ -0,0 +1,72 @@
+import { z } from "zod/v4";
+import { errorEnvelopePayloadSchema } from "#sdk/plugins/payload/errors";
+import { pageleavePayloadSchema, pageviewPayloadSchema, uiEventPayloadSchema } from "#sdk/plugins/payload/page-events";
+import { rageClickPayloadSchema } from "#sdk/plugins/payload/rage-click";
+import { envSchema, runtimeSchema } from "#sdk/runtime";
+import { sessionIdSchema } from "#data/session";
+import { surfaceSlugSchema } from "#data/surface";
+import { browserContextSchema } from "#sdk/plugins/context/browser";
+import { edgeContextSchema } from "#sdk/plugins/context/edge";
+import { nextjsContextSchema } from "#sdk/plugins/context/next";
+import { replayChunkPayloadSchema } from "#sdk/plugins/payload/replay";
+//#region src/sdk/envelope.ts
+const envelopeVersion = z.union([z.literal(0)]);
+/**
+* Indicates how the sessionId was resolved on the server.
+*
+* - "header": Extracted from x-interfere-request header (ideal case)
+* - "async_context": Retrieved from AsyncLocalStorage context
+* - "fallback": Generated as server-side fallback (breaks session continuity)
+* - "client": Session ID was set on the client (browser SDK)
+*/
+const sessionSourceSchema = z.enum([
+	"header",
+	"async_context",
+	"fallback",
+	"client"
+]).optional();
+const envelopeContextSchema = z.discriminatedUnion("runtime", [
+	browserContextSchema,
+	nextjsContextSchema,
+	edgeContextSchema
+]);
+const envelopeSchema = z.object({
+	buildId: z.string(),
+	clientTs: z.int(),
+	context: envelopeContextSchema.optional(),
+	environment: envSchema,
+	releaseId: z.string().nullable(),
+	runtime: runtimeSchema,
+	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")
+	})
+]));
+const stampedEnvelopeSchema = z.intersection(envelopeSchema, z.object({ surfaceSlug: surfaceSlugSchema }));
+//#endregion
+export { envelopeContextSchema, envelopeSchema, sessionSourceSchema, stampedEnvelopeSchema };

package/dist/sdk/envelope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.mjs","names":[],"sources":["../../src/sdk/envelope.ts"],"sourcesContent":["import { z } from \"zod/v4\";\n\nimport { sessionIdSchema } from \"#data/session\";\nimport { surfaceSlugSchema } from \"#data/surface\";\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\nexport type EnvelopeVersion = z.infer<typeof envelopeVersion>;\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  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\nexport const stampedEnvelopeSchema = z.intersection(\n  envelopeSchema,\n  z.object({\n    surfaceSlug: surfaceSlugSchema,\n  })\n);\n\nexport type StampedEnvelope = z.infer<typeof stampedEnvelopeSchema>;\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAM,kBAAkB,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;;;;;;;;;AAY/C,MAAa,sBAAsB,EAChC,KAAK;CAAC;CAAU;CAAiB;CAAY;CAAS,CAAC,CACvD,UAAU;AAIb,MAAa,wBAAwB,EAAE,mBAAmB,WAAW;CACnE;CACA;CACA;CACD,CAAC;AAiBF,MAAa,iBAbiB,EAAE,OAAO;CACrC,SAAS,EAAE,QAAQ;CACnB,UAAU,EAAE,KAAK;CACjB,SAAS,sBAAsB,UAAU;CACzC,aAAa;CACb,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;AAWD,MAAa,wBAAwB,EAAE,aACrC,gBACA,EAAE,OAAO,EACP,aAAa,mBACd,CAAC,CACH"}

package/dist/sdk/errors.d.mts

@@ -0,0 +1,7 @@
+import { ErrorMechanism, ExceptionValue } from "#sdk/plugins/payload/errors";
+
+//#region src/sdk/errors.d.ts
+declare function toError(error: unknown): Error;
+declare function toExceptions(error: Error, mechanism: ErrorMechanism): ExceptionValue[];
+//#endregion
+export { toError, toExceptions };

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/sdk/errors.ts"],"mappings":";;;iBAUgB,OAAA,CAAQ,KAAA,YAAiB,KAAA;AAAA,iBAYzB,YAAA,CACd,KAAA,EAAO,KAAA,EACP,SAAA,EAAW,cAAA,GACV,cAAA"}

package/dist/sdk/errors.mjs

@@ -0,0 +1,33 @@
+import { parse } from "error-stack-parser-es";
+//#region src/sdk/errors.ts
+const MAX_CAUSE_DEPTH = 5;
+function toError(error) {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	return new Error(String(error));
+}
+function toExceptions(error, mechanism) {
+	const exceptions = [];
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth += 1) {
+		exceptions.push({
+			type: current.name,
+			value: current.message,
+			mechanism: depth === 0 ? mechanism : void 0,
+			frames: parse(current, { allowEmpty: true }).map(normalizeFrame)
+		});
+		current = current.cause instanceof Error ? current.cause : void 0;
+	}
+	return exceptions;
+}
+function normalizeFrame(frame) {
+	return {
+		fileName: typeof frame.fileName === "string" ? frame.fileName : void 0,
+		functionName: typeof frame.functionName === "string" ? frame.functionName : void 0,
+		lineNumber: typeof frame.lineNumber === "number" ? frame.lineNumber : void 0,
+		columnNumber: typeof frame.columnNumber === "number" ? frame.columnNumber : void 0,
+		source: typeof frame.source === "string" ? frame.source : void 0
+	};
+}
+//#endregion
+export { toError, toExceptions };

package/dist/sdk/errors.mjs.map

@@ -0,0 +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\nconst MAX_CAUSE_DEPTH = 5;\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 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(normalizeFrame),\n    });\n\n    current = current.cause instanceof Error ? current.cause : undefined;\n  }\n\n  return exceptions;\n}\n\nfunction normalizeFrame(frame: {\n  fileName?: unknown;\n  functionName?: unknown;\n  lineNumber?: unknown;\n  columnNumber?: unknown;\n  source?: unknown;\n}): IngestedFrame {\n  return {\n    fileName: typeof frame.fileName === \"string\" ? frame.fileName : undefined,\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  };\n}\n"],"mappings":";;AAQA,MAAM,kBAAkB;AAExB,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,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,IAAI,eAAe;GACjE,CAAC;AAEF,YAAU,QAAQ,iBAAiB,QAAQ,QAAQ,QAAQ,KAAA;;AAG7D,QAAO;;AAGT,SAAS,eAAe,OAMN;AAChB,QAAO;EACL,UAAU,OAAO,MAAM,aAAa,WAAW,MAAM,WAAW,KAAA;EAChE,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;EAC3D"}

package/dist/sdk/identify.d.mts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+//#region src/sdk/identify.d.ts
+declare const identifyParamsSchema: z.ZodObject<{
+  avatar: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  identifier: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type IdentifyParams = z.infer<typeof identifyParamsSchema>;
+//#endregion
+export { IdentifyParams, identifyParamsSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"identify.d.mts","names":[],"sources":["../../src/sdk/identify.ts"],"mappings":";;;cAEa,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;KAQrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA"}

package/dist/sdk/identify.mjs

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+//#region src/sdk/identify.ts
+const identifyParamsSchema = z.object({
+	avatar: z.string().optional(),
+	email: z.string().optional(),
+	identifier: z.string(),
+	name: z.string().optional(),
+	traits: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
+export { identifyParamsSchema };

package/dist/sdk/identify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify.mjs","names":[],"sources":["../../src/sdk/identify.ts"],"sourcesContent":["import { z } from \"zod/v4\";\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  traits: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type IdentifyParams = z.infer<typeof identifyParamsSchema>;\n"],"mappings":";;AAEA,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,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACrD,CAAC"}

package/dist/sdk/packages.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+//#region src/sdk/packages.d.ts
+declare const interferePackageSchema: z.ZodUnion<readonly [z.ZodLiteral<"react">, z.ZodLiteral<"next">, z.ZodString]>;
+type InterferePackage = z.infer<typeof interferePackageSchema>;
+//#endregion
+export { InterferePackage, interferePackageSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"packages.d.mts","names":[],"sources":["../../src/sdk/packages.ts"],"mappings":";;;cAEa,sBAAA,EAAsB,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,UAAA,WAAA,CAAA,CAAA,UAAA,UAAA,CAAA,CAAA,SAAA;AAAA,KAMvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA"}

package/dist/sdk/packages.mjs

@@ -0,0 +1,9 @@
+import { z } from "zod";
+//#region src/sdk/packages.ts
+const interferePackageSchema = z.union([
+	z.literal("react"),
+	z.literal("next"),
+	z.string()
+]);
+//#endregion
+export { interferePackageSchema };

package/dist/sdk/packages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"packages.mjs","names":[],"sources":["../../src/sdk/packages.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const interferePackageSchema = z.union([\n  z.literal(\"react\"),\n  z.literal(\"next\"),\n  z.string(),\n]);\n\nexport type InterferePackage = z.infer<typeof interferePackageSchema>;\n"],"mappings":";;AAEA,MAAa,yBAAyB,EAAE,MAAM;CAC5C,EAAE,QAAQ,QAAQ;CAClB,EAAE,QAAQ,OAAO;CACjB,EAAE,QAAQ;CACX,CAAC"}