@getuserfeedback/protocol 0.6.0 → 0.7.2

package/dist/widget-commands.d.ts

@@ -11,6 +11,7 @@ export declare const publicWidgetCommandKindSchema: z.ZodMiniEnum<{
     init: "init";
     close: "close";
     reset: "reset";
+    track: "track";
 }>;
 export declare const containerPolicySchema: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"floating">;
@@ -76,9 +77,9 @@ export declare const publicCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodM
         colorScheme: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
             autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
         }, z.core.$strict>, z.ZodMiniEnum<{
+            system: "system";
             light: "light";
             dark: "dark";
-            system: "system";
         }>]>>;
         consent: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
             pending: "pending";
@@ -108,9 +109,9 @@ export declare const publicCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodM
         colorScheme: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
             autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
         }, z.core.$strict>, z.ZodMiniEnum<{
+            system: "system";
             light: "light";
             dark: "dark";
-            system: "system";
         }>]>>;
         disableTelemetry: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         enableDebug: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -253,7 +254,105 @@ export declare const publicCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodM
     flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
 }, z.core.$strict>, z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"reset">;
-}, z.core.$strict>], "kind">, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+}, z.core.$strict>, z.ZodMiniObject<{
+    traits: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
+    identities: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        type: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./identity-type.js").IdentityTypeValue, string>>;
+        value: z.ZodMiniString<string>;
+    }, z.core.$strip>>>;
+    context: z.ZodMiniOptional<z.ZodMiniObject<{
+        page: z.ZodMiniOptional<z.ZodMiniObject<{
+            path: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            referrer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            search: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        userAgent: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        flags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+            key: z.ZodMiniString<string>;
+            target: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            value: z.ZodMiniType<string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+                [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null, unknown, z.core.$ZodTypeInternals<string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+                [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null)[] | {
+                [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+            } | null, unknown>>;
+            variant: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            origin: z.ZodMiniOptional<z.ZodMiniEnum<{
+                runtime_config: "runtime_config";
+                trigger_context: "trigger_context";
+                provider_sync: "provider_sync";
+                api: "api";
+            }>>;
+            provider: z.ZodMiniOptional<z.ZodMiniObject<{
+                name: z.ZodMiniString<string>;
+                project: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                environment: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>>;
+            status: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            evaluatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strip>>>;
+        capabilities: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+            key: z.ZodMiniString<string>;
+            source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            provider: z.ZodMiniOptional<z.ZodMiniObject<{
+                name: z.ZodMiniString<string>;
+                project: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                environment: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    messageId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    timestamp: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    origin: z.ZodMiniLiteral<"customer">;
+    event: z.ZodMiniString<string>;
+    properties: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<import("./app-event.js").AppEventJsonValue, unknown, z.core.$ZodTypeInternals<import("./app-event.js").AppEventJsonValue, unknown>>>>;
+    kind: z.ZodMiniLiteral<"track">;
+}, z.core.$strip>], "kind">, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"identify">;
     traits: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
 }, z.core.$strict>, z.ZodMiniObject<{

package/dist/widget-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"widget-commands.d.ts","sourceRoot":"","sources":["../src/widget-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAC9B,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAEhB,MAAM,oBAAoB,CAAC;AAmB5B,eAAO,MAAM,6BAA6B;;;;;;;;;;;EAAmC,CAAC;AAyC9E,eAAO,MAAM,qBAAqB;;;;;;;;;4BAShC,CAAC;AAeH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAwCrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAErE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAE5D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAEtE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAEvE"}
+{"version":3,"file":"widget-commands.d.ts","sourceRoot":"","sources":["../src/widget-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAEhB,MAAM,oBAAoB,CAAC;AAoB5B,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAAmC,CAAC;AAyC9E,eAAO,MAAM,qBAAqB;;;;;;;;;4BAShC,CAAC;AAeH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA2CrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAErE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAE5D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAEtE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAEvE"}

package/dist/widget-commands.js

@@ -1,4 +1,5 @@
 import * as z from "zod/mini";
+import { appEventCustomerTrackSchema } from "./app-event.js";
 import { configureOptionsSchema, initOptionsSchema, } from "./widget-config.js";
 const flowHandleIdSchema = z.string().check(z.trim(), z.minLength(1));
 const flowIdSchema = z.string().check(z.trim(), z.minLength(1));
@@ -14,6 +15,7 @@ const publicWidgetCommandKinds = [
     "init",
     "close",
     "reset",
+    "track",
 ];
 export const publicWidgetCommandKindSchema = z.enum(publicWidgetCommandKinds);
 const isHTMLElementLike = (value) => {
@@ -105,6 +107,9 @@ export const publicCommandPayloadSchema = z.union([
         z.strictObject({
             kind: z.literal("reset"),
         }),
+        z.extend(appEventCustomerTrackSchema, {
+            kind: z.literal("track"),
+        }),
     ]),
     identifyPayloadSchema,
 ]);

package/dist/widget-config.d.ts

@@ -2,9 +2,9 @@ import * as z from "zod/mini";
 export declare const colorSchemeConfigInputSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
 }, z.core.$strict>, z.ZodMiniEnum<{
+    system: "system";
     light: "light";
     dark: "dark";
-    system: "system";
 }>]>;
 export type ColorSchemeConfigInput = z.output<typeof colorSchemeConfigInputSchema>;
 export declare const telemetryConfigInputSchema: z.ZodMiniObject<{
@@ -128,9 +128,9 @@ export declare const configureOptionsSchema: z.ZodMiniObject<{
     colorScheme: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
     }, z.core.$strict>, z.ZodMiniEnum<{
+        system: "system";
         light: "light";
         dark: "dark";
-        system: "system";
     }>]>>;
     consent: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
         pending: "pending";
@@ -159,9 +159,9 @@ export declare const initOptionsSchema: z.ZodMiniObject<{
     colorScheme: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
     }, z.core.$strict>, z.ZodMiniEnum<{
+        system: "system";
         light: "light";
         dark: "dark";
-        system: "system";
     }>]>>;
     disableTelemetry: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     enableDebug: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -310,9 +310,9 @@ export declare const instanceUpdateableConfigSchema: z.ZodMiniObject<{
     colorScheme: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
     }, z.core.$strict>, z.ZodMiniEnum<{
+        system: "system";
         light: "light";
         dark: "dark";
-        system: "system";
     }>]>>;
     consent: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
         pending: "pending";
@@ -354,9 +354,9 @@ export declare const coreInstanceConfigSchema: z.ZodMiniObject<{
     colorScheme: z.ZodMiniDefault<z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         autoDetectColorScheme: z.ZodMiniArray<z.ZodMiniString<string>>;
     }, z.core.$strict>, z.ZodMiniEnum<{
+        system: "system";
         light: "light";
         dark: "dark";
-        system: "system";
     }>]>>>;
     disableTelemetry: z.ZodMiniDefault<z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>>;
     enableDebug: z.ZodMiniDefault<z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getuserfeedback/protocol",
-	"version": "0.6.0",
+	"version": "0.7.2",
 	"description": "getuserfeedback widget protocol — host surface and (later) wire protocol",
 	"keywords": [
 		"getuserfeedback",
@@ -8,82 +8,101 @@
 		"protocol"
 	],
 	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/getuserfeedback/getuserfeedback.git"
+	},
 	"publishConfig": {
 		"access": "public"
 	},
 	"type": "module",
 	"sideEffects": false,
 	"files": [
-		"dist"
+		"dist",
+		"src"
 	],
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
 		"./host": {
 			"types": "./dist/host/index.d.ts",
+			"bun": "./src/host/index.ts",
 			"import": "./dist/host/index.js",
 			"default": "./dist/host/index.js"
 		},
 		"./host/sdk-types": {
 			"types": "./dist/host/sdk-types.d.ts",
+			"bun": "./src/host/sdk-types.ts",
 			"import": "./dist/host/sdk-types.js",
 			"default": "./dist/host/sdk-types.js"
 		},
 		"./host/host-event-contract": {
 			"types": "./dist/host/host-event-contract.d.ts",
+			"bun": "./src/host/host-event-contract.ts",
 			"import": "./dist/host/host-event-contract.js",
 			"default": "./dist/host/host-event-contract.js"
 		},
 		"./host/constants": {
 			"types": "./dist/host/constants.d.ts",
+			"bun": "./src/host/constants.ts",
 			"import": "./dist/host/constants.js",
 			"default": "./dist/host/constants.js"
 		},
 		"./host/command-dispatch": {
 			"types": "./dist/host/command-dispatch.d.ts",
+			"bun": "./src/host/command-dispatch.ts",
 			"import": "./dist/host/command-dispatch.js",
 			"default": "./dist/host/command-dispatch.js"
 		},
 		"./host/command-settlement": {
 			"types": "./dist/host/command-settlement.d.ts",
+			"bun": "./src/host/command-settlement.ts",
 			"import": "./dist/host/command-settlement.js",
 			"default": "./dist/host/command-settlement.js"
 		},
 		"./host/sdk": {
 			"types": "./dist/host/sdk.d.ts",
+			"bun": "./src/host/sdk.ts",
 			"import": "./dist/host/sdk.js",
 			"default": "./dist/host/sdk.js"
 		},
 		"./host/request-id": {
 			"types": "./dist/host/request-id.d.ts",
+			"bun": "./src/host/request-id.ts",
 			"import": "./dist/host/request-id.js",
 			"default": "./dist/host/request-id.js"
 		},
 		"./host/unique-id": {
 			"types": "./dist/host/unique-id.d.ts",
+			"bun": "./src/host/unique-id.ts",
 			"import": "./dist/host/unique-id.js",
 			"default": "./dist/host/unique-id.js"
 		},
 		"./host/lazy-handle-client": {
 			"types": "./dist/host/lazy-handle-client.d.ts",
+			"bun": "./src/host/lazy-handle-client.ts",
 			"import": "./dist/host/lazy-handle-client.js",
 			"default": "./dist/host/lazy-handle-client.js"
 		},
 		"./version-resolution": {
 			"types": "./dist/version-resolution.d.ts",
+			"bun": "./src/version-resolution.ts",
 			"import": "./dist/version-resolution.js",
 			"default": "./dist/version-resolution.js"
 		},
 		"./flow-assignments": {
 			"types": "./dist/flow-assignments.d.ts",
+			"bun": "./src/flow-assignments.ts",
 			"import": "./dist/flow-assignments.js",
 			"default": "./dist/flow-assignments.js"
 		},
 		"./trpc-envelope": {
 			"types": "./dist/trpc-envelope.d.ts",
+			"bun": "./src/trpc-envelope.ts",
 			"import": "./dist/trpc-envelope.js",
 			"default": "./dist/trpc-envelope.js"
 		}
@@ -91,6 +110,7 @@
 	"scripts": {
 		"lint": "ultracite check .",
 		"build": "bun ../../scripts/clean-build-output.ts dist tsconfig.tsbuildinfo && tsc -b tsconfig.json",
+		"types": "bun ../../scripts/clean-build-output.ts dist tsconfig.tsbuildinfo && tsc -b tsconfig.json --emitDeclarationOnly",
 		"typecheck": "tsc -b tsconfig.json",
 		"test": "bun test --dots",
 		"pack:verify": "node ../../scripts/pack-and-verify.cjs",

package/src/app-event.ts

@@ -0,0 +1,211 @@
+import * as z from "zod/mini";
+import { appEventIdentityTypeSchema } from "./identity-type.js";
+
+export { appEventIdentityTypeSchema } from "./identity-type.js";
+
+export const appEventIdentitySchema = z.object({
+	type: appEventIdentityTypeSchema,
+	value: z.string().check(z.trim(), z.minLength(1)),
+});
+
+type AppEventFlagValue =
+	| string
+	| number
+	| boolean
+	| null
+	| AppEventFlagValue[]
+	| { [key: string]: AppEventFlagValue };
+
+export type AppEventJsonValue =
+	| string
+	| number
+	| boolean
+	| null
+	| AppEventJsonValue[]
+	| { [key: string]: AppEventJsonValue };
+
+const appEventFlagValueSchema: z.ZodMiniType<AppEventFlagValue> = z.lazy(() =>
+	z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null(),
+		z.array(appEventFlagValueSchema),
+		z.record(z.string(), appEventFlagValueSchema),
+	]),
+);
+
+const appEventJsonNumberSchema = z.number().check(
+	z.refine(Number.isFinite, {
+		message: "Expected a finite JSON number.",
+	}),
+);
+
+const appEventJsonValueSchema: z.ZodMiniType<AppEventJsonValue> = z.lazy(() =>
+	z.union([
+		z.string(),
+		appEventJsonNumberSchema,
+		z.boolean(),
+		z.null(),
+		z.array(appEventJsonValueSchema),
+		z.record(z.string(), appEventJsonValueSchema),
+	]),
+);
+
+const appEventJsonObjectSchema = z.record(z.string(), appEventJsonValueSchema);
+
+export const appEventFlagProviderSchema = z.object({
+	name: z.string().check(z.trim(), z.minLength(1)),
+	project: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	environment: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export const appEventFlagSchema = z.object({
+	key: z.string().check(z.trim(), z.minLength(1)),
+	target: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	value: appEventFlagValueSchema,
+	variant: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	origin: z.optional(
+		z.enum(["runtime_config", "trigger_context", "provider_sync", "api"]),
+	),
+	provider: z.optional(appEventFlagProviderSchema),
+	status: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	reason: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	evaluatedAt: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export const appEventCapabilitySchema = z.object({
+	key: z.string().check(z.trim(), z.minLength(1)),
+	source: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	provider: z.optional(appEventFlagProviderSchema),
+});
+
+const appEventPageSchema = z.object({
+	path: z.optional(z.string()),
+	referrer: z.optional(z.string()),
+	search: z.optional(z.string()),
+});
+
+export const appEventContextSchema = z.object({
+	page: z.optional(appEventPageSchema),
+	locale: z.optional(z.string()),
+	userAgent: z.optional(z.string()),
+	flags: z.optional(z.array(appEventFlagSchema)),
+	capabilities: z.optional(z.array(appEventCapabilitySchema)),
+});
+
+export const appEventBaseSchema = z.object({
+	traits: z.optional(z.record(z.string(), z.unknown())),
+	identities: z.optional(z.array(appEventIdentitySchema)),
+	context: z.optional(appEventContextSchema),
+	messageId: z.optional(z.string()),
+	timestamp: z.optional(z.number()),
+});
+
+const appEventSurveyReferenceSchema = z.object({
+	surveyId: z.string(),
+});
+
+export const reservedSystemAppEventNames = [
+	"Response Submitted",
+	"Flow Viewed",
+	"Flow Dismissed",
+	"Identified",
+] as const;
+const reservedSystemAppEventNameLowercaseSet = new Set<string>(
+	reservedSystemAppEventNames.map((event) => event.toLowerCase()),
+);
+
+const appEventSystemTrackNameSchema = z.enum(["Flow Viewed", "Flow Dismissed"]);
+
+const appEventCustomerNameSchema = z.string().check(
+	z.trim(),
+	z.minLength(1),
+	z.maxLength(255),
+	z.check<string>((ctx) => {
+		if (!reservedSystemAppEventNameLowercaseSet.has(ctx.value.toLowerCase())) {
+			return;
+		}
+		ctx.issues.push({
+			code: "custom",
+			input: ctx.value,
+			message:
+				"Customer app event names cannot use reserved system event names.",
+			continue: false,
+		});
+	}),
+);
+
+export const appEventSystemBaseSchema = z.extend(appEventBaseSchema, {
+	origin: z.literal("system"),
+});
+
+const normalizeSystemAppEventOrigin = <T extends { origin?: "system" }>(
+	input: T,
+): Omit<T, "origin"> & { origin: "system" } => {
+	const { origin: _origin, ...rest } = input;
+	return {
+		...rest,
+		origin: "system" as const,
+	};
+};
+
+export const appEventSurveyViewedSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: z.literal("Flow Viewed"),
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventFlowDismissedSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: z.literal("Flow Dismissed"),
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventSystemTrackSchema = z.extend(appEventSystemBaseSchema, {
+	event: appEventSystemTrackNameSchema,
+	references: appEventSurveyReferenceSchema,
+});
+
+const appEventLegacySystemTrackSchema = z.pipe(
+	z.extend(appEventBaseSchema, {
+		origin: z.optional(z.literal("system")),
+		event: appEventSystemTrackNameSchema,
+		references: appEventSurveyReferenceSchema,
+	}),
+	z.transform(normalizeSystemAppEventOrigin),
+);
+
+export const appEventCustomerTrackSchema = z.extend(appEventBaseSchema, {
+	origin: z.literal("customer"),
+	event: appEventCustomerNameSchema,
+	// TODO(migration): Normalize Date values in event properties to ISO strings.
+	//   [from=manual-date-property-serialization] [to=protocol-date-property-normalization] [scope=slice] [priority=medium] [impact=medium] [risk=low]
+	properties: z.optional(appEventJsonObjectSchema),
+});
+
+export const appEventTrackSchema = z.union([
+	appEventLegacySystemTrackSchema,
+	appEventCustomerTrackSchema,
+]);
+
+const appEventDiscriminatedPayloadSchema = z.discriminatedUnion("origin", [
+	appEventSystemTrackSchema,
+	appEventCustomerTrackSchema,
+]);
+
+export const appEventPayloadSchema = z.union([
+	appEventLegacySystemTrackSchema,
+	appEventDiscriminatedPayloadSchema,
+]);
+
+export type AppEventTrackInput = z.output<typeof appEventTrackSchema>;
+export type AppEventPayload = z.output<typeof appEventPayloadSchema>;
+export type AppEventFlag = z.output<typeof appEventFlagSchema>;
+export type AppEventCapability = z.output<typeof appEventCapabilitySchema>;

package/src/client-meta.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/mini";
+
+export const clientMetaSchema = z.object({
+	loader: z.enum(["sdk", "gtm", "segment", "rudderstack", "tealium", "custom"]),
+	clientName: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	clientVersion: z.optional(z.string().check(z.trim(), z.minLength(1))),
+	integrator: z.optional(
+		z.object({
+			name: z.optional(z.string().check(z.trim(), z.minLength(1))),
+			version: z.optional(z.string().check(z.trim(), z.minLength(1))),
+		}),
+	),
+	transport: z.optional(
+		z.enum(["script-tag", "esm", "loader", "tag-manager", "snippet"]),
+	),
+	runtime: z.optional(
+		z.object({
+			framework: z.optional(z.enum(["next", "vite", "webpack", "plain"])),
+			runtime: z.optional(z.enum(["browser", "edge"])),
+		}),
+	),
+	notes: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+export type ClientMeta = z.output<typeof clientMetaSchema>;

package/src/defaults.ts

@@ -0,0 +1,4 @@
+export const DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS: readonly [
+	"class",
+	"data-theme",
+] = ["class", "data-theme"];

package/src/errors.ts

@@ -0,0 +1,58 @@
+import * as z from "zod/mini";
+
+import { clientMetaSchema } from "./client-meta.js";
+
+// ---------------------------------------------------------------------------
+// Error-telemetry definitions shared across widget / host.
+// ---------------------------------------------------------------------------
+
+export const ErrorCategory = {
+	INTERNAL: "INTERNAL",
+	INVALID_USAGE: "INVALID_USAGE",
+	HOST: "HOST",
+} as const;
+
+export type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+
+export const ErrorCategorySchema = z.enum([
+	ErrorCategory.INTERNAL,
+	ErrorCategory.INVALID_USAGE,
+	ErrorCategory.HOST,
+]);
+
+export const ErrorEventSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	message: z.string(),
+	stack: z.optional(z.string()),
+	category: ErrorCategorySchema,
+	timestamp: z.number(),
+	probability: z.optional(z.number()),
+	context: z.object({
+		widgetVersion: z.string(),
+		clientMeta: z.optional(clientMetaSchema),
+		/** When true, telemetry was captured with debug mode on (affects how to interpret context). */
+		debug: z.optional(z.boolean()),
+	}),
+});
+
+export type ErrorEvent = z.output<typeof ErrorEventSchema>;
+
+export type ProtocolErrorCode = "PARSE" | "VERSION" | "UNKNOWN_TYPE";
+
+const MAX_DETAIL_LENGTH = 80;
+
+export class ProtocolError extends Error {
+	code: ProtocolErrorCode;
+	details: string;
+
+	constructor(code: ProtocolErrorCode, details: string) {
+		const short =
+			details.length > MAX_DETAIL_LENGTH
+				? details.slice(0, MAX_DETAIL_LENGTH)
+				: details;
+		super(short);
+		this.code = code;
+		this.details = short;
+	}
+}