@interfere/types 0.0.3 → 0.1.0-alpha.2

package/dist/events/session-summary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-summary.mjs","names":[],"sources":["../../src/events/session-summary.ts"],"sourcesContent":["import { z } from \"zod/v4\";\n\nexport const sessionSummaryFactsPayloadSchema = z.object({\n  summary: z.string(),\n  pageTitle: z.string(),\n  pageUrl: z.string(),\n  contentLength: z.number(),\n  timestamp: z.number(),\n  runtime: z.string().optional(),\n  releaseId: z.string().nullable().optional(),\n});\n\nexport type SessionSummaryFactsPayload = z.infer<\n  typeof sessionSummaryFactsPayloadSchema\n>;\n"],"mappings":";;AAEA,MAAa,mCAAmC,EAAE,OAAO;CACvD,SAAS,EAAE,QAAQ;CACnB,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,QAAQ;CACnB,eAAe,EAAE,QAAQ;CACzB,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC5C,CAAC"}

package/dist/events/ui-event.d.mts

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+
+//#region src/events/ui-event.d.ts
+declare const uiEventFactsPayloadSchema: z.ZodObject<{
+  event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  runtime: z.ZodOptional<z.ZodString>;
+  releaseId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type UiEventFactsPayload = z.infer<typeof uiEventFactsPayloadSchema>;
+//#endregion
+export { UiEventFactsPayload, uiEventFactsPayloadSchema };

package/dist/events/ui-event.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-event.d.mts","names":[],"sources":["../../src/events/ui-event.ts"],"mappings":";;;cAEa,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;KAM1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA"}

package/dist/events/ui-event.mjs

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+//#region src/events/ui-event.ts
+const uiEventFactsPayloadSchema = z.object({
+	event: z.record(z.string(), z.unknown()),
+	runtime: z.string().optional(),
+	releaseId: z.string().nullable().optional()
+});
+//#endregion
+export { uiEventFactsPayloadSchema };

package/dist/events/ui-event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-event.mjs","names":[],"sources":["../../src/events/ui-event.ts"],"sourcesContent":["import { z } from \"zod/v4\";\n\nexport const uiEventFactsPayloadSchema = z.object({\n  event: z.record(z.string(), z.unknown()),\n  runtime: z.string().optional(),\n  releaseId: z.string().nullable().optional(),\n});\n\nexport type UiEventFactsPayload = z.infer<typeof uiEventFactsPayloadSchema>;\n"],"mappings":";;AAEA,MAAa,4BAA4B,EAAE,OAAO;CAChD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC;CACxC,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC9B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC5C,CAAC"}

package/dist/integrations/index.d.mts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+//#region src/integrations/index.d.ts
+declare const releaseSourceMetadataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  commitMessage: z.ZodString;
+  branch: z.ZodString;
+  commitSha: z.ZodNullable<z.ZodString>;
+  provider: z.ZodLiteral<"github">;
+}, z.core.$strip>], "provider">;
+type ReleaseSourceMetadata = z.infer<typeof releaseSourceMetadataSchema>;
+declare const releaseDestinationMetadataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  environment: z.ZodNullable<z.ZodString>;
+  deploymentId: z.ZodNullable<z.ZodString>;
+  deploymentUrl: z.ZodNullable<z.ZodString>;
+  environmentName: z.ZodNullable<z.ZodString>;
+  environmentTarget: z.ZodNullable<z.ZodString>;
+  provider: z.ZodLiteral<"vercel">;
+}, z.core.$strip>], "provider">;
+type ReleaseDestinationMetadata = z.infer<typeof releaseDestinationMetadataSchema>;
+declare const sourceProviderSchema: z.ZodEnum<{
+  github: "github";
+}>;
+type SourceProvider = z.infer<typeof sourceProviderSchema>;
+declare const destinationProviderSchema: z.ZodEnum<{
+  vercel: "vercel";
+}>;
+type DestinationProvider = z.infer<typeof destinationProviderSchema>;
+declare const releaseSourceIdEnvKeySchema: z.ZodEnum<{
+  NEXT_PUBLIC_INTERFERE_BUILD_ID: "NEXT_PUBLIC_INTERFERE_BUILD_ID";
+  INTERFERE_SOURCE_ID: "INTERFERE_SOURCE_ID";
+  NEXT_BUILD_ID: "NEXT_BUILD_ID";
+  VERCEL_GIT_COMMIT_SHA: "VERCEL_GIT_COMMIT_SHA";
+  GITHUB_SHA: "GITHUB_SHA";
+}>;
+type ReleaseSourceIdEnvKey = z.infer<typeof releaseSourceIdEnvKeySchema>;
+declare const releaseSourceIdEnvKeys: ("NEXT_PUBLIC_INTERFERE_BUILD_ID" | "INTERFERE_SOURCE_ID" | "NEXT_BUILD_ID" | "VERCEL_GIT_COMMIT_SHA" | "GITHUB_SHA")[];
+declare const releaseDestinationIdEnvKeySchema: z.ZodEnum<{
+  VERCEL_GIT_COMMIT_SHA: "VERCEL_GIT_COMMIT_SHA";
+  GITHUB_SHA: "GITHUB_SHA";
+  NEXT_PUBLIC_INTERFERE_RELEASE_ID: "NEXT_PUBLIC_INTERFERE_RELEASE_ID";
+  INTERFERE_DESTINATION_ID: "INTERFERE_DESTINATION_ID";
+  VERCEL_DEPLOYMENT_ID: "VERCEL_DEPLOYMENT_ID";
+}>;
+type ReleaseDestinationIdEnvKey = z.infer<typeof releaseDestinationIdEnvKeySchema>;
+declare const releaseDestinationIdEnvKeys: ("VERCEL_GIT_COMMIT_SHA" | "GITHUB_SHA" | "NEXT_PUBLIC_INTERFERE_RELEASE_ID" | "INTERFERE_DESTINATION_ID" | "VERCEL_DEPLOYMENT_ID")[];
+//#endregion
+export { DestinationProvider, ReleaseDestinationIdEnvKey, ReleaseDestinationMetadata, ReleaseSourceIdEnvKey, ReleaseSourceMetadata, SourceProvider, destinationProviderSchema, releaseDestinationIdEnvKeySchema, releaseDestinationIdEnvKeys, releaseDestinationMetadataSchema, releaseSourceIdEnvKeySchema, releaseSourceIdEnvKeys, releaseSourceMetadataSchema, sourceProviderSchema };

package/dist/integrations/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/integrations/index.ts"],"mappings":";;;cAWa,2BAAA,EAA2B,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;KAM5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,cAMtC,gCAAA,EAAgC,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;KAWjC,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAClC,gCAAA;AAAA,cAGI,oBAAA,EAAoB,CAAA,CAAA,OAAA;;;KAGrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,yBAAA,EAAyB,CAAA,CAAA,OAAA;;;KAG1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;AAAA,cAEpC,2BAAA,EAA2B,CAAA,CAAA,OAAA;;;;;;;KAM5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,cACtC,sBAAA;AAAA,cAEA,gCAAA,EAAgC,CAAA,CAAA,OAAA;;;;;;;KAMjC,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAClC,gCAAA;AAAA,cAEI,2BAAA"}

package/dist/integrations/index.mjs

@@ -0,0 +1,25 @@
+import { githubIntegration, githubSourceIdEnvKeys } from "./platforms/github.mjs";
+import { vercelDestinationIdEnvKeys, vercelIntegration } from "./platforms/vercel.mjs";
+import { z } from "zod";
+//#region src/integrations/index.ts
+const releaseSourceMetadataSchema = z.discriminatedUnion("provider", [githubIntegration.shape.source.extend({ provider: githubIntegration.shape.name })]);
+const baseDestinationMetadataSchema = z.object({ environment: z.string().nullable() });
+const releaseDestinationMetadataSchema = z.discriminatedUnion("provider", [baseDestinationMetadataSchema.extend(vercelIntegration.shape.destination.shape).extend({ provider: vercelIntegration.shape.name })]);
+const sourceProviderSchema = z.enum([githubIntegration.shape.name.value]);
+const destinationProviderSchema = z.enum([vercelIntegration.shape.name.value]);
+const releaseSourceIdEnvKeySchema = z.enum([
+	"NEXT_PUBLIC_INTERFERE_BUILD_ID",
+	"INTERFERE_SOURCE_ID",
+	"NEXT_BUILD_ID",
+	...githubSourceIdEnvKeys
+]);
+const releaseSourceIdEnvKeys = releaseSourceIdEnvKeySchema.options;
+const releaseDestinationIdEnvKeySchema = z.enum([
+	"NEXT_PUBLIC_INTERFERE_RELEASE_ID",
+	"INTERFERE_DESTINATION_ID",
+	...vercelDestinationIdEnvKeys,
+	...githubSourceIdEnvKeys
+]);
+const releaseDestinationIdEnvKeys = releaseDestinationIdEnvKeySchema.options;
+//#endregion
+export { destinationProviderSchema, releaseDestinationIdEnvKeySchema, releaseDestinationIdEnvKeys, releaseDestinationMetadataSchema, releaseSourceIdEnvKeySchema, releaseSourceIdEnvKeys, releaseSourceMetadataSchema, sourceProviderSchema };

package/dist/integrations/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/integrations/index.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport {\n  githubIntegration,\n  githubSourceIdEnvKeys,\n} from \"./platforms/github.js\";\nimport {\n  vercelDestinationIdEnvKeys,\n  vercelIntegration,\n} from \"./platforms/vercel.js\";\n\nexport const releaseSourceMetadataSchema = z.discriminatedUnion(\"provider\", [\n  githubIntegration.shape.source.extend({\n    provider: githubIntegration.shape.name,\n  }),\n]);\n\nexport type ReleaseSourceMetadata = z.infer<typeof releaseSourceMetadataSchema>;\n\nconst baseDestinationMetadataSchema = z.object({\n  environment: z.string().nullable(),\n});\n\nexport const releaseDestinationMetadataSchema = z.discriminatedUnion(\n  \"provider\",\n  [\n    baseDestinationMetadataSchema\n      .extend(vercelIntegration.shape.destination.shape)\n      .extend({\n        provider: vercelIntegration.shape.name,\n      }),\n  ]\n);\n\nexport type ReleaseDestinationMetadata = z.infer<\n  typeof releaseDestinationMetadataSchema\n>;\n\nexport const sourceProviderSchema = z.enum([\n  githubIntegration.shape.name.value,\n]);\nexport type SourceProvider = z.infer<typeof sourceProviderSchema>;\n\nexport const destinationProviderSchema = z.enum([\n  vercelIntegration.shape.name.value,\n]);\nexport type DestinationProvider = z.infer<typeof destinationProviderSchema>;\n\nexport const releaseSourceIdEnvKeySchema = z.enum([\n  \"NEXT_PUBLIC_INTERFERE_BUILD_ID\",\n  \"INTERFERE_SOURCE_ID\",\n  \"NEXT_BUILD_ID\",\n  ...githubSourceIdEnvKeys,\n]);\nexport type ReleaseSourceIdEnvKey = z.infer<typeof releaseSourceIdEnvKeySchema>;\nexport const releaseSourceIdEnvKeys = releaseSourceIdEnvKeySchema.options;\n\nexport const releaseDestinationIdEnvKeySchema = z.enum([\n  \"NEXT_PUBLIC_INTERFERE_RELEASE_ID\",\n  \"INTERFERE_DESTINATION_ID\",\n  ...vercelDestinationIdEnvKeys,\n  ...githubSourceIdEnvKeys,\n]);\nexport type ReleaseDestinationIdEnvKey = z.infer<\n  typeof releaseDestinationIdEnvKeySchema\n>;\nexport const releaseDestinationIdEnvKeys =\n  releaseDestinationIdEnvKeySchema.options;\n"],"mappings":";;;;AAWA,MAAa,8BAA8B,EAAE,mBAAmB,YAAY,CAC1E,kBAAkB,MAAM,OAAO,OAAO,EACpC,UAAU,kBAAkB,MAAM,MACnC,CAAC,CACH,CAAC;AAIF,MAAM,gCAAgC,EAAE,OAAO,EAC7C,aAAa,EAAE,QAAQ,CAAC,UAAU,EACnC,CAAC;AAEF,MAAa,mCAAmC,EAAE,mBAChD,YACA,CACE,8BACG,OAAO,kBAAkB,MAAM,YAAY,MAAM,CACjD,OAAO,EACN,UAAU,kBAAkB,MAAM,MACnC,CAAC,CACL,CACF;AAMD,MAAa,uBAAuB,EAAE,KAAK,CACzC,kBAAkB,MAAM,KAAK,MAC9B,CAAC;AAGF,MAAa,4BAA4B,EAAE,KAAK,CAC9C,kBAAkB,MAAM,KAAK,MAC9B,CAAC;AAGF,MAAa,8BAA8B,EAAE,KAAK;CAChD;CACA;CACA;CACA,GAAG;CACJ,CAAC;AAEF,MAAa,yBAAyB,4BAA4B;AAElE,MAAa,mCAAmC,EAAE,KAAK;CACrD;CACA;CACA,GAAG;CACH,GAAG;CACJ,CAAC;AAIF,MAAa,8BACX,iCAAiC"}

package/dist/integrations/platforms/github.d.mts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+//#region src/integrations/platforms/github.d.ts
+declare const githubSourceIdEnvKeySchema: z.ZodEnum<{
+  VERCEL_GIT_COMMIT_SHA: "VERCEL_GIT_COMMIT_SHA";
+  GITHUB_SHA: "GITHUB_SHA";
+}>;
+type GithubSourceIdEnvKey = z.infer<typeof githubSourceIdEnvKeySchema>;
+declare const githubSourceIdEnvKeys: ("VERCEL_GIT_COMMIT_SHA" | "GITHUB_SHA")[];
+declare const githubIntegration: z.ZodObject<{
+  name: z.ZodLiteral<"github">;
+  metadata: z.ZodObject<{
+    accountType: z.ZodString;
+    repositories: z.ZodRecord<z.ZodString, z.ZodString>;
+    installationUrl: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  source: z.ZodObject<{
+    commitMessage: z.ZodString;
+    branch: z.ZodString;
+    commitSha: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+//#endregion
+export { GithubSourceIdEnvKey, githubIntegration, githubSourceIdEnvKeySchema, githubSourceIdEnvKeys };

package/dist/integrations/platforms/github.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.mts","names":[],"sources":["../../../src/integrations/platforms/github.ts"],"mappings":";;;cAEa,0BAAA,EAA0B,CAAA,CAAA,OAAA;;;;KAI3B,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,0BAAA;AAAA,cACrC,qBAAA;AAAA,cAEA,iBAAA,EAAiB,CAAA,CAAA,SAAA"}

package/dist/integrations/platforms/github.mjs

@@ -0,0 +1,19 @@
+import { z } from "zod";
+//#region src/integrations/platforms/github.ts
+const githubSourceIdEnvKeySchema = z.enum(["VERCEL_GIT_COMMIT_SHA", "GITHUB_SHA"]);
+const githubSourceIdEnvKeys = githubSourceIdEnvKeySchema.options;
+const githubIntegration = z.object({
+	name: z.literal("github"),
+	metadata: z.object({
+		accountType: z.string(),
+		repositories: z.record(z.string(), z.string()),
+		installationUrl: z.string().nullable()
+	}),
+	source: z.object({
+		commitMessage: z.string(),
+		branch: z.string(),
+		commitSha: z.string().nullable()
+	})
+});
+//#endregion
+export { githubIntegration, githubSourceIdEnvKeySchema, githubSourceIdEnvKeys };

package/dist/integrations/platforms/github.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.mjs","names":[],"sources":["../../../src/integrations/platforms/github.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const githubSourceIdEnvKeySchema = z.enum([\n  \"VERCEL_GIT_COMMIT_SHA\",\n  \"GITHUB_SHA\",\n]);\nexport type GithubSourceIdEnvKey = z.infer<typeof githubSourceIdEnvKeySchema>;\nexport const githubSourceIdEnvKeys = githubSourceIdEnvKeySchema.options;\n\nexport const githubIntegration = z.object({\n  name: z.literal(\"github\"),\n  metadata: z.object({\n    accountType: z.string(),\n    repositories: z.record(z.string(), z.string()),\n    installationUrl: z.string().nullable(),\n  }),\n  source: z.object({\n    commitMessage: z.string(),\n    branch: z.string(),\n    commitSha: z.string().nullable(),\n  }),\n});\n"],"mappings":";;AAEA,MAAa,6BAA6B,EAAE,KAAK,CAC/C,yBACA,aACD,CAAC;AAEF,MAAa,wBAAwB,2BAA2B;AAEhE,MAAa,oBAAoB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,SAAS;CACzB,UAAU,EAAE,OAAO;EACjB,aAAa,EAAE,QAAQ;EACvB,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC;EAC9C,iBAAiB,EAAE,QAAQ,CAAC,UAAU;EACvC,CAAC;CACF,QAAQ,EAAE,OAAO;EACf,eAAe,EAAE,QAAQ;EACzB,QAAQ,EAAE,QAAQ;EAClB,WAAW,EAAE,QAAQ,CAAC,UAAU;EACjC,CAAC;CACH,CAAC"}

package/dist/integrations/platforms/vercel.d.mts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+//#region src/integrations/platforms/vercel.d.ts
+declare const vercelDestinationIdEnvKeySchema: z.ZodEnum<{
+  VERCEL_DEPLOYMENT_ID: "VERCEL_DEPLOYMENT_ID";
+}>;
+type VercelDestinationIdEnvKey = z.infer<typeof vercelDestinationIdEnvKeySchema>;
+declare const vercelDestinationIdEnvKeys: "VERCEL_DEPLOYMENT_ID"[];
+declare const vercelIntegration: z.ZodObject<{
+  name: z.ZodLiteral<"vercel">;
+  metadata: z.ZodObject<{
+    teamId: z.ZodNullable<z.ZodString>;
+    teamSlug: z.ZodNullable<z.ZodString>;
+    installationUrl: z.ZodNullable<z.ZodString>;
+    projectId: z.ZodNullable<z.ZodString>;
+    productionUrl: z.ZodNullable<z.ZodString>;
+    region: z.ZodNullable<z.ZodString>;
+    skewProtectionEnabled: z.ZodNullable<z.ZodBoolean>;
+  }, z.core.$strip>;
+  destination: z.ZodObject<{
+    deploymentId: z.ZodNullable<z.ZodString>;
+    deploymentUrl: z.ZodNullable<z.ZodString>;
+    environmentName: z.ZodNullable<z.ZodString>;
+    environmentTarget: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+//#endregion
+export { VercelDestinationIdEnvKey, vercelDestinationIdEnvKeySchema, vercelDestinationIdEnvKeys, vercelIntegration };

package/dist/integrations/platforms/vercel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.mts","names":[],"sources":["../../../src/integrations/platforms/vercel.ts"],"mappings":";;;cAEa,+BAAA,EAA+B,CAAA,CAAA,OAAA;;;KAChC,yBAAA,GAA4B,CAAA,CAAE,KAAA,QACjC,+BAAA;AAAA,cAEI,0BAAA;AAAA,cAGA,iBAAA,EAAiB,CAAA,CAAA,SAAA"}

package/dist/integrations/platforms/vercel.mjs

@@ -0,0 +1,24 @@
+import { z } from "zod";
+//#region src/integrations/platforms/vercel.ts
+const vercelDestinationIdEnvKeySchema = z.enum(["VERCEL_DEPLOYMENT_ID"]);
+const vercelDestinationIdEnvKeys = vercelDestinationIdEnvKeySchema.options;
+const vercelIntegration = z.object({
+	name: z.literal("vercel"),
+	metadata: z.object({
+		teamId: z.string().nullable(),
+		teamSlug: z.string().nullable(),
+		installationUrl: z.string().nullable(),
+		projectId: z.string().nullable(),
+		productionUrl: z.string().nullable(),
+		region: z.string().nullable(),
+		skewProtectionEnabled: z.boolean().nullable()
+	}),
+	destination: z.object({
+		deploymentId: z.string().nullable(),
+		deploymentUrl: z.string().nullable(),
+		environmentName: z.string().nullable(),
+		environmentTarget: z.string().nullable()
+	})
+});
+//#endregion
+export { vercelDestinationIdEnvKeySchema, vercelDestinationIdEnvKeys, vercelIntegration };

package/dist/integrations/platforms/vercel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.mjs","names":[],"sources":["../../../src/integrations/platforms/vercel.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const vercelDestinationIdEnvKeySchema = z.enum([\"VERCEL_DEPLOYMENT_ID\"]);\nexport type VercelDestinationIdEnvKey = z.infer<\n  typeof vercelDestinationIdEnvKeySchema\n>;\nexport const vercelDestinationIdEnvKeys =\n  vercelDestinationIdEnvKeySchema.options;\n\nexport const vercelIntegration = z.object({\n  name: z.literal(\"vercel\"),\n  metadata: z.object({\n    teamId: z.string().nullable(),\n    teamSlug: z.string().nullable(),\n    installationUrl: z.string().nullable(),\n    projectId: z.string().nullable(),\n    productionUrl: z.string().nullable(),\n    region: z.string().nullable(),\n    skewProtectionEnabled: z.boolean().nullable(),\n  }),\n  destination: z.object({\n    deploymentId: z.string().nullable(),\n    deploymentUrl: z.string().nullable(),\n    environmentName: z.string().nullable(),\n    environmentTarget: z.string().nullable(),\n  }),\n});\n"],"mappings":";;AAEA,MAAa,kCAAkC,EAAE,KAAK,CAAC,uBAAuB,CAAC;AAI/E,MAAa,6BACX,gCAAgC;AAElC,MAAa,oBAAoB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,SAAS;CACzB,UAAU,EAAE,OAAO;EACjB,QAAQ,EAAE,QAAQ,CAAC,UAAU;EAC7B,UAAU,EAAE,QAAQ,CAAC,UAAU;EAC/B,iBAAiB,EAAE,QAAQ,CAAC,UAAU;EACtC,WAAW,EAAE,QAAQ,CAAC,UAAU;EAChC,eAAe,EAAE,QAAQ,CAAC,UAAU;EACpC,QAAQ,EAAE,QAAQ,CAAC,UAAU;EAC7B,uBAAuB,EAAE,SAAS,CAAC,UAAU;EAC9C,CAAC;CACF,aAAa,EAAE,OAAO;EACpB,cAAc,EAAE,QAAQ,CAAC,UAAU;EACnC,eAAe,EAAE,QAAQ,CAAC,UAAU;EACpC,iBAAiB,EAAE,QAAQ,CAAC,UAAU;EACtC,mBAAmB,EAAE,QAAQ,CAAC,UAAU;EACzC,CAAC;CACH,CAAC"}

package/dist/releases/definition.d.mts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+
+//#region src/releases/definition.d.ts
+declare const releaseStatusSchema: z.ZodEnum<{
+  pending: "pending";
+  uploading: "uploading";
+  processing: "processing";
+  ready: "ready";
+  failed: "failed";
+}>;
+declare const createReleaseRequest: z.ZodObject<{
+  source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    commitMessage: z.ZodString;
+    branch: z.ZodString;
+    commitSha: z.ZodNullable<z.ZodString>;
+    provider: z.ZodLiteral<"github">;
+  }, z.core.$strip>], "provider">;
+  destination: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    environment: z.ZodNullable<z.ZodString>;
+    deploymentId: z.ZodNullable<z.ZodString>;
+    deploymentUrl: z.ZodNullable<z.ZodString>;
+    environmentName: z.ZodNullable<z.ZodString>;
+    environmentTarget: z.ZodNullable<z.ZodString>;
+    provider: z.ZodLiteral<"vercel">;
+  }, z.core.$strip>], "provider">>;
+  buildId: z.ZodString;
+}, z.core.$strip>;
+type CreateReleaseRequest = z.infer<typeof createReleaseRequest>;
+declare const createReleaseResponse: z.ZodObject<{
+  org: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+  }, z.core.$strip>;
+  surface: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+  }, z.core.$strip>;
+  source: z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$strip>;
+  destination: z.ZodObject<{
+    id: z.ZodString;
+    slug: z.ZodString;
+    environment: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  build: z.ZodObject<{
+    hash: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CreateReleaseResponse = z.infer<typeof createReleaseResponse>;
+//#endregion
+export { CreateReleaseRequest, CreateReleaseResponse, createReleaseRequest, createReleaseResponse, releaseStatusSchema };

package/dist/releases/definition.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.mts","names":[],"sources":["../../src/releases/definition.ts"],"mappings":";;;cAOa,mBAAA,EAAmB,CAAA,CAAA,OAAA;;;;;;;cAQnB,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;KAMrB,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAErC,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;KAsBtB,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/releases/definition.mjs

@@ -0,0 +1,34 @@
+import { releaseDestinationMetadataSchema, releaseSourceMetadataSchema } from "../integrations/index.mjs";
+import { z } from "zod";
+//#region src/releases/definition.ts
+const releaseStatusSchema = z.enum([
+	"pending",
+	"uploading",
+	"processing",
+	"ready",
+	"failed"
+]);
+const createReleaseRequest = z.object({
+	source: releaseSourceMetadataSchema,
+	destination: releaseDestinationMetadataSchema.nullable(),
+	buildId: z.string()
+});
+const createReleaseResponse = z.object({
+	org: z.object({
+		id: z.string(),
+		slug: z.string()
+	}),
+	surface: z.object({
+		id: z.string(),
+		slug: z.string()
+	}),
+	source: z.object({ id: z.string() }),
+	destination: z.object({
+		id: z.string(),
+		slug: z.string(),
+		environment: z.string().nullable()
+	}),
+	build: z.object({ hash: z.string() })
+});
+//#endregion
+export { createReleaseRequest, createReleaseResponse, releaseStatusSchema };

package/dist/releases/definition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.mjs","names":[],"sources":["../../src/releases/definition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport {\n  releaseDestinationMetadataSchema,\n  releaseSourceMetadataSchema,\n} from \"../integrations\";\n\nexport const releaseStatusSchema = z.enum([\n  \"pending\",\n  \"uploading\",\n  \"processing\",\n  \"ready\",\n  \"failed\",\n]);\n\nexport const createReleaseRequest = z.object({\n  source: releaseSourceMetadataSchema,\n  destination: releaseDestinationMetadataSchema.nullable(),\n  buildId: z.string(),\n});\n\nexport type CreateReleaseRequest = z.infer<typeof createReleaseRequest>;\n\nexport const createReleaseResponse = z.object({\n  org: z.object({\n    id: z.string(),\n    slug: z.string(),\n  }),\n  surface: z.object({\n    id: z.string(),\n    slug: z.string(),\n  }),\n  source: z.object({\n    id: z.string(),\n  }),\n  destination: z.object({\n    id: z.string(),\n    slug: z.string(),\n    environment: z.string().nullable(),\n  }),\n  build: z.object({\n    hash: z.string(),\n  }),\n});\n\nexport type CreateReleaseResponse = z.infer<typeof createReleaseResponse>;\n"],"mappings":";;;AAOA,MAAa,sBAAsB,EAAE,KAAK;CACxC;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,MAAa,uBAAuB,EAAE,OAAO;CAC3C,QAAQ;CACR,aAAa,iCAAiC,UAAU;CACxD,SAAS,EAAE,QAAQ;CACpB,CAAC;AAIF,MAAa,wBAAwB,EAAE,OAAO;CAC5C,KAAK,EAAE,OAAO;EACZ,IAAI,EAAE,QAAQ;EACd,MAAM,EAAE,QAAQ;EACjB,CAAC;CACF,SAAS,EAAE,OAAO;EAChB,IAAI,EAAE,QAAQ;EACd,MAAM,EAAE,QAAQ;EACjB,CAAC;CACF,QAAQ,EAAE,OAAO,EACf,IAAI,EAAE,QAAQ,EACf,CAAC;CACF,aAAa,EAAE,OAAO;EACpB,IAAI,EAAE,QAAQ;EACd,MAAM,EAAE,QAAQ;EAChB,aAAa,EAAE,QAAQ,CAAC,UAAU;EACnC,CAAC;CACF,OAAO,EAAE,OAAO,EACd,MAAM,EAAE,QAAQ,EACjB,CAAC;CACH,CAAC"}

package/dist/sdk/capture.d.mts

@@ -0,0 +1,8 @@
+import { EventType } from "./envelope.mjs";
+import { z } from "zod/v4";
+
+//#region src/sdk/capture.d.ts
+declare const defaultCaptureSchemas: Partial<Record<EventType, z.ZodType>>;
+type CaptureDefaults = typeof defaultCaptureSchemas;
+//#endregion
+export { CaptureDefaults, defaultCaptureSchemas };

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

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.mts","names":[],"sources":["../../src/sdk/capture.ts"],"mappings":";;;;cAWa,qBAAA,EAAuB,OAAA,CAAQ,MAAA,CAAO,SAAA,EAAW,CAAA,CAAE,OAAA;AAAA,KAOpD,eAAA,UAAyB,qBAAA"}

package/dist/sdk/capture.mjs

@@ -0,0 +1,12 @@
+import { errorEnvelopePayloadSchema } from "#sdk/plugins/payload/errors";
+import { pageleavePayloadSchema, pageviewPayloadSchema } from "#sdk/plugins/payload/page-events";
+import { rageClickPayloadSchema } from "#sdk/plugins/payload/rage-click";
+//#region src/sdk/capture.ts
+const defaultCaptureSchemas = {
+	error: errorEnvelopePayloadSchema,
+	pageleave: pageleavePayloadSchema,
+	pageview: pageviewPayloadSchema,
+	rage_click: rageClickPayloadSchema
+};
+//#endregion
+export { defaultCaptureSchemas };

package/dist/sdk/capture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.mjs","names":[],"sources":["../../src/sdk/capture.ts"],"sourcesContent":["import type { z } from \"zod/v4\";\n\nimport { errorEnvelopePayloadSchema } from \"#sdk/plugins/payload/errors\";\nimport {\n  pageleavePayloadSchema,\n  pageviewPayloadSchema,\n} from \"#sdk/plugins/payload/page-events\";\nimport { rageClickPayloadSchema } from \"#sdk/plugins/payload/rage-click\";\n\nimport type { EventType } from \"./envelope.js\";\n\nexport const defaultCaptureSchemas: Partial<Record<EventType, z.ZodType>> = {\n  error: errorEnvelopePayloadSchema,\n  pageleave: pageleavePayloadSchema,\n  pageview: pageviewPayloadSchema,\n  rage_click: rageClickPayloadSchema,\n};\n\nexport type CaptureDefaults = typeof defaultCaptureSchemas;\n"],"mappings":";;;;AAWA,MAAa,wBAA+D;CAC1E,OAAO;CACP,WAAW;CACX,UAAU;CACV,YAAY;CACb"}

package/dist/sdk/config.d.mts

@@ -0,0 +1,178 @@
+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://in.interfere.com": "https://in.interfere.com";
+  "http://localhost:3001": "http://localhost:3001";
+}>]>;
+declare const featuresSchema: z.ZodDefault<z.ZodObject<{
+  errors: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  fingerprint: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  replay: 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>>;
+    fingerprint: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    replay: 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;
+    fingerprint?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    replay?: 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;
+    fingerprint?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    replay?: 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;
+    fingerprint?: boolean | undefined;
+    pageEvents?: boolean | undefined;
+    rageClick?: boolean | undefined;
+    replay?: 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>>;
+    fingerprint: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    pageEvents: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    rageClick: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    replay: 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"],"mappings":";;;cAWa,oBAAA,EAAoB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;;;;KAgBrB,cAAA,GAAiB,CAAA,CAAE,KAAA,QAAa,oBAAA;AAAA,cAE/B,gBAAA,EAAgB,CAAA,CAAA,QAAA,WAAA,CAAA,CAAA,SAAA,EAAA,CAAA,CAAA,OAAA;;;;cAKhB,cAAA,EAAc,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;KAgBf,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cAgCzB,YAAA,EAAY,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,eAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAeb,MAAA,GAAS,CAAA,CAAE,MAAA,QAAc,YAAA;AAAA,cAExB,iBAAA,EAAiB,CAAA,CAAA,eAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuBlB,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,cAE5B,qBAAA,EAAqB,CAAA,CAAA,OAAA;;;;;KAMtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/sdk/config.mjs

@@ -0,0 +1,67 @@
+import { PLUGIN_MANIFEST } from "./plugins/manifest.mjs";
+import { z } from "zod/v4";
+import { API_URL } from "@interfere/constants/api";
+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 { PLUGIN_MANIFEST, type PluginKey } 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":";;;;;AAQA,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,KAAA,EAC1B,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/env.d.mts

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+
+//#region src/sdk/env.d.ts
+declare const interfereEnvValueSchema: z.ZodString;
+type InterfereEnvValue = z.infer<typeof interfereEnvValueSchema>;
+declare function parseEnvValue(value: unknown): InterfereEnvValue | null;
+declare function readFirstEnvValue(env: Record<string, string | undefined>, keys: readonly string[]): InterfereEnvValue | null;
+//#endregion
+export { InterfereEnvValue, interfereEnvValueSchema, parseEnvValue, readFirstEnvValue };