@getuserfeedback/protocol 0.1.0 → 0.2.0

package/dist/client-meta.d.ts

@@ -0,0 +1,39 @@
+import * as z from "zod";
+export declare const clientMetaSchema: z.ZodObject<{
+    loader: z.ZodEnum<{
+        sdk: "sdk";
+        gtm: "gtm";
+        segment: "segment";
+        rudderstack: "rudderstack";
+        tealium: "tealium";
+        custom: "custom";
+    }>;
+    clientName: z.ZodOptional<z.ZodString>;
+    clientVersion: z.ZodOptional<z.ZodString>;
+    integrator: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    transport: z.ZodOptional<z.ZodEnum<{
+        loader: "loader";
+        "script-tag": "script-tag";
+        esm: "esm";
+        "tag-manager": "tag-manager";
+        snippet: "snippet";
+    }>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        framework: z.ZodOptional<z.ZodEnum<{
+            next: "next";
+            vite: "vite";
+            webpack: "webpack";
+            plain: "plain";
+        }>>;
+        runtime: z.ZodOptional<z.ZodEnum<{
+            browser: "browser";
+            edge: "edge";
+        }>>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ClientMeta = z.output<typeof clientMetaSchema>;
+//# sourceMappingURL=client-meta.d.ts.map

package/dist/client-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-meta.d.ts","sourceRoot":"","sources":["../src/client-meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoB3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/client-meta.js

@@ -0,0 +1,16 @@
+import * as z from "zod";
+export const clientMetaSchema = z.object({
+    loader: z.enum(["sdk", "gtm", "segment", "rudderstack", "tealium", "custom"]),
+    clientName: z.optional(z.string().trim().min(1)),
+    clientVersion: z.optional(z.string().trim().min(1)),
+    integrator: z.optional(z.object({
+        name: z.optional(z.string().trim().min(1)),
+        version: z.optional(z.string().trim().min(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().trim().min(1)),
+});

package/dist/defaults.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS: readonly [
+    "class",
+    "data-theme"
+];
+//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sCAAsC,EAAE,SAAS;IAC7D,OAAO;IACP,YAAY;CACc,CAAC"}

package/dist/defaults.js

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

package/dist/host/command-settlement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-settlement.d.ts","sourceRoot":"","sources":["../../src/host/command-settlement.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,oBAAoB,EAEzB,MAAM,0BAA0B,CAAC;AAElC,KAAK,6BAA6B,GAAG;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAGF,eAAO,MAAM,+BAA+B,EAC3C,4BAAqC,CAAC;AAEvC,qBAAa,sBAAuB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEvB,KAAK,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;KACd;CAUD;AAED,KAAK,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,EAAE;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAEhF,eAAO,MAAM,wBAAwB,GACpC,QAAQ,2BAA2B,KACjC,sBAUF,CAAC;AAEF,qBAAa,6BAA8B,SAAQ,KAAK;IACvD,QAAQ,CAAC,IAAI,+BAAmC;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAK7B;AASD,eAAO,MAAM,wBAAwB,GACpC,OAAO,6BAA6B,KAClC,OAAO,CAAC,oBAAoB,CAgD9B,CAAC"}
+{"version":3,"file":"command-settlement.d.ts","sourceRoot":"","sources":["../../src/host/command-settlement.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,oBAAoB,EAEzB,MAAM,0BAA0B,CAAC;AAElC,KAAK,6BAA6B,GAAG;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAGF,eAAO,MAAM,+BAA+B,EAC3C,4BAAqC,CAAC;AAEvC,qBAAa,sBAAuB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;gBAEvB,KAAK,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;KACd;CAUD;AAED,KAAK,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,EAAE;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAEhF,eAAO,MAAM,wBAAwB,GACpC,QAAQ,2BAA2B,KACjC,sBAUF,CAAC;AAEF,qBAAa,6BAA8B,SAAQ,KAAK;IACvD,QAAQ,CAAC,IAAI,+BAAmC;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAK7B;AAKD,eAAO,MAAM,wBAAwB,GACpC,OAAO,6BAA6B,KAClC,OAAO,CAAC,oBAAoB,CAgD9B,CAAC"}

package/dist/host/command-settlement.js

@@ -37,12 +37,7 @@ export class CommandSettlementTimeoutError extends Error {
         this.requestId = requestId;
     }
 }
-const eventHasDetail = (event) => {
-    if (typeof CustomEvent !== "undefined") {
-        return event instanceof CustomEvent;
-    }
-    return typeof event === "object" && event !== null && "detail" in event;
-};
+const eventHasDetail = (event) => typeof event === "object" && event !== null && "detail" in event;
 export const waitForCommandSettlement = (input) => {
     const requestId = input.requestId;
     if (!requestId) {

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
+export { getScopeMeta, listScopes, SCOPE_IDS, type Scope, scopeIdSchema, } from "./scopes.js";
+export { type PublicCommandPayload, parseConfigureOptions, parseInitOptions, parsePublicCommand, publicCommandPayloadSchema, } from "./widget-commands.js";
+export { type ConfigureOptions, colorSchemeConfigInputSchema, configureOptionsSchema, consentConfigInputSchema, type InitOptions, initOptionsSchema, } from "./widget-config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sCAAsC,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EACN,YAAY,EACZ,UAAU,EACV,SAAS,EACT,KAAK,KAAK,EACV,aAAa,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,KAAK,oBAAoB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,KAAK,gBAAgB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,wBAAwB,EACxB,KAAK,WAAW,EAChB,iBAAiB,GACjB,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
+export { getScopeMeta, listScopes, SCOPE_IDS, scopeIdSchema, } from "./scopes.js";
+export { parseConfigureOptions, parseInitOptions, parsePublicCommand, publicCommandPayloadSchema, } from "./widget-commands.js";
+export { colorSchemeConfigInputSchema, configureOptionsSchema, consentConfigInputSchema, initOptionsSchema, } from "./widget-config.js";

package/dist/runtime-endpoints.d.ts

@@ -0,0 +1,7 @@
+import * as z from "zod";
+export declare const runtimeEndpointsSchema: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    coreUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RuntimeEndpoints = z.output<typeof runtimeEndpointsSchema>;
+//# sourceMappingURL=runtime-endpoints.d.ts.map

package/dist/runtime-endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-endpoints.d.ts","sourceRoot":"","sources":["../src/runtime-endpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,eAAO,MAAM,sBAAsB;;;kBAKzB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/runtime-endpoints.js

@@ -0,0 +1,8 @@
+import * as z from "zod";
+const absoluteUrlSchema = z.string().trim().url();
+export const runtimeEndpointsSchema = z
+    .object({
+    apiUrl: z.optional(absoluteUrlSchema),
+    coreUrl: z.optional(absoluteUrlSchema),
+})
+    .strict();

package/dist/scopes.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+export declare const SCOPE_IDS: readonly [
+    "functionality.storage",
+    "security.storage",
+    "analytics.storage",
+    "analytics.measurement",
+    "personalization.storage",
+    "ads.storage",
+    "ads.user_data",
+    "ads.personalization"
+];
+export declare const scopeIdSchema: z.ZodEnum<{
+    "functionality.storage": "functionality.storage";
+    "security.storage": "security.storage";
+    "analytics.storage": "analytics.storage";
+    "analytics.measurement": "analytics.measurement";
+    "personalization.storage": "personalization.storage";
+    "ads.storage": "ads.storage";
+    "ads.user_data": "ads.user_data";
+    "ads.personalization": "ads.personalization";
+}>;
+export type Scope = (typeof SCOPE_IDS)[number];
+export type ScopeMeta = {
+    description: string;
+};
+export declare function getScopeMeta(id: Scope): ScopeMeta;
+export declare function listScopes(): ReadonlyArray<{
+    id: Scope;
+} & ScopeMeta>;
+//# sourceMappingURL=scopes.d.ts.map

package/dist/scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../src/scopes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,SAAS,EAAE,SAAS;IAChC,uBAAuB;IACvB,kBAAkB;IAClB,mBAAmB;IACnB,uBAAuB;IACvB,yBAAyB;IACzB,aAAa;IACb,eAAe;IACf,qBAAqB;CAUrB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;EAAoB,CAAC;AAE/C,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,SAAS,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;CACpB,CAAC;AAqCF,wBAAgB,YAAY,CAAC,EAAE,EAAE,KAAK,GAAG,SAAS,CAEjD;AAED,wBAAgB,UAAU,IAAI,aAAa,CAAC;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,GAAG,SAAS,CAAC,CAKrE"}

package/dist/scopes.js

@@ -0,0 +1,47 @@
+import * as z from "zod";
+export const SCOPE_IDS = [
+    "functionality.storage",
+    "security.storage",
+    "analytics.storage",
+    "analytics.measurement",
+    "personalization.storage",
+    "ads.storage",
+    "ads.user_data",
+    "ads.personalization",
+];
+export const scopeIdSchema = z.enum(SCOPE_IDS);
+const scopeMetaById = {
+    "functionality.storage": {
+        description: "Allow essential storage for core widget behavior (e.g., frequency capping, dismissals, draft answers).",
+    },
+    "security.storage": {
+        description: "Allow storage used for fraud/abuse prevention and integrity checks.",
+    },
+    "analytics.storage": {
+        description: "Allow storage for analytics identifiers enabling consistent cross-session measurement.",
+    },
+    "analytics.measurement": {
+        description: "Allow sending analytics events; can operate without storage when needed.",
+    },
+    "personalization.storage": {
+        description: "Allow storage used to personalize the widget UI/targeting (non-ads).",
+    },
+    "ads.storage": {
+        description: "Allow storage for advertising identifiers and conversion cookies.",
+    },
+    "ads.user_data": {
+        description: "Allow sending user data to ad platforms when legally permitted.",
+    },
+    "ads.personalization": {
+        description: "Allow personalized advertising signals and interest-based targeting.",
+    },
+};
+export function getScopeMeta(id) {
+    return scopeMetaById[id];
+}
+export function listScopes() {
+    return SCOPE_IDS.map((id) => ({
+        id,
+        ...getScopeMeta(id),
+    }));
+}

package/dist/widget-commands.d.ts

@@ -0,0 +1,163 @@
+import * as z from "zod";
+import { type ConfigureOptions, type InitOptions } from "./widget-config.js";
+export declare const containerPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"floating">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hostContainer">;
+    host: z.ZodCustom<HTMLElement | null, HTMLElement | null>;
+    sharing: z.ZodEnum<{
+        shared: "shared";
+        perFlowRun: "perFlowRun";
+    }>;
+}, z.core.$strict>], "kind">;
+export declare const publicCommandPayloadSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"open">;
+    flowId: z.ZodString;
+    flowHandleId: z.ZodOptional<z.ZodString>;
+    container: z.ZodOptional<z.ZodCustom<HTMLElement, HTMLElement>>;
+    containerRequirement: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        hostOnly: "hostOnly";
+    }>>;
+    hideCloseButton: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"prefetch">;
+    flowId: z.ZodString;
+    flowHandleId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"prerender">;
+    flowId: z.ZodString;
+    flowHandleId: z.ZodOptional<z.ZodString>;
+    hideCloseButton: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"setContainer">;
+    flowHandleId: z.ZodString;
+    container: z.ZodCustom<HTMLElement | null, HTMLElement | null>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"setDefaultContainerPolicy">;
+    policy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"floating">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hostContainer">;
+        host: z.ZodCustom<HTMLElement | null, HTMLElement | null>;
+        sharing: z.ZodEnum<{
+            shared: "shared";
+            perFlowRun: "perFlowRun";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"configure">;
+    opts: z.ZodObject<{
+        colorScheme: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            autoDetectColorScheme: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+            system: "system";
+        }>]>>;
+        consent: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            granted: "granted";
+            denied: "denied";
+            pending: "pending";
+            revoked: "revoked";
+        }>, z.ZodArray<z.ZodEnum<{
+            "analytics.storage": "analytics.storage";
+            "analytics.measurement": "analytics.measurement";
+            "personalization.storage": "personalization.storage";
+            "ads.storage": "ads.storage";
+            "ads.user_data": "ads.user_data";
+            "ads.personalization": "ads.personalization";
+        }>>]>>;
+        auth: z.ZodOptional<z.ZodObject<{
+            jwt: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                token: z.ZodString;
+            }, z.core.$strip>, z.ZodNull]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"init">;
+    opts: z.ZodObject<{
+        apiKey: z.ZodString;
+        colorScheme: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            autoDetectColorScheme: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>, z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+            system: "system";
+        }>]>>;
+        disableTelemetry: z.ZodOptional<z.ZodBoolean>;
+        enableDebug: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+        defaultConsent: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            granted: "granted";
+            denied: "denied";
+            pending: "pending";
+            revoked: "revoked";
+        }>, z.ZodArray<z.ZodEnum<{
+            "analytics.storage": "analytics.storage";
+            "analytics.measurement": "analytics.measurement";
+            "personalization.storage": "personalization.storage";
+            "ads.storage": "ads.storage";
+            "ads.user_data": "ads.user_data";
+            "ads.personalization": "ads.personalization";
+        }>>]>>;
+        clientMeta: z.ZodOptional<z.ZodObject<{
+            loader: z.ZodEnum<{
+                sdk: "sdk";
+                gtm: "gtm";
+                segment: "segment";
+                rudderstack: "rudderstack";
+                tealium: "tealium";
+                custom: "custom";
+            }>;
+            clientName: z.ZodOptional<z.ZodString>;
+            clientVersion: z.ZodOptional<z.ZodString>;
+            integrator: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                loader: "loader";
+                "script-tag": "script-tag";
+                esm: "esm";
+                "tag-manager": "tag-manager";
+                snippet: "snippet";
+            }>>;
+            runtime: z.ZodOptional<z.ZodObject<{
+                framework: z.ZodOptional<z.ZodEnum<{
+                    next: "next";
+                    vite: "vite";
+                    webpack: "webpack";
+                    plain: "plain";
+                }>>;
+                runtime: z.ZodOptional<z.ZodEnum<{
+                    browser: "browser";
+                    edge: "edge";
+                }>>;
+            }, z.core.$strip>>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        runtimeEndpoints: z.ZodOptional<z.ZodObject<{
+            apiUrl: z.ZodOptional<z.ZodString>;
+            coreUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"close">;
+    flowHandleId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reset">;
+}, z.core.$strict>], "kind">, z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"identify">;
+    traits: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"identify">;
+    userId: z.ZodString;
+    traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>]>]>;
+export type PublicCommandPayload = z.output<typeof publicCommandPayloadSchema>;
+export type ContainerPolicy = z.output<typeof containerPolicySchema>;
+export declare function parseInitOptions(input: unknown): InitOptions;
+export declare function parseConfigureOptions(input: unknown): ConfigureOptions;
+export declare function parsePublicCommand(input: unknown): PublicCommandPayload;
+//# sourceMappingURL=widget-commands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"widget-commands.d.ts","sourceRoot":"","sources":["../src/widget-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,WAAW,EAEhB,MAAM,oBAAoB,CAAC;AAkD5B,eAAO,MAAM,qBAAqB;;;;;;;;;4BAahC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAiErC,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

@@ -0,0 +1,130 @@
+import * as z from "zod";
+import { configureOptionsSchema, initOptionsSchema, } from "./widget-config.js";
+const flowHandleIdSchema = z.string().trim().min(1);
+const flowIdSchema = z.string().trim().min(1);
+const isHTMLElementLike = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (typeof HTMLElement !== "undefined" && value instanceof HTMLElement) {
+        return true;
+    }
+    if (!("nodeType" in value) || !("appendChild" in value)) {
+        return false;
+    }
+    const nodeType = Reflect.get(value, "nodeType");
+    const appendChild = Reflect.get(value, "appendChild");
+    return nodeType === 1 && typeof appendChild === "function";
+};
+const htmlElementSchema = z.custom(isHTMLElementLike, {
+    message: "Container must be an HTMLElement with nodeType=1",
+});
+const htmlElementOrNullSchema = z.custom((value) => value === null || isHTMLElementLike(value), {
+    message: "Container must be null or an HTMLElement with nodeType=1",
+});
+const identifyTraitsSchema = z.record(z.string(), z.unknown());
+const identifyPayloadSchema = z.union([
+    z
+        .object({
+        kind: z.literal("identify"),
+        traits: identifyTraitsSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("identify"),
+        userId: z.string().trim().min(1),
+        traits: z.optional(identifyTraitsSchema),
+    })
+        .strict(),
+]);
+const legacyContainerRequirementSchema = z.enum(["any", "hostOnly"]);
+export const containerPolicySchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("floating"),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("hostContainer"),
+        host: htmlElementOrNullSchema,
+        sharing: z.enum(["shared", "perFlowRun"]),
+    })
+        .strict(),
+]);
+export const publicCommandPayloadSchema = z.union([
+    z.discriminatedUnion("kind", [
+        z
+            .object({
+            kind: z.literal("open"),
+            flowId: flowIdSchema,
+            flowHandleId: z.optional(flowHandleIdSchema),
+            container: z.optional(htmlElementSchema),
+            containerRequirement: z.optional(legacyContainerRequirementSchema),
+            hideCloseButton: z.optional(z.boolean()),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("prefetch"),
+            flowId: flowIdSchema,
+            flowHandleId: z.optional(flowHandleIdSchema),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("prerender"),
+            flowId: flowIdSchema,
+            flowHandleId: z.optional(flowHandleIdSchema),
+            hideCloseButton: z.optional(z.boolean()),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("setContainer"),
+            flowHandleId: flowHandleIdSchema,
+            container: htmlElementOrNullSchema,
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("setDefaultContainerPolicy"),
+            policy: containerPolicySchema,
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("configure"),
+            opts: configureOptionsSchema,
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("init"),
+            opts: initOptionsSchema,
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("close"),
+            flowHandleId: z.optional(flowHandleIdSchema),
+        })
+            .strict(),
+        z
+            .object({
+            kind: z.literal("reset"),
+        })
+            .strict(),
+    ]),
+    identifyPayloadSchema,
+]);
+export function parseInitOptions(input) {
+    return initOptionsSchema.parse(input);
+}
+export function parseConfigureOptions(input) {
+    return configureOptionsSchema.parse(input);
+}
+export function parsePublicCommand(input) {
+    return publicCommandPayloadSchema.parse(input);
+}

package/dist/widget-config.d.ts

@@ -0,0 +1,126 @@
+import * as z from "zod";
+export declare const colorSchemeConfigInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    autoDetectColorScheme: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodEnum<{
+    light: "light";
+    dark: "dark";
+    system: "system";
+}>]>;
+export type ColorSchemeConfigInput = z.output<typeof colorSchemeConfigInputSchema>;
+export declare const consentConfigInputSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    granted: "granted";
+    denied: "denied";
+    pending: "pending";
+    revoked: "revoked";
+}>, z.ZodArray<z.ZodEnum<{
+    "analytics.storage": "analytics.storage";
+    "analytics.measurement": "analytics.measurement";
+    "personalization.storage": "personalization.storage";
+    "ads.storage": "ads.storage";
+    "ads.user_data": "ads.user_data";
+    "ads.personalization": "ads.personalization";
+}>>]>;
+export type ConsentConfigInput = z.output<typeof consentConfigInputSchema>;
+export declare const debugInputSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>;
+export declare const authConfigInputSchema: z.ZodObject<{
+    jwt: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        token: z.ZodString;
+    }, z.core.$strip>, z.ZodNull]>>;
+}, z.core.$strip>;
+export declare const configureOptionsSchema: z.ZodObject<{
+    colorScheme: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        autoDetectColorScheme: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+        system: "system";
+    }>]>>;
+    consent: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        granted: "granted";
+        denied: "denied";
+        pending: "pending";
+        revoked: "revoked";
+    }>, z.ZodArray<z.ZodEnum<{
+        "analytics.storage": "analytics.storage";
+        "analytics.measurement": "analytics.measurement";
+        "personalization.storage": "personalization.storage";
+        "ads.storage": "ads.storage";
+        "ads.user_data": "ads.user_data";
+        "ads.personalization": "ads.personalization";
+    }>>]>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        jwt: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>, z.ZodNull]>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ConfigureOptions = z.output<typeof configureOptionsSchema>;
+export declare const initOptionsSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    colorScheme: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        autoDetectColorScheme: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+        system: "system";
+    }>]>>;
+    disableTelemetry: z.ZodOptional<z.ZodBoolean>;
+    enableDebug: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+    defaultConsent: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        granted: "granted";
+        denied: "denied";
+        pending: "pending";
+        revoked: "revoked";
+    }>, z.ZodArray<z.ZodEnum<{
+        "analytics.storage": "analytics.storage";
+        "analytics.measurement": "analytics.measurement";
+        "personalization.storage": "personalization.storage";
+        "ads.storage": "ads.storage";
+        "ads.user_data": "ads.user_data";
+        "ads.personalization": "ads.personalization";
+    }>>]>>;
+    clientMeta: z.ZodOptional<z.ZodObject<{
+        loader: z.ZodEnum<{
+            sdk: "sdk";
+            gtm: "gtm";
+            segment: "segment";
+            rudderstack: "rudderstack";
+            tealium: "tealium";
+            custom: "custom";
+        }>;
+        clientName: z.ZodOptional<z.ZodString>;
+        clientVersion: z.ZodOptional<z.ZodString>;
+        integrator: z.ZodOptional<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        transport: z.ZodOptional<z.ZodEnum<{
+            loader: "loader";
+            "script-tag": "script-tag";
+            esm: "esm";
+            "tag-manager": "tag-manager";
+            snippet: "snippet";
+        }>>;
+        runtime: z.ZodOptional<z.ZodObject<{
+            framework: z.ZodOptional<z.ZodEnum<{
+                next: "next";
+                vite: "vite";
+                webpack: "webpack";
+                plain: "plain";
+            }>>;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                browser: "browser";
+                edge: "edge";
+            }>>;
+        }, z.core.$strip>>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    runtimeEndpoints: z.ZodOptional<z.ZodObject<{
+        apiUrl: z.ZodOptional<z.ZodString>;
+        coreUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type InitOptions = z.output<typeof initOptionsSchema>;
+export declare const DEFAULT_COLOR_SCHEME_CONFIG: ColorSchemeConfigInput;
+//# sourceMappingURL=widget-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"widget-config.d.ts","sourceRoot":"","sources":["../src/widget-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AA6BzB,eAAO,MAAM,4BAA4B;;;;;;IAOvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,4BAA4B,CACnC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;KAGnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E,eAAO,MAAM,gBAAgB,2EAI3B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;iBAShC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMzB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWpB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7D,eAAO,MAAM,2BAA2B,EAAE,sBAEzC,CAAC"}

package/dist/widget-config.js

@@ -0,0 +1,64 @@
+import * as z from "zod";
+import { clientMetaSchema } from "./client-meta.js";
+import { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
+import { runtimeEndpointsSchema } from "./runtime-endpoints.js";
+const colorSchemeValueSchema = z.enum(["light", "dark", "system"]);
+const autoDetectColorSchemeArraySchema = z
+    .array(z.string().trim().min(1))
+    .min(1);
+const publicGrantScopeIds = [
+    "analytics.storage",
+    "analytics.measurement",
+    "personalization.storage",
+    "ads.storage",
+    "ads.user_data",
+    "ads.personalization",
+];
+const publicGrantScopeIdSchema = z.enum(publicGrantScopeIds);
+export const colorSchemeConfigInputSchema = z.union([
+    z
+        .object({
+        autoDetectColorScheme: autoDetectColorSchemeArraySchema,
+    })
+        .strict(),
+    colorSchemeValueSchema,
+]);
+export const consentConfigInputSchema = z.union([
+    z.enum(["granted", "denied", "pending", "revoked"]),
+    z.array(publicGrantScopeIdSchema),
+]);
+export const debugInputSchema = z.union([
+    z.boolean(),
+    z.string(),
+    z.array(z.string()),
+]);
+export const authConfigInputSchema = z.object({
+    jwt: z.optional(z.union([
+        z.object({
+            token: z.string().trim().min(1),
+        }),
+        z.null(),
+    ])),
+});
+export const configureOptionsSchema = z
+    .object({
+    colorScheme: z.optional(colorSchemeConfigInputSchema),
+    consent: z.optional(consentConfigInputSchema),
+    auth: z.optional(authConfigInputSchema),
+})
+    .strict();
+export const initOptionsSchema = z
+    .object({
+    apiKey: z.string().trim().min(1),
+    colorScheme: z.optional(colorSchemeConfigInputSchema),
+    disableTelemetry: z.optional(z.boolean()),
+    enableDebug: z.optional(debugInputSchema),
+    defaultConsent: z.optional(consentConfigInputSchema),
+    clientMeta: z.optional(clientMetaSchema),
+    capabilities: z.optional(z.array(z.string())),
+    runtimeEndpoints: z.optional(runtimeEndpointsSchema),
+})
+    .strict();
+export const DEFAULT_COLOR_SCHEME_CONFIG = {
+    autoDetectColorScheme: [...DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getuserfeedback/protocol",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "getuserfeedback widget protocol — host surface and (later) wire protocol",
 	"keywords": [
 		"getuserfeedback",
@@ -17,6 +17,10 @@
 		"dist"
 	],
 	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
 		"./host": {
 			"types": "./dist/host/index.d.ts",
 			"import": "./dist/host/index.js"
@@ -62,10 +66,14 @@
 		"lint": "ultracite check .",
 		"build": "bun x rimraf dist tsconfig.tsbuildinfo && tsc -b tsconfig.json",
 		"typecheck": "tsc -b tsconfig.json",
+		"test": "bun test --dots",
 		"pack:verify": "node ../../scripts/pack-and-verify.cjs",
 		"publish:dry-run": "node ../../scripts/publish-package.cjs . -- --dry-run",
 		"publish:npm": "node ../../scripts/publish-package.cjs ."
 	},
+	"dependencies": {
+		"zod": "^4.2.1"
+	},
 	"devDependencies": {
 		"rimraf": "^6.0.0",
 		"typescript": "^5.8.3"