@interfere/types 0.0.3 → 0.1.0-alpha.1

package/dist/auth/public-token.d.mts

@@ -0,0 +1,9 @@
+import z$1 from "zod";
+
+//#region src/auth/public-token.d.ts
+declare const PUBLIC_TOKEN_PREFIX = "int_pub_";
+declare const PUBLIC_TOKEN_REGEX: RegExp;
+declare const publicTokenSchema: z$1.ZodString;
+type PublicToken = z$1.infer<typeof publicTokenSchema>;
+//#endregion
+export { PUBLIC_TOKEN_PREFIX, PUBLIC_TOKEN_REGEX, PublicToken, publicTokenSchema };

package/dist/auth/public-token.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-token.d.mts","names":[],"sources":["../../src/auth/public-token.ts"],"sourcesContent":[],"mappings":";;;cAEa,mBAAA;cACA,oBAAkB;AADlB,cAGA,iBAHmB,EAGF,GAAA,CAAA,SAHE;AACnB,KAID,WAAA,GAAc,GAAA,CAAE,KAJgC,CAAA,OAInB,iBAJmB,CAAA"}

package/dist/auth/public-token.mjs

@@ -0,0 +1,9 @@
+import z$1 from "zod";
+
+//#region src/auth/public-token.ts
+const PUBLIC_TOKEN_PREFIX = "int_pub_";
+const PUBLIC_TOKEN_REGEX = /^int_pub_([a-zA-Z0-9]+)$/;
+const publicTokenSchema = z$1.string().startsWith(PUBLIC_TOKEN_PREFIX);
+
+//#endregion
+export { PUBLIC_TOKEN_PREFIX, PUBLIC_TOKEN_REGEX, publicTokenSchema };

package/dist/auth/public-token.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-token.mjs","names":["z"],"sources":["../../src/auth/public-token.ts"],"sourcesContent":["import z from \"zod\";\n\nexport const PUBLIC_TOKEN_PREFIX = \"int_pub_\";\nexport const PUBLIC_TOKEN_REGEX = /^int_pub_([a-zA-Z0-9]+)$/;\n\nexport const publicTokenSchema = z.string().startsWith(PUBLIC_TOKEN_PREFIX);\n\nexport type PublicToken = z.infer<typeof publicTokenSchema>;\n"],"mappings":";;;AAEA,MAAa,sBAAsB;AACnC,MAAa,qBAAqB;AAElC,MAAa,oBAAoBA,IAAE,QAAQ,CAAC,WAAW,oBAAoB"}

package/dist/auth/secret-key.d.mts

@@ -0,0 +1,5 @@
+//#region src/auth/secret-key.d.ts
+declare const SECRET_KEY_REGEX: RegExp;
+declare const SECRET_KEY_PREFIX = "int_sk_";
+//#endregion
+export { SECRET_KEY_PREFIX, SECRET_KEY_REGEX };

package/dist/auth/secret-key.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-key.d.mts","names":[],"sources":["../../src/auth/secret-key.ts"],"sourcesContent":[],"mappings":";cAGa,kBAAgB;AAAhB,cAEA,iBAAA,GAF6D,SAAA"}

package/dist/auth/secret-key.mjs

@@ -0,0 +1,6 @@
+//#region src/auth/secret-key.ts
+const SECRET_KEY_REGEX = /^int_sk_([a-zA-Z0-9_-]+)_([a-zA-Z0-9]+)$/;
+const SECRET_KEY_PREFIX = "int_sk_";
+
+//#endregion
+export { SECRET_KEY_PREFIX, SECRET_KEY_REGEX };

package/dist/auth/secret-key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-key.mjs","names":[],"sources":["../../src/auth/secret-key.ts"],"sourcesContent":["// Format: int_sk_{surfaceSlug}_{random}\n// surfaceSlug can contain alphanumeric chars, hyphens, and underscores\n// random part is alphanumeric only (no underscores)\nexport const SECRET_KEY_REGEX = /^int_sk_([a-zA-Z0-9_-]+)_([a-zA-Z0-9]+)$/;\n\nexport const SECRET_KEY_PREFIX = \"int_sk_\";\n"],"mappings":";AAGA,MAAa,mBAAmB;AAEhC,MAAa,oBAAoB"}

package/dist/data/frame.d.mts

@@ -0,0 +1,20 @@
+import z$1 from "zod";
+
+//#region src/data/frame.d.ts
+declare const ingestedFrame: z$1.ZodObject<{
+  file: z$1.ZodObject<{
+    reported: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  line: z$1.ZodObject<{
+    reported: z$1.ZodNullable<z$1.ZodNumber>;
+  }, z$1.core.$strip>;
+  column: z$1.ZodObject<{
+    reported: z$1.ZodNullable<z$1.ZodNumber>;
+  }, z$1.core.$strip>;
+  fn: z$1.ZodObject<{
+    reported: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type IngestedFrame = z$1.infer<typeof ingestedFrame>;
+//#endregion
+export { IngestedFrame, ingestedFrame };

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.mts","names":[],"sources":["../../src/data/frame.ts"],"sourcesContent":[],"mappings":";;;cAEa,eAAa,GAAA,CAAA;;IAAb,QAAA,iBAaX,cAAA,CAAA;;;;;;;;;;;;KAEU,aAAA,GAAgB,GAAA,CAAE,aAAa"}

package/dist/data/frame.mjs

@@ -0,0 +1,12 @@
+import z$1 from "zod";
+
+//#region src/data/frame.ts
+const ingestedFrame = z$1.object({
+	file: z$1.object({ reported: z$1.string().nullable() }),
+	line: z$1.object({ reported: z$1.number().nullable() }),
+	column: z$1.object({ reported: z$1.number().nullable() }),
+	fn: z$1.object({ reported: z$1.string().nullable() })
+});
+
+//#endregion
+export { ingestedFrame };

package/dist/data/frame.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.mjs","names":["z"],"sources":["../../src/data/frame.ts"],"sourcesContent":["import z from \"zod\";\n\nexport const ingestedFrame = z.object({\n  file: z.object({\n    reported: z.string().nullable(),\n  }),\n  line: z.object({\n    reported: z.number().nullable(),\n  }),\n  column: z.object({\n    reported: z.number().nullable(),\n  }),\n  fn: z.object({\n    reported: z.string().nullable(),\n  }),\n});\n\nexport type IngestedFrame = z.infer<typeof ingestedFrame>;\n"],"mappings":";;;AAEA,MAAa,gBAAgBA,IAAE,OAAO;CACpC,MAAMA,IAAE,OAAO,EACb,UAAUA,IAAE,QAAQ,CAAC,UAAU,EAChC,CAAC;CACF,MAAMA,IAAE,OAAO,EACb,UAAUA,IAAE,QAAQ,CAAC,UAAU,EAChC,CAAC;CACF,QAAQA,IAAE,OAAO,EACf,UAAUA,IAAE,QAAQ,CAAC,UAAU,EAChC,CAAC;CACF,IAAIA,IAAE,OAAO,EACX,UAAUA,IAAE,QAAQ,CAAC,UAAU,EAChC,CAAC;CACH,CAAC"}

package/dist/data/session.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+//#region src/data/session.d.ts
+declare const sessionIdSchema: z.ZodUUID;
+type SessionId = z.infer<typeof sessionIdSchema>;
+//#endregion
+export { SessionId, sessionIdSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.mts","names":[],"sources":["../../src/data/session.ts"],"sourcesContent":[],"mappings":";;;cAEa,iBAAe,CAAA,CAAA;KAEhB,SAAA,GAAY,CAAA,CAAE,aAAa"}

package/dist/data/session.mjs

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+//#region src/data/session.ts
+const sessionIdSchema = z.uuidv7();
+
+//#endregion
+export { sessionIdSchema };

package/dist/data/session.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.mjs","names":[],"sources":["../../src/data/session.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const sessionIdSchema = z.uuidv7();\n\nexport type SessionId = z.infer<typeof sessionIdSchema>;\n"],"mappings":";;;AAEA,MAAa,kBAAkB,EAAE,QAAQ"}

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

@@ -0,0 +1,95 @@
+import { z } from "zod";
+
+//#region src/data/source-maps.d.ts
+declare const baseFileMetadataSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  hash: z.ZodString;
+}, z.core.$strip>;
+declare const sourceMapFileSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  hash: z.ZodString;
+  size: z.ZodNumber;
+}, z.core.$strip>;
+type SourceMapFile = z.infer<typeof sourceMapFileSchema>;
+declare const uploadTokenSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  uploadUrl: z.ZodURL;
+  expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type UploadToken = z.infer<typeof uploadTokenSchema>;
+declare const batchUploadPathsSchema: z.ZodObject<{
+  uploadPaths: z.ZodRecord<z.ZodString, z.ZodObject<{
+    uploadPath: z.ZodString;
+    contentType: z.ZodString;
+  }, z.core.$strip>>;
+  expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type BatchUploadPaths = z.infer<typeof batchUploadPathsSchema>;
+declare const batchUploadTokensSchema: z.ZodObject<{
+  uploadPaths: z.ZodRecord<z.ZodString, z.ZodObject<{
+    uploadPath: z.ZodString;
+    contentType: z.ZodString;
+  }, z.core.$strip>>;
+  expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type BatchUploadTokens = BatchUploadPaths;
+declare const uploadedBlobSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  hash: z.ZodString;
+  blobUrl: z.ZodURL;
+}, z.core.$strip>;
+declare const uploadedSourceMapSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  hash: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>;
+declare const uploadedJsFileSchema: z.ZodObject<{
+  relativePath: z.ZodString;
+  hash: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strip>;
+type UploadedSourceMap = z.infer<typeof uploadedSourceMapSchema>;
+type UploadedJsFile = z.infer<typeof uploadedJsFileSchema>;
+type UploadedBlob = z.infer<typeof uploadedBlobSchema>;
+declare const sourceMapConfigSchema: z.ZodObject<{
+  uploadTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+  concurrency: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type SourceMapConfig = z.infer<typeof sourceMapConfigSchema>;
+declare const getSourceMapPath: ({
+  orgId,
+  surfaceId,
+  releaseId,
+  relativePath
+}: {
+  orgId: string;
+  surfaceId: number;
+  releaseId: number;
+  relativePath: string;
+}) => string;
+declare const getDistPath: ({
+  orgId,
+  surfaceId,
+  releaseId,
+  relativePath
+}: {
+  orgId: string;
+  surfaceId: number;
+  releaseId: number;
+  relativePath: string;
+}) => string;
+declare const sourceMapMappingSchema: z.ZodObject<{
+  releaseId: z.ZodNumber;
+  filePath: z.ZodString;
+  generatedFilePath: z.ZodString;
+  generatedLine: z.ZodNumber;
+  generatedColumn: z.ZodNumber;
+  originalFile: z.ZodNullable<z.ZodString>;
+  originalLine: z.ZodNullable<z.ZodNumber>;
+  originalColumn: z.ZodNullable<z.ZodNumber>;
+  originalName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type SourceMapMapping = z.infer<typeof sourceMapMappingSchema>;
+//#endregion
+export { BatchUploadPaths, BatchUploadTokens, SourceMapConfig, SourceMapFile, SourceMapMapping, UploadToken, UploadedBlob, UploadedJsFile, UploadedSourceMap, baseFileMetadataSchema, batchUploadPathsSchema, batchUploadTokensSchema, getDistPath, getSourceMapPath, sourceMapConfigSchema, sourceMapFileSchema, sourceMapMappingSchema, uploadTokenSchema, uploadedBlobSchema, uploadedJsFileSchema, uploadedSourceMapSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"source-maps.d.mts","names":[],"sources":["../../src/data/source-maps.ts"],"sourcesContent":[],"mappings":";;;cAGa,wBAAsB,CAAA,CAAA;;EAAtB,IAAA,aAAA;;cAMA,qBAAmB,CAAA,CAAA;;EANG,IAAA,aAAA;EAAA,IAAA,aAAA;AAMnC,CAAA,eAAa,CAAA;KAID,aAAA,GAAgB,CAAA,CAAE,aAAa;cAG9B,mBAAiB,CAAA,CAAA;;;EAPE,SAAA,kBAAA;CAAA,eAAA,CAAA;AAIpB,KASA,WAAA,GAAc,CAAA,CAAE,KATe,CAAA,OASF,iBATX,CAAA;AAGjB,cASA,sBALX,EAKiC,CAAA,CAAA,SALjC,CAAA;;;;;EAJ4B,SAAA,kBAAA;CAAA,eAAA,CAAA;AAMlB,KAcA,gBAAA,GAAmB,CAAA,CAAE,KAdQ,CAAA,OAcK,sBAdb,CAAA;AAGpB,cAcA,uBALX,EAKkC,CAAA,CAAA,SALlC,CAAA;;;;;;;KAMU,iBAAA,GAAoB;cAGnB,oBAAkB,CAAA,CAAA;EAlBI,YAAA,aAAA;EAAA,IAAA,aAAA;EAWvB,OAAA,UAAA;AAGZ,CAAA,eAAa,CAAA;cASA,yBAAuB,CAAA,CAAA;;;;;cAKvB,sBAAoB,CAAA,CAAA;;;EAdG,OAAA,aAAA;CAAA,eAAA,CAAA;AACxB,KAiBA,iBAAA,GAAoB,CAAA,CAAE,KAjBF,CAAA,OAiBe,uBAjBC,CAAA;AAGnC,KAeD,cAAA,GAAiB,CAAA,CAAE,KAb7B,CAAA,OAa0C,oBAb1C,CAAA;KAcU,YAAA,GAAe,CAAA,CAAE,aAAa;cAG7B,uBAAqB,CAAA,CAAA;;;EAnBH,WAAA,cAAA,YAAA,CAAA;CAAA,eAAA,CAAA;AAKlB,KAoBD,eAAA,GAAkB,CAAA,CAAE,KAlB9B,CAAA,OAkB2C,qBAlB3C,CAAA;cAqBW;;;;;;;;;EAvBuB,YAAA,EAAA,MAAA;CAAA,EAAA,GAAA,MAAA;AAKvB,cA+BA,WA7BX,EAAA,CAAA;EAAA,KAAA;EAAA,SAAA;EAAA,SAAA;EAAA;CAAA,EAAA;;;;;CAF+B,EAAA,GAAA,MAAA;AAAA,cA6CpB,sBA7CoB,EA6CE,CAAA,CAAA,SA7CF,CAAA;EAIrB,SAAA,aAAiB;EACjB,QAAA,aAAc;EACd,iBAAY,aAAkB;EAG7B,aAAA,aAIX;;;;;;;KA4CU,gBAAA,GAAmB,CAAA,CAAE,aAAa"}

package/dist/data/source-maps.mjs

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+//#region src/data/source-maps.ts
+const baseFileMetadataSchema = z.object({
+	relativePath: z.string().describe("Relative path of the file"),
+	hash: z.string().describe("SHA256 hash of the file content")
+});
+const sourceMapFileSchema = baseFileMetadataSchema.extend({ size: z.number().positive().describe("File size in bytes") });
+const uploadTokenSchema = z.object({
+	relativePath: z.string(),
+	uploadUrl: z.url(),
+	expiresAt: z.iso.datetime()
+});
+const batchUploadPathsSchema = z.object({
+	uploadPaths: z.record(z.string(), z.object({
+		uploadPath: z.string(),
+		contentType: z.string()
+	})),
+	expiresAt: z.iso.datetime()
+});
+const batchUploadTokensSchema = batchUploadPathsSchema;
+const uploadedBlobSchema = baseFileMetadataSchema.extend({ blobUrl: z.url() });
+const uploadedSourceMapSchema = baseFileMetadataSchema.extend({ content: z.string() });
+const uploadedJsFileSchema = baseFileMetadataSchema.extend({ content: z.string() });
+const sourceMapConfigSchema = z.object({
+	uploadTimeoutMs: z.number().positive().default(3e4),
+	maxRetries: z.number().min(0).default(3),
+	concurrency: z.number().positive().default(5)
+});
+const getSourceMapPath = ({ orgId, surfaceId, releaseId, relativePath }) => `source-maps/orgs/${orgId}/surfaces/${surfaceId}/releases/${releaseId}/${relativePath}`;
+const getDistPath = ({ orgId, surfaceId, releaseId, relativePath }) => `INTERFERE_DIST/orgs/${orgId}/surfaces/${surfaceId}/releases/${releaseId}/${relativePath}`;
+const sourceMapMappingSchema = z.object({
+	releaseId: z.number(),
+	filePath: z.string(),
+	generatedFilePath: z.string(),
+	generatedLine: z.number(),
+	generatedColumn: z.number(),
+	originalFile: z.string().nullable(),
+	originalLine: z.number().nullable(),
+	originalColumn: z.number().nullable(),
+	originalName: z.string().nullable()
+});
+
+//#endregion
+export { baseFileMetadataSchema, batchUploadPathsSchema, batchUploadTokensSchema, getDistPath, getSourceMapPath, sourceMapConfigSchema, sourceMapFileSchema, sourceMapMappingSchema, uploadTokenSchema, uploadedBlobSchema, uploadedJsFileSchema, uploadedSourceMapSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"source-maps.mjs","names":[],"sources":["../../src/data/source-maps.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Base schema for file metadata (shared between multiple file types)\nexport const baseFileMetadataSchema = z.object({\n  relativePath: z.string().describe(\"Relative path of the file\"),\n  hash: z.string().describe(\"SHA256 hash of the file content\"),\n});\n\n// File metadata for source map uploads (extends base with size)\nexport const sourceMapFileSchema = baseFileMetadataSchema.extend({\n  size: z.number().positive().describe(\"File size in bytes\"),\n});\n\nexport type SourceMapFile = z.infer<typeof sourceMapFileSchema>;\n\n// Upload token response\nexport const uploadTokenSchema = z.object({\n  relativePath: z.string(),\n  uploadUrl: z.url(),\n  expiresAt: z.iso.datetime(),\n});\n\nexport type UploadToken = z.infer<typeof uploadTokenSchema>;\n\n// Batch upload paths - paths only, tokens are generated per-file via /upload endpoint\nexport const batchUploadPathsSchema = z.object({\n  uploadPaths: z.record(\n    z.string(), // file relative path\n    z.object({\n      uploadPath: z.string(), // Path to use with Vercel Blob upload()\n      contentType: z.string(),\n    })\n  ),\n  expiresAt: z.iso.datetime(),\n});\n\nexport type BatchUploadPaths = z.infer<typeof batchUploadPathsSchema>;\n\n// Legacy schema for backwards compatibility (deprecated)\nexport const batchUploadTokensSchema = batchUploadPathsSchema;\nexport type BatchUploadTokens = BatchUploadPaths;\n\n// Uploaded blob with URL reference\nexport const uploadedBlobSchema = baseFileMetadataSchema.extend({\n  blobUrl: z.url(),\n});\n\n// Uploaded source map with content\nexport const uploadedSourceMapSchema = baseFileMetadataSchema.extend({\n  content: z.string(),\n});\n\n// Uploaded generated JS file with content\nexport const uploadedJsFileSchema = baseFileMetadataSchema.extend({\n  content: z.string(),\n});\n\nexport type UploadedSourceMap = z.infer<typeof uploadedSourceMapSchema>;\nexport type UploadedJsFile = z.infer<typeof uploadedJsFileSchema>;\nexport type UploadedBlob = z.infer<typeof uploadedBlobSchema>;\n\n// Source map configuration\nexport const sourceMapConfigSchema = z.object({\n  uploadTimeoutMs: z.number().positive().default(30_000),\n  maxRetries: z.number().min(0).default(3),\n  concurrency: z.number().positive().default(5),\n});\n\nexport type SourceMapConfig = z.infer<typeof sourceMapConfigSchema>;\n\n// Helper functions for path generation\nexport const getSourceMapPath = ({\n  orgId,\n  surfaceId,\n  releaseId,\n  relativePath,\n}: {\n  orgId: string;\n  surfaceId: number;\n  releaseId: number;\n  relativePath: string;\n}) =>\n  `source-maps/orgs/${orgId}/surfaces/${surfaceId}/releases/${releaseId}/${relativePath}`;\n\nexport const getDistPath = ({\n  orgId,\n  surfaceId,\n  releaseId,\n  relativePath,\n}: {\n  orgId: string;\n  surfaceId: number;\n  releaseId: number;\n  relativePath: string;\n}) =>\n  `INTERFERE_DIST/orgs/${orgId}/surfaces/${surfaceId}/releases/${releaseId}/${relativePath}`;\n\n// Source map mapping information for source map parsing/processing\nexport const sourceMapMappingSchema = z.object({\n  releaseId: z.number(),\n  filePath: z.string(), // Source map file path in blob storage\n  generatedFilePath: z.string(), // Generated/minified JS file path (e.g., \"static/chunks/file.js\")\n  generatedLine: z.number(),\n  generatedColumn: z.number(),\n  originalFile: z.string().nullable(),\n  originalLine: z.number().nullable(),\n  originalColumn: z.number().nullable(),\n  originalName: z.string().nullable(),\n});\n\nexport type SourceMapMapping = z.infer<typeof sourceMapMappingSchema>;\n"],"mappings":";;;AAGA,MAAa,yBAAyB,EAAE,OAAO;CAC7C,cAAc,EAAE,QAAQ,CAAC,SAAS,4BAA4B;CAC9D,MAAM,EAAE,QAAQ,CAAC,SAAS,kCAAkC;CAC7D,CAAC;AAGF,MAAa,sBAAsB,uBAAuB,OAAO,EAC/D,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,qBAAqB,EAC3D,CAAC;AAKF,MAAa,oBAAoB,EAAE,OAAO;CACxC,cAAc,EAAE,QAAQ;CACxB,WAAW,EAAE,KAAK;CAClB,WAAW,EAAE,IAAI,UAAU;CAC5B,CAAC;AAKF,MAAa,yBAAyB,EAAE,OAAO;CAC7C,aAAa,EAAE,OACb,EAAE,QAAQ,EACV,EAAE,OAAO;EACP,YAAY,EAAE,QAAQ;EACtB,aAAa,EAAE,QAAQ;EACxB,CAAC,CACH;CACD,WAAW,EAAE,IAAI,UAAU;CAC5B,CAAC;AAKF,MAAa,0BAA0B;AAIvC,MAAa,qBAAqB,uBAAuB,OAAO,EAC9D,SAAS,EAAE,KAAK,EACjB,CAAC;AAGF,MAAa,0BAA0B,uBAAuB,OAAO,EACnE,SAAS,EAAE,QAAQ,EACpB,CAAC;AAGF,MAAa,uBAAuB,uBAAuB,OAAO,EAChE,SAAS,EAAE,QAAQ,EACpB,CAAC;AAOF,MAAa,wBAAwB,EAAE,OAAO;CAC5C,iBAAiB,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,IAAO;CACtD,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;CACxC,aAAa,EAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE;CAC9C,CAAC;AAKF,MAAa,oBAAoB,EAC/B,OACA,WACA,WACA,mBAOA,oBAAoB,MAAM,YAAY,UAAU,YAAY,UAAU,GAAG;AAE3E,MAAa,eAAe,EAC1B,OACA,WACA,WACA,mBAOA,uBAAuB,MAAM,YAAY,UAAU,YAAY,UAAU,GAAG;AAG9E,MAAa,yBAAyB,EAAE,OAAO;CAC7C,WAAW,EAAE,QAAQ;CACrB,UAAU,EAAE,QAAQ;CACpB,mBAAmB,EAAE,QAAQ;CAC7B,eAAe,EAAE,QAAQ;CACzB,iBAAiB,EAAE,QAAQ;CAC3B,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,gBAAgB,EAAE,QAAQ,CAAC,UAAU;CACrC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACpC,CAAC"}

package/dist/data/surface.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+//#region src/data/surface.d.ts
+declare const surfaceSlugSchema: z.ZodString;
+type SurfaceSlug = z.infer<typeof surfaceSlugSchema>;
+//#endregion
+export { SurfaceSlug, surfaceSlugSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"surface.d.mts","names":[],"sources":["../../src/data/surface.ts"],"sourcesContent":[],"mappings":";;;cAQa,mBAAiB,CAAA,CAAA;KAElB,WAAA,GAAc,CAAA,CAAE,aAAa"}

package/dist/data/surface.mjs

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+//#region src/data/surface.ts
+const SURFACE_SLUG_LENGTH = 21;
+const surfaceSlugSchema = z.string().length(SURFACE_SLUG_LENGTH);
+
+//#endregion
+export { surfaceSlugSchema };

package/dist/data/surface.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface.mjs","names":[],"sources":["../../src/data/surface.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Surface slug length constraints\nconst SURFACE_SLUG_LENGTH = 21; // Standard nanoid length\n\n// Surface slugs are nanoid-generated URL-friendly identifiers for surfaces\n// These are the ONLY surface identifiers exposed to clients\n// Internal numeric IDs should NEVER be exposed\nexport const surfaceSlugSchema = z.string().length(SURFACE_SLUG_LENGTH);\n\nexport type SurfaceSlug = z.infer<typeof surfaceSlugSchema>;\n"],"mappings":";;;AAGA,MAAM,sBAAsB;AAK5B,MAAa,oBAAoB,EAAE,QAAQ,CAAC,OAAO,oBAAoB"}

package/dist/releases/definition.d.mts

@@ -0,0 +1,89 @@
+import z$1 from "zod";
+
+//#region src/releases/definition.d.ts
+declare const releaseStatusSchema: z$1.ZodEnum<{
+  pending: "pending";
+  uploading: "uploading";
+  processing: "processing";
+  ready: "ready";
+  failed: "failed";
+}>;
+declare const releaseSourceTypeSchema: z$1.ZodEnum<{
+  git: "git";
+}>;
+type ReleaseSourceType = z$1.infer<typeof releaseSourceTypeSchema>;
+declare const releaseSourceMetadataSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  type: z$1.ZodLiteral<"git">;
+  gitCommitMessage: z$1.ZodString;
+  gitBranch: z$1.ZodString;
+  gitCommitSha: z$1.ZodString;
+}, z$1.core.$strip>], "type">;
+type ReleaseSourceMetadata = z$1.infer<typeof releaseSourceMetadataSchema>;
+declare const releaseDestinationTypeSchema: z$1.ZodEnum<{
+  vercel: "vercel";
+}>;
+type ReleaseDestinationType = z$1.infer<typeof releaseDestinationTypeSchema>;
+declare const releaseDestinationMetadataSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  type: z$1.ZodLiteral<"vercel">;
+  deployment: z$1.ZodObject<{
+    id: z$1.ZodNullable<z$1.ZodString>;
+    url: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  env: z$1.ZodObject<{
+    name: z$1.ZodNullable<z$1.ZodString>;
+    target: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  project: z$1.ZodObject<{
+    id: z$1.ZodNullable<z$1.ZodString>;
+    productionUrl: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  region: z$1.ZodNullable<z$1.ZodString>;
+  skewProtectionEnabled: z$1.ZodNullable<z$1.ZodBoolean>;
+}, z$1.core.$strip>], "type">;
+type ReleaseDestinationMetadata = z$1.infer<typeof releaseDestinationMetadataSchema>;
+declare const createReleaseSchema: z$1.ZodObject<{
+  sourceId: z$1.ZodString;
+  environment: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+  sourceType: z$1.ZodEnum<{
+    git: "git";
+  }>;
+  sourceMetadata: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    type: z$1.ZodLiteral<"git">;
+    gitCommitMessage: z$1.ZodString;
+    gitBranch: z$1.ZodString;
+    gitCommitSha: z$1.ZodString;
+  }, z$1.core.$strip>], "type">;
+  destinationType: z$1.ZodEnum<{
+    vercel: "vercel";
+  }>;
+  destinationMetadata: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    type: z$1.ZodLiteral<"vercel">;
+    deployment: z$1.ZodObject<{
+      id: z$1.ZodNullable<z$1.ZodString>;
+      url: z$1.ZodNullable<z$1.ZodString>;
+    }, z$1.core.$strip>;
+    env: z$1.ZodObject<{
+      name: z$1.ZodNullable<z$1.ZodString>;
+      target: z$1.ZodNullable<z$1.ZodString>;
+    }, z$1.core.$strip>;
+    project: z$1.ZodObject<{
+      id: z$1.ZodNullable<z$1.ZodString>;
+      productionUrl: z$1.ZodNullable<z$1.ZodString>;
+    }, z$1.core.$strip>;
+    region: z$1.ZodNullable<z$1.ZodString>;
+    skewProtectionEnabled: z$1.ZodNullable<z$1.ZodBoolean>;
+  }, z$1.core.$strip>], "type">;
+}, z$1.core.$strip>;
+type CreateRelease = z$1.infer<typeof createReleaseSchema>;
+declare const createReleaseResponseSchema: z$1.ZodObject<{
+  orgId: z$1.ZodString;
+  surfaceId: z$1.ZodNumber;
+  surfaceSlug: z$1.ZodString;
+  sourceId: z$1.ZodString;
+  environment: z$1.ZodString;
+  releaseId: z$1.ZodNumber;
+  releaseSlug: z$1.ZodString;
+}, z$1.core.$strip>;
+type CreateReleaseResponse = z$1.infer<typeof createReleaseResponseSchema>;
+//#endregion
+export { CreateRelease, CreateReleaseResponse, ReleaseDestinationMetadata, ReleaseDestinationType, ReleaseSourceMetadata, ReleaseSourceType, createReleaseResponseSchema, createReleaseSchema, releaseDestinationMetadataSchema, releaseDestinationTypeSchema, releaseSourceMetadataSchema, releaseSourceTypeSchema, releaseStatusSchema };

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.mts","names":[],"sources":["../../src/releases/definition.ts"],"sourcesContent":[],"mappings":";;;cAWa,qBAAmB,GAAA,CAAA;;EAAnB,SAAA,EAAA,WAMX;EAGW,UAAA,EAAA,YAAA;EAID,KAAA,EAAA,OAAA;EAEC,MAAA,EAAA,QAAA;;cANA,yBAAuB,GAAA,CAAA;;;KAIxB,iBAAA,GAAoB,GAAA,CAAE,aAAa;AAEP,cAA3B,2BAA2B,EAAA,GAAA,CAAA,qBAAA,CAAA,CAAA,GAAA,CAAA,SAAA,CAAA;EAAA,IAAA,gBAAA,CAAA,KAAA,CAAA;EAAA,gBAAA,eAAA;EAI5B,SAAA,eAAA;EAGC,YAAA,eAAA;AAIb,CAAA,iBAAY,CAAA,CAAA,EAAA,MAAA,CAAA;AAIC,KAXD,qBAAA,GAAwB,GAAA,CAAE,KAapC,CAAA,OAbiD,2BAajD,CAAA;cAVW,8BAA4B,GAAA,CAAA;;;KAI7B,sBAAA,GAAyB,GAAA,CAAE,aAC9B;cAGI,kCAAgC,GAAA,CAAA,uBAAA,GAAA,CAAA;;;;;;;;;;;;;;;;;KAIjC,0BAAA,GAA6B,GAAA,CAAE,aAClC;cAII,qBAAmB,GAAA,CAAA;;EATa,WAAA,gBAAA,gBAAA,cAAA,CAAA,CAAA;EAAA,UAAA,aAAA,CAAA;IAAA,GAAA,EAAA,KAAA;EAIjC,CAAA,CAAA;EAKC,cAAA,2BAOX,CAAA,cAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEU,aAAA,GAAgB,GAAA,CAAE,aAAa;cAG9B,6BAA2B,GAAA,CAAA;;;;;;;;;KAU5B,qBAAA,GAAwB,GAAA,CAAE,aAAa"}

package/dist/releases/definition.mjs

@@ -0,0 +1,36 @@
+import { versionControlMetadataSchema, versionControlTypeSchema } from "./sources/version-control.mjs";
+import { cloudPlatformMetadataSchema, cloudPlatformTypeSchema } from "./targets/cloud-platform.mjs";
+import z$1 from "zod";
+
+//#region src/releases/definition.ts
+const releaseStatusSchema = z$1.enum([
+	"pending",
+	"uploading",
+	"processing",
+	"ready",
+	"failed"
+]);
+const releaseSourceTypeSchema = z$1.enum([...versionControlTypeSchema.options]);
+const releaseSourceMetadataSchema = z$1.discriminatedUnion("type", [...versionControlMetadataSchema.options]);
+const releaseDestinationTypeSchema = z$1.enum([...cloudPlatformTypeSchema.options]);
+const releaseDestinationMetadataSchema = z$1.discriminatedUnion("type", [...cloudPlatformMetadataSchema.options]);
+const createReleaseSchema = z$1.object({
+	sourceId: z$1.string(),
+	environment: z$1.string().optional().default("production"),
+	sourceType: releaseSourceTypeSchema,
+	sourceMetadata: releaseSourceMetadataSchema,
+	destinationType: releaseDestinationTypeSchema,
+	destinationMetadata: releaseDestinationMetadataSchema
+});
+const createReleaseResponseSchema = z$1.object({
+	orgId: z$1.string(),
+	surfaceId: z$1.number(),
+	surfaceSlug: z$1.string(),
+	sourceId: z$1.string(),
+	environment: z$1.string(),
+	releaseId: z$1.number(),
+	releaseSlug: z$1.string()
+});
+
+//#endregion
+export { createReleaseResponseSchema, createReleaseSchema, releaseDestinationMetadataSchema, releaseDestinationTypeSchema, releaseSourceMetadataSchema, releaseSourceTypeSchema, releaseStatusSchema };

package/dist/releases/definition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.mjs","names":["z"],"sources":["../../src/releases/definition.ts"],"sourcesContent":["import z from \"zod\";\n\nimport {\n  versionControlMetadataSchema,\n  versionControlTypeSchema,\n} from \"./sources/version-control.js\";\nimport {\n  cloudPlatformMetadataSchema,\n  cloudPlatformTypeSchema,\n} from \"./targets/cloud-platform.js\";\n\nexport const releaseStatusSchema = z.enum([\n  \"pending\",\n  \"uploading\",\n  \"processing\",\n  \"ready\",\n  \"failed\",\n]);\n\n// Source\nexport const releaseSourceTypeSchema = z.enum([\n  ...versionControlTypeSchema.options,\n]);\n\nexport type ReleaseSourceType = z.infer<typeof releaseSourceTypeSchema>;\n\nexport const releaseSourceMetadataSchema = z.discriminatedUnion(\"type\", [\n  ...versionControlMetadataSchema.options,\n]);\n\nexport type ReleaseSourceMetadata = z.infer<typeof releaseSourceMetadataSchema>;\n\n// Destination\nexport const releaseDestinationTypeSchema = z.enum([\n  ...cloudPlatformTypeSchema.options,\n]);\n\nexport type ReleaseDestinationType = z.infer<\n  typeof releaseDestinationTypeSchema\n>;\n\nexport const releaseDestinationMetadataSchema = z.discriminatedUnion(\"type\", [\n  ...cloudPlatformMetadataSchema.options,\n]);\n\nexport type ReleaseDestinationMetadata = z.infer<\n  typeof releaseDestinationMetadataSchema\n>;\n\n// Create release schema - now that all dependencies are defined\nexport const createReleaseSchema = z.object({\n  sourceId: z.string(),\n  environment: z.string().optional().default(\"production\"),\n  sourceType: releaseSourceTypeSchema,\n  sourceMetadata: releaseSourceMetadataSchema,\n  destinationType: releaseDestinationTypeSchema,\n  destinationMetadata: releaseDestinationMetadataSchema,\n});\n\nexport type CreateRelease = z.infer<typeof createReleaseSchema>;\n\n// Response schema for release creation\nexport const createReleaseResponseSchema = z.object({\n  orgId: z.string(),\n  surfaceId: z.number(),\n  surfaceSlug: z.string(),\n  sourceId: z.string(),\n  environment: z.string(),\n  releaseId: z.number(),\n  releaseSlug: z.string(),\n});\n\nexport type CreateReleaseResponse = z.infer<typeof createReleaseResponseSchema>;\n"],"mappings":";;;;;AAWA,MAAa,sBAAsBA,IAAE,KAAK;CACxC;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,MAAa,0BAA0BA,IAAE,KAAK,CAC5C,GAAG,yBAAyB,QAC7B,CAAC;AAIF,MAAa,8BAA8BA,IAAE,mBAAmB,QAAQ,CACtE,GAAG,6BAA6B,QACjC,CAAC;AAKF,MAAa,+BAA+BA,IAAE,KAAK,CACjD,GAAG,wBAAwB,QAC5B,CAAC;AAMF,MAAa,mCAAmCA,IAAE,mBAAmB,QAAQ,CAC3E,GAAG,4BAA4B,QAChC,CAAC;AAOF,MAAa,sBAAsBA,IAAE,OAAO;CAC1C,UAAUA,IAAE,QAAQ;CACpB,aAAaA,IAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,aAAa;CACxD,YAAY;CACZ,gBAAgB;CAChB,iBAAiB;CACjB,qBAAqB;CACtB,CAAC;AAKF,MAAa,8BAA8BA,IAAE,OAAO;CAClD,OAAOA,IAAE,QAAQ;CACjB,WAAWA,IAAE,QAAQ;CACrB,aAAaA,IAAE,QAAQ;CACvB,UAAUA,IAAE,QAAQ;CACpB,aAAaA,IAAE,QAAQ;CACvB,WAAWA,IAAE,QAAQ;CACrB,aAAaA,IAAE,QAAQ;CACxB,CAAC"}

package/dist/releases/sources/version-control.d.mts

@@ -0,0 +1,16 @@
+import z$1 from "zod";
+
+//#region src/releases/sources/version-control.d.ts
+declare const versionControlTypeSchema: z$1.ZodEnum<{
+  git: "git";
+}>;
+type VersionControlType = z$1.infer<typeof versionControlTypeSchema>;
+declare const versionControlMetadataSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  type: z$1.ZodLiteral<"git">;
+  gitCommitMessage: z$1.ZodString;
+  gitBranch: z$1.ZodString;
+  gitCommitSha: z$1.ZodString;
+}, z$1.core.$strip>], "type">;
+type VersionControlMetadata = z$1.infer<typeof versionControlMetadataSchema>;
+//#endregion
+export { VersionControlMetadata, VersionControlType, versionControlMetadataSchema, versionControlTypeSchema };

package/dist/releases/sources/version-control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-control.d.mts","names":[],"sources":["../../../src/releases/sources/version-control.ts"],"sourcesContent":[],"mappings":";;;cAEa,0BAAwB,GAAA,CAAA;;AAArC,CAAA,CAAA;AAEY,KAAA,kBAAA,GAAqB,GAAA,CAAE,KAAa,CAAA,OAAA,wBAAb,CAAK;AAE3B,cAAA,4BAOX,EAPuC,GAAA,CAAA,qBAOvC,CAAA,CAPuC,GAAA,CAAA,SAOvC,CAAA;;;;;;AAPuC,KAS7B,sBAAA,GAAyB,GAAA,CAAE,KATE,CAAA,OAUhC,4BAVgC,CAAA"}

package/dist/releases/sources/version-control.mjs

@@ -0,0 +1,13 @@
+import z$1 from "zod";
+
+//#region src/releases/sources/version-control.ts
+const versionControlTypeSchema = z$1.enum(["git"]);
+const versionControlMetadataSchema = z$1.discriminatedUnion("type", [z$1.object({
+	type: z$1.literal(versionControlTypeSchema.enum.git),
+	gitCommitMessage: z$1.string(),
+	gitBranch: z$1.string(),
+	gitCommitSha: z$1.string()
+})]);
+
+//#endregion
+export { versionControlMetadataSchema, versionControlTypeSchema };

package/dist/releases/sources/version-control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-control.mjs","names":["z"],"sources":["../../../src/releases/sources/version-control.ts"],"sourcesContent":["import z from \"zod\";\n\nexport const versionControlTypeSchema = z.enum([\"git\"]);\n\nexport type VersionControlType = z.infer<typeof versionControlTypeSchema>;\n\nexport const versionControlMetadataSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(versionControlTypeSchema.enum.git),\n    gitCommitMessage: z.string(),\n    gitBranch: z.string(),\n    gitCommitSha: z.string(),\n  }),\n]);\n\nexport type VersionControlMetadata = z.infer<\n  typeof versionControlMetadataSchema\n>;\n"],"mappings":";;;AAEA,MAAa,2BAA2BA,IAAE,KAAK,CAAC,MAAM,CAAC;AAIvD,MAAa,+BAA+BA,IAAE,mBAAmB,QAAQ,CACvEA,IAAE,OAAO;CACP,MAAMA,IAAE,QAAQ,yBAAyB,KAAK,IAAI;CAClD,kBAAkBA,IAAE,QAAQ;CAC5B,WAAWA,IAAE,QAAQ;CACrB,cAAcA,IAAE,QAAQ;CACzB,CAAC,CACH,CAAC"}

package/dist/releases/targets/cloud-platform.d.mts

@@ -0,0 +1,27 @@
+import z$1 from "zod";
+
+//#region src/releases/targets/cloud-platform.d.ts
+declare const cloudPlatformTypeSchema: z$1.ZodEnum<{
+  vercel: "vercel";
+}>;
+type CloudPlatformType = z$1.infer<typeof cloudPlatformTypeSchema>;
+declare const cloudPlatformMetadataSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  type: z$1.ZodLiteral<"vercel">;
+  deployment: z$1.ZodObject<{
+    id: z$1.ZodNullable<z$1.ZodString>;
+    url: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  env: z$1.ZodObject<{
+    name: z$1.ZodNullable<z$1.ZodString>;
+    target: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  project: z$1.ZodObject<{
+    id: z$1.ZodNullable<z$1.ZodString>;
+    productionUrl: z$1.ZodNullable<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  region: z$1.ZodNullable<z$1.ZodString>;
+  skewProtectionEnabled: z$1.ZodNullable<z$1.ZodBoolean>;
+}, z$1.core.$strip>], "type">;
+type CloudPlatformMetadata = z$1.infer<typeof cloudPlatformMetadataSchema>;
+//#endregion
+export { CloudPlatformMetadata, CloudPlatformType, cloudPlatformMetadataSchema, cloudPlatformTypeSchema };

package/dist/releases/targets/cloud-platform.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-platform.d.mts","names":[],"sources":["../../../src/releases/targets/cloud-platform.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,GAAA,CAAA;;AAApC,CAAA,CAAA;AAEY,KAAA,iBAAA,GAAoB,GAAA,CAAE,KAAa,CAAA,OAAA,uBAAb,CAAK;AAE1B,cAAA,2BAkBX,EAlBsC,GAAA,CAAA,qBAkBtC,CAAA,CAlBsC,GAAA,CAAA,SAkBtC,CAAA;;;;;;;;;;;;;;;;;KAEU,qBAAA,GAAwB,GAAA,CAAE,aAAa"}

package/dist/releases/targets/cloud-platform.mjs

@@ -0,0 +1,24 @@
+import z$1 from "zod";
+
+//#region src/releases/targets/cloud-platform.ts
+const cloudPlatformTypeSchema = z$1.enum(["vercel"]);
+const cloudPlatformMetadataSchema = z$1.discriminatedUnion("type", [z$1.object({
+	type: z$1.literal(cloudPlatformTypeSchema.enum.vercel),
+	deployment: z$1.object({
+		id: z$1.string().nullable(),
+		url: z$1.string().nullable()
+	}),
+	env: z$1.object({
+		name: z$1.string().nullable(),
+		target: z$1.string().nullable()
+	}),
+	project: z$1.object({
+		id: z$1.string().nullable(),
+		productionUrl: z$1.string().nullable()
+	}),
+	region: z$1.string().nullable(),
+	skewProtectionEnabled: z$1.boolean().nullable()
+})]);
+
+//#endregion
+export { cloudPlatformMetadataSchema, cloudPlatformTypeSchema };

package/dist/releases/targets/cloud-platform.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-platform.mjs","names":["z"],"sources":["../../../src/releases/targets/cloud-platform.ts"],"sourcesContent":["import z from \"zod\";\n\nexport const cloudPlatformTypeSchema = z.enum([\"vercel\"]);\n\nexport type CloudPlatformType = z.infer<typeof cloudPlatformTypeSchema>;\n\nexport const cloudPlatformMetadataSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(cloudPlatformTypeSchema.enum.vercel),\n    deployment: z.object({\n      id: z.string().nullable(),\n      url: z.string().nullable(),\n    }),\n    env: z.object({\n      name: z.string().nullable(),\n      target: z.string().nullable(),\n    }),\n    project: z.object({\n      id: z.string().nullable(),\n      productionUrl: z.string().nullable(),\n    }),\n    region: z.string().nullable(),\n    skewProtectionEnabled: z.boolean().nullable(),\n  }),\n]);\n\nexport type CloudPlatformMetadata = z.infer<typeof cloudPlatformMetadataSchema>;\n"],"mappings":";;;AAEA,MAAa,0BAA0BA,IAAE,KAAK,CAAC,SAAS,CAAC;AAIzD,MAAa,8BAA8BA,IAAE,mBAAmB,QAAQ,CACtEA,IAAE,OAAO;CACP,MAAMA,IAAE,QAAQ,wBAAwB,KAAK,OAAO;CACpD,YAAYA,IAAE,OAAO;EACnB,IAAIA,IAAE,QAAQ,CAAC,UAAU;EACzB,KAAKA,IAAE,QAAQ,CAAC,UAAU;EAC3B,CAAC;CACF,KAAKA,IAAE,OAAO;EACZ,MAAMA,IAAE,QAAQ,CAAC,UAAU;EAC3B,QAAQA,IAAE,QAAQ,CAAC,UAAU;EAC9B,CAAC;CACF,SAASA,IAAE,OAAO;EAChB,IAAIA,IAAE,QAAQ,CAAC,UAAU;EACzB,eAAeA,IAAE,QAAQ,CAAC,UAAU;EACrC,CAAC;CACF,QAAQA,IAAE,QAAQ,CAAC,UAAU;CAC7B,uBAAuBA,IAAE,SAAS,CAAC,UAAU;CAC9C,CAAC,CACH,CAAC"}

package/dist/sdk/capture.d.mts

@@ -0,0 +1,8 @@
+import { EventType } from "./plugins/lib/types.mjs";
+import { z } from "zod/v4";
+
+//#region src/sdk/capture.d.ts
+declare const defaultCaptureSchemas: Partial<Record<EventType, z.ZodObject>>;
+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"],"sourcesContent":[],"mappings":";;;;cAYa,uBAAuB,QAAQ,OAAO,WAAW,CAAA,CAAE;KAQpD,eAAA,UAAyB"}

package/dist/sdk/capture.mjs

@@ -0,0 +1,16 @@
+import { sessionSummaryPayloadSchema } from "#sdk/plugins/payload/ai-summary";
+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,
+	rage_click: rageClickPayloadSchema,
+	session_summary: sessionSummaryPayloadSchema,
+	pageview: pageviewPayloadSchema,
+	pageleave: pageleavePayloadSchema
+};
+
+//#endregion
+export { defaultCaptureSchemas };

package/dist/sdk/capture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.mjs","names":["defaultCaptureSchemas: Partial<Record<EventType, z.ZodObject>>"],"sources":["../../src/sdk/capture.ts"],"sourcesContent":["import type { z } from \"zod/v4\";\n\nimport { sessionSummaryPayloadSchema } from \"#sdk/plugins/payload/ai-summary\";\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 \"./plugins/lib/types.js\";\n\nexport const defaultCaptureSchemas: Partial<Record<EventType, z.ZodObject>> = {\n  error: errorEnvelopePayloadSchema,\n  rage_click: rageClickPayloadSchema,\n  session_summary: sessionSummaryPayloadSchema,\n  pageview: pageviewPayloadSchema,\n  pageleave: pageleavePayloadSchema,\n};\n\nexport type CaptureDefaults = typeof defaultCaptureSchemas;\n"],"mappings":";;;;;;AAYA,MAAaA,wBAAiE;CAC5E,OAAO;CACP,YAAY;CACZ,iBAAiB;CACjB,UAAU;CACV,WAAW;CACZ"}