@interfere/types 0.0.2 → 0.1.0-alpha.1

package/dist/sdk/config.d.mts

@@ -0,0 +1,184 @@
+import { z } from "zod/v4";
+
+//#region src/sdk/config.d.ts
+declare const offlineStorageSchema: z.ZodDefault<z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  maxQueueSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+type OfflineStorage = z.infer<typeof offlineStorageSchema>;
+declare const apiBaseUrlSchema: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
+  "https://api.interfere.com": "https://api.interfere.com";
+  "http://localhost:3001": "http://localhost:3001";
+}>]>;
+declare const featuresSchema: z.ZodDefault<z.ZodObject<{
+  errors: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  replay: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  aiSummary: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  serverTracing: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$strip>>;
+type Features = z.infer<typeof featuresSchema>;
+declare const configSchema: z.ZodPipe<z.ZodIntersection<z.ZodObject<{
+  features: z.ZodDefault<z.ZodObject<{
+    errors: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    replay: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    aiSummary: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    serverTracing: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  }, z.core.$strip>>;
+  metadata: z.ZodObject<{
+    buildId: z.ZodNullable<z.ZodString>;
+    releaseId: z.ZodNullable<z.ZodString>;
+    environment: z.ZodNullable<z.ZodEnum<{
+      development: "development";
+      preview: "preview";
+      production: "production";
+    }>>;
+    runtime: z.ZodNullable<z.ZodEnum<{
+      edge: "edge";
+      browser: "browser";
+      node: "node";
+    }>>;
+  }, z.core.$strip>;
+  batch: z.ZodDefault<z.ZodObject<{
+    size: z.ZodDefault<z.ZodNumber>;
+    ms: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  offline: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxQueueSize: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+  proxyUrl: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  ingestUrl: z.ZodString;
+  surfaceToken: z.ZodString;
+}, z.core.$strip>]>>, z.ZodTransform<({
+  features: {
+    errors?: boolean | undefined;
+    replay?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    aiSummary?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    serverTracing?: boolean | undefined;
+  };
+  metadata: {
+    buildId: string | null;
+    releaseId: string | null;
+    environment: "development" | "preview" | "production" | null;
+    runtime: "edge" | "browser" | "node" | null;
+  };
+  batch: {
+    size: number;
+    ms: number;
+  };
+  offline: {
+    enabled: boolean;
+    maxQueueSize: number;
+  };
+} & {
+  proxyUrl: string;
+}) | ({
+  features: {
+    errors?: boolean | undefined;
+    replay?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    aiSummary?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    serverTracing?: boolean | undefined;
+  };
+  metadata: {
+    buildId: string | null;
+    releaseId: string | null;
+    environment: "development" | "preview" | "production" | null;
+    runtime: "edge" | "browser" | "node" | null;
+  };
+  batch: {
+    size: number;
+    ms: number;
+  };
+  offline: {
+    enabled: boolean;
+    maxQueueSize: number;
+  };
+} & {
+  ingestUrl: string;
+  surfaceToken: string;
+}), {
+  features: {
+    errors?: boolean | undefined;
+    replay?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    aiSummary?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    serverTracing?: boolean | undefined;
+  };
+  metadata: {
+    buildId: string | null;
+    releaseId: string | null;
+    environment: "development" | "preview" | "production" | null;
+    runtime: "edge" | "browser" | "node" | null;
+  };
+  batch: {
+    size: number;
+    ms: number;
+  };
+  offline: {
+    enabled: boolean;
+    maxQueueSize: number;
+  };
+} & ({
+  proxyUrl: string;
+} | {
+  ingestUrl: string;
+  surfaceToken: string;
+})>>;
+type Config = z.output<typeof configSchema>;
+declare const configInputSchema: z.ZodIntersection<z.ZodObject<{
+  features: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    errors: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    replay: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    aiSummary: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    serverTracing: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  }, z.core.$strip>>>;
+  metadata: z.ZodOptional<z.ZodObject<{
+    buildId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    releaseId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    environment: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+      development: "development";
+      preview: "preview";
+      production: "production";
+    }>>>;
+    runtime: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+      edge: "edge";
+      browser: "browser";
+      node: "node";
+    }>>>;
+  }, z.core.$strip>>;
+  batch: z.ZodOptional<z.ZodObject<{
+    size: z.ZodOptional<z.ZodNumber>;
+    ms: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  offline: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxQueueSize: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+  proxyUrl: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  ingestUrl: z.ZodString;
+  surfaceToken: z.ZodString;
+}, z.core.$strip>]>>;
+type ConfigInput = z.infer<typeof configInputSchema>;
+declare const persistenceTypeSchema: z.ZodEnum<{
+  localStorage: "localStorage";
+  sessionStorage: "sessionStorage";
+  memory: "memory";
+}>;
+type PersistenceType = z.infer<typeof persistenceTypeSchema>;
+//#endregion
+export { Config, ConfigInput, Features, OfflineStorage, PersistenceType, apiBaseUrlSchema, configInputSchema, configSchema, featuresSchema, offlineStorageSchema, persistenceTypeSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/sdk/config.ts"],"sourcesContent":[],"mappings":";;;cAYa,sBAAoB,CAAA,CAAA,WAAA,CAAA,CAAA;;EAApB,YAAA,cAcoC,YAAA,CAAA;;KAErC,cAAA,GAAiB,CAAA,CAAE,aAAa;cAE/B,kBAAgB,CAAA,CAAA,mBAAA,CAAA,CAAA,WAAA,CAAA,CAAA;;;CAlBI,CAAA,CAAA,CAAA;AAAA,cAuBpB,cAvBoB,EAuBN,CAAA,CAAA,UAvBM,CAuBN,CAAA,CAAA,SAvBM,CAAA;EAAA,MAAA,eAAA,aAAA,aAAA,CAAA,CAAA;EAgBrB,MAAA,eAAc,aAAkB,aAAA,CAAA,CAAA;EAE/B,SAAA,eAGX,aAAA,aAAA,CAAA,CAAA;EAH2B,SAAA,eAAA,aAAA,aAAA,CAAA,CAAA;EAAA,UAAA,eAAA,aAAA,aAAA,CAAA,CAAA;EAAA,aAAA,eAAA,aAAA,aAAA,CAAA,CAAA;CAAA,eAAA,CAAA,CAAA;AAKhB,KAgBD,QAAA,GAAW,CAAA,CAAE,KAFtB,CAAA,OAEmC,cAFnC,CAAA;cAkCU,cAAY,CAAA,CAAA,QAAA,CAAA,CAAA,gBAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;MAhDE,OAAA,EAAA,SAAA;MAAA,IAAA,EAAA,MAAA;IAAA,CAAA,CAAA,CAAA;EAgBf,CAAA,eAAQ,CAAA;EAgCP,KAAA,cAaT,YAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAbqB,QAAA,EAAA;;;;;;;;;EAAA,CAAA;;IAAA,OAAA,EAAA,OAAA;IAAA,YAAA,EAAA,MAAA;EAeb,CAAA;AAEZ,CAAA,GAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAFD,MAAA,GAAS,CAAA,CAAE,cAAc;cAExB,mBAAiB,CAAA,CAAA,gBAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;IAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;EAAA,CAAA,eAAA,CAAA,CAAA,CAAA;CAAA,eAAA,CAAA,YAAA,CAAA,SAAA,YAAA,CAAA;EAuBlB,QAAA,aAAW;AAEvB,CAAA,eAAa,CAAA,aAIX,CAAA;EAEU,SAAA,aAAe;;;KARf,WAAA,GAAc,CAAA,CAAE,aAAa;cAE5B,uBAAqB,CAAA,CAAA;;;;;KAMtB,eAAA,GAAkB,CAAA,CAAE,aAAa"}

package/dist/sdk/config.mjs

@@ -0,0 +1,69 @@
+import { PLUGIN_MANIFEST } from "./plugins/manifest.mjs";
+import { API_URL } from "@interfere/constants/api";
+import { z } from "zod/v4";
+import { envSchema, runtimeSchema } from "#sdk/runtime";
+
+//#region src/sdk/config.ts
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_MS = 250;
+const offlineStorageSchema = z.object({
+	enabled: z.boolean().default(false),
+	maxQueueSize: z.number().default(100)
+}).default({
+	enabled: false,
+	maxQueueSize: 100
+});
+const apiBaseUrlSchema = z.union([z.string(), z.enum([API_URL, "http://localhost:3001"])]);
+const featuresSchema = z.object(Object.fromEntries(PLUGIN_MANIFEST.map((plugin) => [plugin.name, z.boolean().default(plugin.defaultEnabled)]))).partial().default(Object.fromEntries(PLUGIN_MANIFEST.map((plugin) => [plugin.name, plugin.defaultEnabled])));
+const baseSdkConfigSchema = z.object({
+	features: featuresSchema,
+	metadata: z.object({
+		buildId: z.string().nullable(),
+		releaseId: z.string().nullable(),
+		environment: envSchema,
+		runtime: runtimeSchema
+	}),
+	batch: z.object({
+		size: z.number().default(DEFAULT_BATCH_SIZE),
+		ms: z.number().default(DEFAULT_BATCH_MS)
+	}).default(() => ({
+		size: DEFAULT_BATCH_SIZE,
+		ms: DEFAULT_BATCH_MS
+	})),
+	offline: offlineStorageSchema
+});
+const proxyConfigSchema = z.object({ proxyUrl: z.string() });
+const directConfigSchema = z.object({
+	ingestUrl: z.string(),
+	surfaceToken: z.string()
+});
+const configSchema = baseSdkConfigSchema.and(z.union([proxyConfigSchema, directConfigSchema])).transform((cfg) => {
+	const replayDefault = cfg.metadata.environment !== "development";
+	if (cfg.features.replay === void 0) cfg.features = {
+		...cfg.features,
+		replay: replayDefault
+	};
+	return cfg;
+});
+const configInputSchema = z.object({
+	features: featuresSchema.optional(),
+	metadata: z.object({
+		buildId: z.string().nullable(),
+		releaseId: z.string().nullable(),
+		environment: envSchema,
+		runtime: runtimeSchema
+	}).partial().optional(),
+	batch: z.object({
+		size: z.number(),
+		ms: z.number()
+	}).partial().optional(),
+	offline: offlineStorageSchema.optional()
+}).and(z.union([proxyConfigSchema, directConfigSchema]));
+const persistenceTypeSchema = z.enum([
+	"localStorage",
+	"sessionStorage",
+	"memory"
+]);
+
+//#endregion
+export { apiBaseUrlSchema, configInputSchema, configSchema, featuresSchema, offlineStorageSchema, persistenceTypeSchema };

package/dist/sdk/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../src/sdk/config.ts"],"sourcesContent":["import { API_URL } from \"@interfere/constants/api\";\n\nimport { z } from \"zod/v4\";\n\nimport { envSchema, runtimeSchema } from \"#sdk/runtime\";\n\nimport type { PluginKey } from \"./plugins/lib/types.js\";\nimport { PLUGIN_MANIFEST } from \"./plugins/manifest.js\";\n\nconst DEFAULT_BATCH_SIZE = 10;\nconst DEFAULT_BATCH_MS = 250;\n\nexport const offlineStorageSchema = z\n  .object({\n    /**\n     * Whether to enable offline storage (IndexedDB persistence).\n     * When enabled, envelopes that fail to send are stored and retried when connectivity returns.\n     * @default false\n     */\n    enabled: z.boolean().default(false),\n    /**\n     * Maximum number of envelopes to store offline.\n     * @default 100\n     */\n    maxQueueSize: z.number().default(100),\n  })\n  .default({ enabled: false, maxQueueSize: 100 });\n\nexport type OfflineStorage = z.infer<typeof offlineStorageSchema>;\n\nexport const apiBaseUrlSchema = z.union([\n  z.string(),\n  z.enum([API_URL, \"http://localhost:3001\"]),\n]);\n\nexport const featuresSchema = z\n  .object(\n    Object.fromEntries(\n      PLUGIN_MANIFEST.map((plugin) => [\n        plugin.name,\n        z.boolean().default(plugin.defaultEnabled),\n      ])\n    ) as Record<PluginKey, z.ZodDefault<z.ZodBoolean>>\n  )\n  .partial()\n  .default(\n    Object.fromEntries(\n      PLUGIN_MANIFEST.map((plugin) => [plugin.name, plugin.defaultEnabled])\n    )\n  );\n\nexport type Features = z.infer<typeof featuresSchema>;\n\nconst baseSdkConfigSchema = z.object({\n  features: featuresSchema,\n  metadata: z.object({\n    buildId: z.string().nullable(),\n    releaseId: z.string().nullable(),\n    environment: envSchema,\n    runtime: runtimeSchema,\n  }),\n  batch: z\n    .object({\n      size: z.number().default(DEFAULT_BATCH_SIZE),\n      ms: z.number().default(DEFAULT_BATCH_MS),\n    })\n    .default(() => ({ size: DEFAULT_BATCH_SIZE, ms: DEFAULT_BATCH_MS })),\n  /**\n   * Offline storage configuration.\n   * When enabled, envelopes that fail to send are persisted to IndexedDB and\n   * retried when connectivity returns.\n   * @default { enabled: false }\n   */\n  offline: offlineStorageSchema,\n});\n\nconst proxyConfigSchema = z.object({ proxyUrl: z.string() });\n\nconst directConfigSchema = z.object({\n  ingestUrl: z.string(),\n  surfaceToken: z.string(),\n});\n\nexport const configSchema = baseSdkConfigSchema\n  .and(z.union([proxyConfigSchema, directConfigSchema]))\n  .transform((cfg) => {\n    const env = cfg.metadata.environment;\n    const replayDefault = env !== \"development\";\n\n    if (cfg.features.replay === undefined) {\n      cfg.features = {\n        ...cfg.features,\n        replay: replayDefault,\n      };\n    }\n    return cfg;\n  });\n\nexport type Config = z.output<typeof configSchema>;\n\nexport const configInputSchema = z\n  .object({\n    features: featuresSchema.optional(),\n    metadata: z\n      .object({\n        buildId: z.string().nullable(),\n        releaseId: z.string().nullable(),\n        environment: envSchema,\n        runtime: runtimeSchema,\n      })\n      .partial()\n      .optional(),\n    batch: z\n      .object({\n        size: z.number(),\n        ms: z.number(),\n      })\n      .partial()\n      .optional(),\n    offline: offlineStorageSchema.optional(),\n  })\n  .and(z.union([proxyConfigSchema, directConfigSchema]));\n\nexport type ConfigInput = z.infer<typeof configInputSchema>;\n\nexport const persistenceTypeSchema = z.enum([\n  \"localStorage\",\n  \"sessionStorage\",\n  \"memory\",\n]);\n\nexport type PersistenceType = z.infer<typeof persistenceTypeSchema>;\n"],"mappings":";;;;;;AASA,MAAM,qBAAqB;AAC3B,MAAM,mBAAmB;AAEzB,MAAa,uBAAuB,EACjC,OAAO;CAMN,SAAS,EAAE,SAAS,CAAC,QAAQ,MAAM;CAKnC,cAAc,EAAE,QAAQ,CAAC,QAAQ,IAAI;CACtC,CAAC,CACD,QAAQ;CAAE,SAAS;CAAO,cAAc;CAAK,CAAC;AAIjD,MAAa,mBAAmB,EAAE,MAAM,CACtC,EAAE,QAAQ,EACV,EAAE,KAAK,CAAC,SAAS,wBAAwB,CAAC,CAC3C,CAAC;AAEF,MAAa,iBAAiB,EAC3B,OACC,OAAO,YACL,gBAAgB,KAAK,WAAW,CAC9B,OAAO,MACP,EAAE,SAAS,CAAC,QAAQ,OAAO,eAAe,CAC3C,CAAC,CACH,CACF,CACA,SAAS,CACT,QACC,OAAO,YACL,gBAAgB,KAAK,WAAW,CAAC,OAAO,MAAM,OAAO,eAAe,CAAC,CACtE,CACF;AAIH,MAAM,sBAAsB,EAAE,OAAO;CACnC,UAAU;CACV,UAAU,EAAE,OAAO;EACjB,SAAS,EAAE,QAAQ,CAAC,UAAU;EAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU;EAChC,aAAa;EACb,SAAS;EACV,CAAC;CACF,OAAO,EACJ,OAAO;EACN,MAAM,EAAE,QAAQ,CAAC,QAAQ,mBAAmB;EAC5C,IAAI,EAAE,QAAQ,CAAC,QAAQ,iBAAiB;EACzC,CAAC,CACD,eAAe;EAAE,MAAM;EAAoB,IAAI;EAAkB,EAAE;CAOtE,SAAS;CACV,CAAC;AAEF,MAAM,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;AAE5D,MAAM,qBAAqB,EAAE,OAAO;CAClC,WAAW,EAAE,QAAQ;CACrB,cAAc,EAAE,QAAQ;CACzB,CAAC;AAEF,MAAa,eAAe,oBACzB,IAAI,EAAE,MAAM,CAAC,mBAAmB,mBAAmB,CAAC,CAAC,CACrD,WAAW,QAAQ;CAElB,MAAM,gBADM,IAAI,SAAS,gBACK;AAE9B,KAAI,IAAI,SAAS,WAAW,OAC1B,KAAI,WAAW;EACb,GAAG,IAAI;EACP,QAAQ;EACT;AAEH,QAAO;EACP;AAIJ,MAAa,oBAAoB,EAC9B,OAAO;CACN,UAAU,eAAe,UAAU;CACnC,UAAU,EACP,OAAO;EACN,SAAS,EAAE,QAAQ,CAAC,UAAU;EAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU;EAChC,aAAa;EACb,SAAS;EACV,CAAC,CACD,SAAS,CACT,UAAU;CACb,OAAO,EACJ,OAAO;EACN,MAAM,EAAE,QAAQ;EAChB,IAAI,EAAE,QAAQ;EACf,CAAC,CACD,SAAS,CACT,UAAU;CACb,SAAS,qBAAqB,UAAU;CACzC,CAAC,CACD,IAAI,EAAE,MAAM,CAAC,mBAAmB,mBAAmB,CAAC,CAAC;AAIxD,MAAa,wBAAwB,EAAE,KAAK;CAC1C;CACA;CACA;CACD,CAAC"}

package/dist/sdk/envelope.d.mts

@@ -0,0 +1,190 @@
+import { EventType } from "./plugins/lib/types.mjs";
+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>;
+declare const envelopeSchema: z.ZodIntersection<z.ZodObject<{
+  uuid: z.ZodUUID;
+  v: z.ZodUnion<readonly [z.ZodLiteral<0>]>;
+  runtime: z.ZodNullable<z.ZodEnum<{
+    edge: "edge";
+    browser: "browser";
+    node: "node";
+  }>>;
+  environment: z.ZodNullable<z.ZodEnum<{
+    development: "development";
+    preview: "preview";
+    production: "production";
+  }>>;
+  buildId: z.ZodNullable<z.ZodString>;
+  releaseId: z.ZodNullable<z.ZodString>;
+  clientTs: z.ZodInt;
+  sessionId: z.ZodNullable<z.ZodUUID>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"error">;
+  payload: z.ZodObject<{
+    frames: z.ZodArray<z.ZodObject<{
+      file: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+      line: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>;
+      column: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>;
+      fn: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    message: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    stack: z.ZodNullable<z.ZodString>;
+    errorSource: z.ZodEnum<{
+      client: "client";
+      server: "server";
+      edge: "edge";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"session_summary">;
+  payload: z.ZodObject<{
+    summary: z.ZodString;
+    pageTitle: z.ZodString;
+    pageUrl: z.ZodURL;
+    contentLength: z.ZodNumber;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pageview">;
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pageleave">;
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"ui_event">;
+  payload: z.ZodObject<{
+    event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"replay_chunk">;
+  payload: z.ZodObject<{
+    ts: z.ZodNumber;
+    count: z.ZodNumber;
+    events: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rage_click">;
+  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>;
+}, z.core.$strip>], "type">>;
+type Envelope<Type extends EventType | undefined = undefined> = Type extends EventType ? Extract<z.infer<typeof envelopeSchema>, {
+  type: Type;
+}> : z.infer<typeof envelopeSchema>;
+declare const stampedEnvelopeSchema: z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+  uuid: z.ZodUUID;
+  v: z.ZodUnion<readonly [z.ZodLiteral<0>]>;
+  runtime: z.ZodNullable<z.ZodEnum<{
+    edge: "edge";
+    browser: "browser";
+    node: "node";
+  }>>;
+  environment: z.ZodNullable<z.ZodEnum<{
+    development: "development";
+    preview: "preview";
+    production: "production";
+  }>>;
+  buildId: z.ZodNullable<z.ZodString>;
+  releaseId: z.ZodNullable<z.ZodString>;
+  clientTs: z.ZodInt;
+  sessionId: z.ZodNullable<z.ZodUUID>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"error">;
+  payload: z.ZodObject<{
+    frames: z.ZodArray<z.ZodObject<{
+      file: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+      line: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>;
+      column: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>;
+      fn: z.ZodObject<{
+        reported: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    message: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    stack: z.ZodNullable<z.ZodString>;
+    errorSource: z.ZodEnum<{
+      client: "client";
+      server: "server";
+      edge: "edge";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"session_summary">;
+  payload: z.ZodObject<{
+    summary: z.ZodString;
+    pageTitle: z.ZodString;
+    pageUrl: z.ZodURL;
+    contentLength: z.ZodNumber;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pageview">;
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"pageleave">;
+  payload: z.ZodObject<{
+    url: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"ui_event">;
+  payload: z.ZodObject<{
+    event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"replay_chunk">;
+  payload: z.ZodObject<{
+    ts: z.ZodNumber;
+    count: z.ZodNumber;
+    events: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rage_click">;
+  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>;
+}, z.core.$strip>], "type">>, z.ZodObject<{
+  surfaceSlug: z.ZodString;
+}, z.core.$strip>>;
+type StampedEnvelope = z.infer<typeof stampedEnvelopeSchema>;
+//#endregion
+export { Envelope, EnvelopeVersion, StampedEnvelope, envelopeSchema, stampedEnvelopeSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.mts","names":[],"sources":["../../src/sdk/envelope.ts"],"sourcesContent":[],"mappings":";;;;cAiBM,iBAAe,CAAA,CAAA,mBAAA,CAAA,CAAA;KAET,eAAA,GAAkB,CAAA,CAAE,aAAa;AAFvC,cAiBO,cAjBQ,EAiBM,CAAA,CAAA,eAjBN,CAiBM,CAAA,CAAA,SAjBN,CAAA;EAET,IAAA,WAAA;EAeC,CAAA,YAAA,CAAA,SAqCZ,aAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;EArC0B,IAAA,cAAA,CAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCf,sBAAsB,qCAChC,aAAa,YACT,QAAQ,CAAA,CAAE,aAAa;QAAyB;KAChD,CAAA,CAAE,aAAa;cAER,uBAAqB,CAAA,CAAA,gBAAA,CAAA,CAAA,gBAAA,CAAA,CAAA;;;;;;;;;;;;;;;EA5CP,QAAA,UAAA;EAAA,SAAA,eAAA,UAAA,CAAA;AAuC3B,CAAA,eAAoB,CAAA,yBAAA,CAAA,YAAA,CAAA;EAAc,IAAA,cAAA,CAAA,OAAA,CAAA;EAChC,OAAA,aAAA,CAAA;IAAa,MAAA,YAAA,YAAA,CAAA;MACc,IAAA,aAAA,CAAA;QAAb,QAAA,eAAA,YAAA,CAAA;MAAsC,CAAA,eAAA,CAAA;MAAhD,IAAA,aAAA,CAAA;QACe,QAAA,eAAA,YAAA,CAAA;MAAb,CAAA,eAAA,CAAA;MAAK,MAAA,aAAA,CAAA;QAEA,QAAA,eAKZ,YAAA,CAAA;;;;;;;;;;;;;;;;EALiC,IAAA,cAAA,CAAA,iBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOtB,eAAA,GAAkB,CAAA,CAAE,aAAa"}

package/dist/sdk/envelope.mjs

@@ -0,0 +1,57 @@
+import { eventTypeSchema } from "./plugins/lib/types.mjs";
+import { sessionSummaryPayloadSchema } from "#sdk/plugins/payload/ai-summary";
+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 { z } from "zod/v4";
+import { envSchema, runtimeSchema } from "#sdk/runtime";
+import { sessionIdSchema } from "#data/session";
+import { surfaceSlugSchema } from "#data/surface";
+import { replayChunkPayloadSchema } from "#sdk/plugins/payload/replay";
+
+//#region src/sdk/envelope.ts
+const envelopeVersion = z.union([z.literal(0)]);
+const envelopeHeadersSchema = z.object({
+	uuid: z.uuidv7(),
+	v: envelopeVersion,
+	runtime: runtimeSchema,
+	environment: envSchema,
+	buildId: z.string().nullable(),
+	releaseId: z.string().nullable(),
+	clientTs: z.int(),
+	sessionId: sessionIdSchema.nullable()
+});
+const envelopeSchema = envelopeHeadersSchema.and(z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal(eventTypeSchema.enum.error),
+		payload: errorEnvelopePayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.session_summary),
+		payload: sessionSummaryPayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.pageview),
+		payload: pageviewPayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.pageleave),
+		payload: pageleavePayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.ui_event),
+		payload: uiEventPayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.replay_chunk),
+		payload: replayChunkPayloadSchema
+	}),
+	z.object({
+		type: z.literal(eventTypeSchema.enum.rage_click),
+		payload: rageClickPayloadSchema
+	})
+]));
+const stampedEnvelopeSchema = z.intersection(envelopeSchema, z.object({ surfaceSlug: surfaceSlugSchema }));
+
+//#endregion
+export { envelopeSchema, 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 { sessionSummaryPayloadSchema } from \"#sdk/plugins/payload/ai-summary\";\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\nimport { type EventType, eventTypeSchema } from \"./plugins/lib/types.js\";\n\nconst envelopeVersion = z.union([z.literal(0)]);\n\nexport type EnvelopeVersion = z.infer<typeof envelopeVersion>;\n\nconst envelopeHeadersSchema = z.object({\n  uuid: z.uuidv7(),\n  v: envelopeVersion,\n\n  runtime: runtimeSchema,\n  environment: envSchema,\n  buildId: z.string().nullable(),\n  releaseId: z.string().nullable(),\n\n  clientTs: z.int(),\n  sessionId: sessionIdSchema.nullable(),\n});\n\nexport const envelopeSchema = envelopeHeadersSchema.and(\n  z.discriminatedUnion(\"type\", [\n    z.object({\n      type: z.literal(eventTypeSchema.enum.error),\n      payload: errorEnvelopePayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.session_summary),\n      payload: sessionSummaryPayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.pageview),\n      payload: pageviewPayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.pageleave),\n      payload: pageleavePayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.ui_event),\n      payload: uiEventPayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.replay_chunk),\n      payload: replayChunkPayloadSchema,\n    }),\n\n    z.object({\n      type: z.literal(eventTypeSchema.enum.rage_click),\n      payload: rageClickPayloadSchema,\n    }),\n  ])\n);\n\nexport type Envelope<Type extends EventType | undefined = undefined> =\n  Type extends EventType\n    ? Extract<z.infer<typeof envelopeSchema>, { type: Type }>\n    : z.infer<typeof envelopeSchema>;\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;AAI/C,MAAM,wBAAwB,EAAE,OAAO;CACrC,MAAM,EAAE,QAAQ;CAChB,GAAG;CAEH,SAAS;CACT,aAAa;CACb,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU;CAEhC,UAAU,EAAE,KAAK;CACjB,WAAW,gBAAgB,UAAU;CACtC,CAAC;AAEF,MAAa,iBAAiB,sBAAsB,IAClD,EAAE,mBAAmB,QAAQ;CAC3B,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,MAAM;EAC3C,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,gBAAgB;EACrD,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,SAAS;EAC9C,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,UAAU;EAC/C,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,SAAS;EAC9C,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,aAAa;EAClD,SAAS;EACV,CAAC;CAEF,EAAE,OAAO;EACP,MAAM,EAAE,QAAQ,gBAAgB,KAAK,WAAW;EAChD,SAAS;EACV,CAAC;CACH,CAAC,CACH;AAOD,MAAa,wBAAwB,EAAE,aACrC,gBACA,EAAE,OAAO,EACP,aAAa,mBACd,CAAC,CACH"}

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"],"sourcesContent":[],"mappings":";;;cAEa,wBAAsB,CAAA,CAAA,mBAAA,CAAA,CAAA,qBAAA,CAAA,CAAA,oBAAA,CAAA,CAAA;KAMvB,gBAAA,GAAmB,CAAA,CAAE,aAAa"}

package/dist/sdk/packages.mjs

@@ -0,0 +1,11 @@
+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"}

package/dist/sdk/plugins/lib/schemas.d.mts

@@ -0,0 +1,23 @@
+import z$1 from "zod";
+
+//#region src/sdk/plugins/lib/schemas.d.ts
+
+/**
+ * Shape of a single event registration within a plugin.
+ * The `payloadSchema` is optional and can be any Zod schema.
+ */
+interface PluginEventRegistration {
+  readonly name: string;
+  readonly enrich: boolean;
+  readonly payloadSchema?: z$1.ZodTypeAny;
+}
+/**
+ * Shape of a single plugin registration.
+ */
+interface PluginRegistration {
+  readonly name: string;
+  readonly defaultEnabled: boolean;
+  readonly events: readonly PluginEventRegistration[];
+}
+//#endregion
+export { PluginEventRegistration, PluginRegistration };

package/dist/sdk/plugins/lib/schemas.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.mts","names":[],"sources":["../../../../src/sdk/plugins/lib/schemas.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;AASA;UATiB,uBAAA;;;2BAGU,GAAA,CAAE;;;;;UAMZ,kBAAA;;;4BAGW"}

package/dist/sdk/plugins/lib/schemas.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/sdk/plugins/lib/types.d.mts

@@ -0,0 +1,19 @@
+import { PLUGIN_MANIFEST } from "../manifest.mjs";
+import z$1 from "zod";
+
+//#region src/sdk/plugins/lib/types.d.ts
+type PluginManifestType = typeof PLUGIN_MANIFEST;
+type PluginRegistrationInManifest = PluginManifestType[number];
+type PluginKey = PluginRegistrationInManifest["name"];
+declare const eventTypeSchema: z$1.ZodEnum<{
+  error: "error";
+  replay_chunk: "replay_chunk";
+  rage_click: "rage_click";
+  session_summary: "session_summary";
+  pageview: "pageview";
+  pageleave: "pageleave";
+  ui_event: "ui_event";
+}>;
+type EventType = z$1.infer<typeof eventTypeSchema>;
+//#endregion
+export { EventType, PluginKey, eventTypeSchema };

package/dist/sdk/plugins/lib/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../src/sdk/plugins/lib/types.ts"],"sourcesContent":[],"mappings":";;;;KAIK,kBAAA,UAA4B;KAE5B,4BAAA,GAA+B;AAF/B,KAIO,SAAA,GAAY,4BAJwB,CAAA,MAAA,CAAA;AAE3C,cAIQ,eAJoB,EAIL,GAAA,CAAA,OAJQ,CAAA;EAExB,KAAA,EAAA,OAAS;EAER,YAAA,EAAA,cAEZ;EAEW,UAAA,EAAS,YAAkB;;;;;;KAA3B,SAAA,GAAY,GAAA,CAAE,aAAa"}

package/dist/sdk/plugins/lib/types.mjs

@@ -0,0 +1,8 @@
+import { PLUGIN_MANIFEST } from "../manifest.mjs";
+import z$1 from "zod";
+
+//#region src/sdk/plugins/lib/types.ts
+const eventTypeSchema = z$1.enum(PLUGIN_MANIFEST.flatMap(({ events }) => events.map(({ name }) => name)));
+
+//#endregion
+export { eventTypeSchema };

package/dist/sdk/plugins/lib/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":["z"],"sources":["../../../../src/sdk/plugins/lib/types.ts"],"sourcesContent":["import z from \"zod\";\n\nimport { PLUGIN_MANIFEST } from \"../manifest.js\";\n\ntype PluginManifestType = typeof PLUGIN_MANIFEST;\n\ntype PluginRegistrationInManifest = PluginManifestType[number];\n\nexport type PluginKey = PluginRegistrationInManifest[\"name\"];\n\nexport const eventTypeSchema = z.enum(\n  PLUGIN_MANIFEST.flatMap(({ events }) => events.map(({ name }) => name))\n);\n\nexport type EventType = z.infer<typeof eventTypeSchema>;\n"],"mappings":";;;;AAUA,MAAa,kBAAkBA,IAAE,KAC/B,gBAAgB,SAAS,EAAE,aAAa,OAAO,KAAK,EAAE,WAAW,KAAK,CAAC,CACxE"}