@getuserfeedback/protocol 3.0.14 → 3.1.1

package/dist/attention-policy.d.ts

@@ -9,7 +9,7 @@ export declare const attentionExclusiveSurfaceStrategySchema: z.ZodMiniEnum<{
 export declare const attentionBlockedBroadcastStrategySchema: z.ZodMiniEnum<{
     queue: "queue";
 }>;
-export declare const attentionPolicyConfigSchema: z.ZodMiniObject<{
+export declare const legacyAttentionPolicyConfigSchema: z.ZodMiniObject<{
     version: z.ZodMiniString<string>;
     source: z.ZodMiniEnum<{
         default: "default";
@@ -23,6 +23,21 @@ export declare const attentionPolicyConfigSchema: z.ZodMiniObject<{
         queue: "queue";
     }>;
 }, z.core.$strict>;
+export declare const attentionPolicyConfigSchema: z.ZodMiniObject<{
+    recentInAppCooldownMs: z.ZodMiniDefault<z.ZodMiniNumber<number>>;
+    version: z.ZodMiniString<string>;
+    source: z.ZodMiniEnum<{
+        default: "default";
+        custom: "custom";
+    }>;
+    recentFlowCooldownMs: z.ZodMiniNumber<number>;
+    exclusiveSurfaceStrategy: z.ZodMiniEnum<{
+        queue: "queue";
+    }>;
+    blockedBroadcastStrategy: z.ZodMiniEnum<{
+        queue: "queue";
+    }>;
+}, z.core.$loose>;
 export type AttentionPolicyConfig = z.output<typeof attentionPolicyConfigSchema>;
 export declare const DEFAULT_ATTENTION_POLICY_CONFIG: AttentionPolicyConfig;
 //# sourceMappingURL=attention-policy.d.ts.map

package/dist/attention-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attention-policy.d.ts","sourceRoot":"","sources":["../src/attention-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,2BAA2B;;;EAAgC,CAAC;AAEzE,eAAO,MAAM,uCAAuC;;EAAoB,CAAC;AAEzE,eAAO,MAAM,uCAAuC;;EAAoB,CAAC;AAEzE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;kBAMtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,2BAA2B,CAClC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,qBAM7C,CAAC"}
+{"version":3,"file":"attention-policy.d.ts","sourceRoot":"","sources":["../src/attention-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,2BAA2B;;;EAAgC,CAAC;AAEzE,eAAO,MAAM,uCAAuC;;EAAoB,CAAC;AAEzE,eAAO,MAAM,uCAAuC;;EAAoB,CAAC;AAUzE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;kBAE7C,CAAC;AAKF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAGtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,2BAA2B,CAClC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,qBAO7C,CAAC"}

package/dist/attention-policy.js

@@ -2,17 +2,26 @@ import * as z from "zod/mini";
 export const attentionPolicySourceSchema = z.enum(["default", "custom"]);
 export const attentionExclusiveSurfaceStrategySchema = z.enum(["queue"]);
 export const attentionBlockedBroadcastStrategySchema = z.enum(["queue"]);
-export const attentionPolicyConfigSchema = z.strictObject({
+const legacyAttentionPolicyConfigFields = {
     version: z.string().check(z.trim(), z.minLength(1)),
     source: attentionPolicySourceSchema,
     recentFlowCooldownMs: z.number().check(z.positive()),
     exclusiveSurfaceStrategy: attentionExclusiveSurfaceStrategySchema,
     blockedBroadcastStrategy: attentionBlockedBroadcastStrategySchema,
+};
+export const legacyAttentionPolicyConfigSchema = z.strictObject(legacyAttentionPolicyConfigFields);
+// V2 is the additive policy envelope for the flow-display wire contract.
+// Keep legacy strict, and add future policy controls here instead of creating
+// another versioned sibling field for every new setting.
+export const attentionPolicyConfigSchema = z.looseObject({
+    ...legacyAttentionPolicyConfigFields,
+    recentInAppCooldownMs: z._default(z.number().check(z.nonnegative()), 0),
 });
 export const DEFAULT_ATTENTION_POLICY_CONFIG = {
     version: "attention-policy-default-v1",
     source: "default",
     recentFlowCooldownMs: 5 * 60 * 1000,
+    recentInAppCooldownMs: 0,
     exclusiveSurfaceStrategy: "queue",
     blockedBroadcastStrategy: "queue",
 };

package/dist/core-command-envelope.d.ts

@@ -42,7 +42,7 @@ export declare const coreCommandEnvelopeSchema: z.ZodMiniObject<{
         }, z.core.$strip>>;
         notes: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strip>>;
-    command: z.ZodMiniUnion<readonly [z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+    command: z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         kind: z.ZodMiniLiteral<"open">;
         flowId: z.ZodMiniString<string>;
         flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -51,15 +51,53 @@ export declare const coreCommandEnvelopeSchema: z.ZodMiniObject<{
         }, z.core.$strict>>;
         hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>, z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"open">;
+        flow: z.ZodMiniObject<{
+            definition: z.ZodMiniUnknown;
+            theme: z.ZodMiniOptional<z.ZodMiniObject<{
+                css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        metadata: z.ZodMiniOptional<z.ZodMiniObject<{
+            tags: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>>;
+        }, z.core.$strict>>;
+        hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strict>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         kind: z.ZodMiniLiteral<"prefetch">;
         flowId: z.ZodMiniString<string>;
         flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strict>, z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"prefetch">;
+        flow: z.ZodMiniObject<{
+            definition: z.ZodMiniUnknown;
+            theme: z.ZodMiniOptional<z.ZodMiniObject<{
+                css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strict>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         kind: z.ZodMiniLiteral<"prerender">;
         flowId: z.ZodMiniString<string>;
         flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
         hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     }, z.core.$strict>, z.ZodMiniObject<{
+        kind: z.ZodMiniLiteral<"prerender">;
+        flow: z.ZodMiniObject<{
+            definition: z.ZodMiniUnknown;
+            theme: z.ZodMiniOptional<z.ZodMiniObject<{
+                css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strict>]>, z.ZodMiniObject<{
         kind: z.ZodMiniLiteral<"hostContextUpdated">;
         context: z.ZodMiniObject<{
             url: z.ZodMiniString<string>;
@@ -346,7 +384,7 @@ export declare const coreCommandEnvelopeSchema: z.ZodMiniObject<{
                 debug: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             }, z.core.$strip>;
         }, z.core.$strip>;
-    }, z.core.$strip>], "kind">, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    }, z.core.$strip>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         kind: z.ZodMiniLiteral<"identify">;
         traits: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
         options: z.ZodMiniOptional<z.ZodMiniObject<{

package/dist/core-command-envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core-command-envelope.d.ts","sourceRoot":"","sources":["../src/core-command-envelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAC9B,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AAOrE,sEAAsE;AACtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,wEAAwE;AACxE,MAAM,MAAM,cAAc,GAAG;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;CACxB,CAAC"}
+{"version":3,"file":"core-command-envelope.d.ts","sourceRoot":"","sources":["../src/core-command-envelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAC9B,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AAOrE,sEAAsE;AACtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,wEAAwE;AACxE,MAAM,MAAM,cAAc,GAAG;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;CACxB,CAAC"}

package/dist/core-commands.d.ts

@@ -1,5 +1,5 @@
 import * as z from "zod/mini";
-export declare const coreCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+export declare const coreCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"open">;
     flowId: z.ZodMiniString<string>;
     flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -8,15 +8,53 @@ export declare const coreCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodMin
     }, z.core.$strict>>;
     hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
 }, z.core.$strict>, z.ZodMiniObject<{
+    kind: z.ZodMiniLiteral<"open">;
+    flow: z.ZodMiniObject<{
+        definition: z.ZodMiniUnknown;
+        theme: z.ZodMiniOptional<z.ZodMiniObject<{
+            css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniObject<{
+        tags: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>>;
+    }, z.core.$strict>>;
+    hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"prefetch">;
     flowId: z.ZodMiniString<string>;
     flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
 }, z.core.$strict>, z.ZodMiniObject<{
+    kind: z.ZodMiniLiteral<"prefetch">;
+    flow: z.ZodMiniObject<{
+        definition: z.ZodMiniUnknown;
+        theme: z.ZodMiniOptional<z.ZodMiniObject<{
+            css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strict>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"prerender">;
     flowId: z.ZodMiniString<string>;
     flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
     hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
 }, z.core.$strict>, z.ZodMiniObject<{
+    kind: z.ZodMiniLiteral<"prerender">;
+    flow: z.ZodMiniObject<{
+        definition: z.ZodMiniUnknown;
+        theme: z.ZodMiniOptional<z.ZodMiniObject<{
+            css: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeRuntimeArtifactId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            themeVersionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    flowHandleId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    hideCloseButton: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>]>, z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"hostContextUpdated">;
     context: z.ZodMiniObject<{
         url: z.ZodMiniString<string>;
@@ -303,7 +341,7 @@ export declare const coreCommandPayloadSchema: z.ZodMiniUnion<readonly [z.ZodMin
             debug: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
-}, z.core.$strip>], "kind">, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+}, z.core.$strip>]>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
     kind: z.ZodMiniLiteral<"identify">;
     traits: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
     options: z.ZodMiniOptional<z.ZodMiniObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"core-commands.d.ts","sourceRoot":"","sources":["../src/core-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA6J9B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAInC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"core-commands.d.ts","sourceRoot":"","sources":["../src/core-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA8M9B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAInC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/core-commands.js

@@ -41,19 +41,56 @@ const prefetchPayloadSchema = z.strictObject({
     flowId: flowIdSchema,
     flowHandleId: z.optional(flowHandleIdSchema),
 });
-const openCorePayloadSchema = z.strictObject({
+const inlineFlowThemeSchema = z.strictObject({
+    css: z.optional(z.string()),
+    themeRuntimeArtifactId: z.optional(z.string().check(z.trim(), z.minLength(1))),
+    themeVersionId: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+const inlineFlowSchema = z.strictObject({
+    definition: z.unknown().check(z.check((ctx) => {
+        if (ctx.value !== undefined) {
+            return;
+        }
+        ctx.issues.push({
+            code: "custom",
+            input: ctx.value,
+            message: "Inline flow definition is required.",
+            continue: false,
+        });
+    })),
+    theme: z.optional(inlineFlowThemeSchema),
+});
+const prefetchInlinePayloadSchema = z.strictObject({
+    kind: z.literal("prefetch"),
+    flow: inlineFlowSchema,
+    flowHandleId: z.optional(flowHandleIdSchema),
+});
+const openPersistedCorePayloadSchema = z.strictObject({
     kind: z.literal("open"),
     flowId: flowIdSchema,
     flowHandleId: z.optional(flowHandleIdSchema),
     metadata: z.optional(responseMetadataInputSchema),
     hideCloseButton: z.optional(z.boolean()),
 });
-const prerenderCorePayloadSchema = z.strictObject({
+const openInlineCorePayloadSchema = z.strictObject({
+    kind: z.literal("open"),
+    flow: inlineFlowSchema,
+    flowHandleId: z.optional(flowHandleIdSchema),
+    metadata: z.optional(responseMetadataInputSchema),
+    hideCloseButton: z.optional(z.boolean()),
+});
+const prerenderPersistedCorePayloadSchema = z.strictObject({
     kind: z.literal("prerender"),
     flowId: flowIdSchema,
     flowHandleId: z.optional(flowHandleIdSchema),
     hideCloseButton: z.optional(z.boolean()),
 });
+const prerenderInlineCorePayloadSchema = z.strictObject({
+    kind: z.literal("prerender"),
+    flow: inlineFlowSchema,
+    flowHandleId: z.optional(flowHandleIdSchema),
+    hideCloseButton: z.optional(z.boolean()),
+});
 const closeCorePayloadSchema = z.object({
     kind: z.literal("close"),
     flowHandleId: z.optional(flowHandleIdSchema),
@@ -108,10 +145,13 @@ const initCorePayloadSchema = z.strictObject({
 const resetPayloadSchema = z.object({
     kind: z.literal("reset"),
 });
-const coreCommandPayloadWithoutIdentifySchema = z.discriminatedUnion("kind", [
-    openCorePayloadSchema,
-    prefetchPayloadSchema,
-    prerenderCorePayloadSchema,
+const coreCommandPayloadWithoutIdentifySchema = z.union([
+    z.union([openPersistedCorePayloadSchema, openInlineCorePayloadSchema]),
+    z.union([prefetchPayloadSchema, prefetchInlinePayloadSchema]),
+    z.union([
+        prerenderPersistedCorePayloadSchema,
+        prerenderInlineCorePayloadSchema,
+    ]),
     hostContextUpdatedPayloadSchema,
     hostSignalPayloadSchema,
     setTargetingPlanPayloadSchema,

package/dist/flow-display.d.ts

@@ -214,6 +214,21 @@ export declare const flowDisplaySyncResponseSchema: z.ZodMiniObject<{
             queue: "queue";
         }>;
     }, z.core.$strict>>;
+    attentionPolicyV2: z.ZodMiniOptional<z.ZodMiniObject<{
+        recentInAppCooldownMs: z.ZodMiniDefault<z.ZodMiniNumber<number>>;
+        version: z.ZodMiniString<string>;
+        source: z.ZodMiniEnum<{
+            default: "default";
+            custom: "custom";
+        }>;
+        recentFlowCooldownMs: z.ZodMiniNumber<number>;
+        exclusiveSurfaceStrategy: z.ZodMiniEnum<{
+            queue: "queue";
+        }>;
+        blockedBroadcastStrategy: z.ZodMiniEnum<{
+            queue: "queue";
+        }>;
+    }, z.core.$loose>>;
     assignments: z.ZodMiniObject<{
         claimed: z.ZodMiniArray<z.ZodMiniObject<{
             flowAssignmentId: z.ZodMiniString<string>;
@@ -288,4 +303,5 @@ export type RuntimeDisplayTrigger = z.output<typeof runtimeDisplayTriggerSchema>
 export type FlowDisplaySyncRequest = z.output<typeof flowDisplaySyncRequestSchema>;
 export type FlowDisplaySyncResponse = z.output<typeof flowDisplaySyncResponseSchema>;
 export type FlowDisplayAttentionPolicyConfig = AttentionPolicyConfig;
+export declare const resolveFlowDisplayAttentionPolicyConfig: (displaySync: Pick<FlowDisplaySyncResponse, "attentionPolicy" | "attentionPolicyV2">) => FlowDisplayAttentionPolicyConfig | undefined;
 //# sourceMappingURL=flow-display.d.ts.map

package/dist/flow-display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flow-display.d.ts","sourceRoot":"","sources":["../src/flow-display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EACN,KAAK,qBAAqB,EAE1B,MAAM,uBAAuB,CAAC;AAO/B,eAAO,MAAM,+BAA+B;;;;;iBAU1C,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;2BAOtC,CAAC;AAQH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;iBAY9C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAenD,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGzC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOxC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,8BAA8B,CACrC,CAAC;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CACxD,OAAO,wCAAwC,CAC/C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CACnD,OAAO,mCAAmC,CAC1C,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC/C,OAAO,+BAA+B,CACtC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,2BAA2B,CAClC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,4BAA4B,CACnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,6BAA6B,CACpC,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,qBAAqB,CAAC"}
+{"version":3,"file":"flow-display.d.ts","sourceRoot":"","sources":["../src/flow-display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EACN,KAAK,qBAAqB,EAG1B,MAAM,uBAAuB,CAAC;AAO/B,eAAO,MAAM,+BAA+B;;;;;iBAU1C,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;2BAOtC,CAAC;AAQH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;iBAY9C,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAenD,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGzC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQxC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,8BAA8B,CACrC,CAAC;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,MAAM,CACxD,OAAO,wCAAwC,CAC/C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CACnD,OAAO,mCAAmC,CAC1C,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC/C,OAAO,+BAA+B,CACtC,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,2BAA2B,CAClC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,4BAA4B,CACnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,6BAA6B,CACpC,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,qBAAqB,CAAC;AAErE,eAAO,MAAM,uCAAuC,GACnD,aAAa,IAAI,CAChB,uBAAuB,EACvB,iBAAiB,GAAG,mBAAmB,CACvC,KACC,gCAAgC,GAAG,SAkBrC,CAAC"}

package/dist/flow-display.js

@@ -1,5 +1,5 @@
 import * as z from "zod/mini";
-import { attentionPolicyConfigSchema, } from "./attention-policy.js";
+import { attentionPolicyConfigSchema, legacyAttentionPolicyConfigSchema, } from "./attention-policy.js";
 import { flowAssignmentIdentitySchema, flowAssignmentRecordSchema, flowAssignmentTargetingContextSchema, } from "./flow-assignments.js";
 export const runtimeDisplayEligibilitySchema = z.object({
     requiredCapabilities: z._default(z.array(z.string().check(z.trim(), z.minLength(1))), []),
@@ -56,9 +56,27 @@ export const flowDisplaySyncRequestSchema = z.object({
 });
 export const flowDisplaySyncResponseSchema = z.object({
     fetchedAt: z.string(),
-    attentionPolicy: z.optional(attentionPolicyConfigSchema),
+    attentionPolicy: z.optional(legacyAttentionPolicyConfigSchema),
+    attentionPolicyV2: z.optional(attentionPolicyConfigSchema),
     assignments: z.object({
         claimed: z.array(flowAssignmentRecordSchema),
     }),
     broadcasts: runtimeDisplayBroadcastsSchema,
 });
+export const resolveFlowDisplayAttentionPolicyConfig = (displaySync) => {
+    const policy = displaySync.attentionPolicyV2 ?? displaySync.attentionPolicy;
+    if (!policy) {
+        return undefined;
+    }
+    return {
+        version: policy.version,
+        source: policy.source,
+        recentFlowCooldownMs: policy.recentFlowCooldownMs,
+        recentInAppCooldownMs: "recentInAppCooldownMs" in policy &&
+            typeof policy.recentInAppCooldownMs === "number"
+            ? policy.recentInAppCooldownMs
+            : 0,
+        exclusiveSurfaceStrategy: policy.exclusiveSurfaceStrategy,
+        blockedBroadcastStrategy: policy.blockedBroadcastStrategy,
+    };
+};

package/dist/host/lazy-handle-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy-handle-client.d.ts","sourceRoot":"","sources":["../../src/host/lazy-handle-client.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,CAAC,SAAS,SAAS,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;AAC1E,KAAK,eAAe,CAAC,MAAM,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAEtE,KAAK,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,aAAa,CAAC;AAChE,KAAK,QAAQ,CAAC,MAAM,SAAS,MAAM,IAAI;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACpB,CAAC;AAQF,MAAM,MAAM,gBAAgB,CAC3B,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,GAAG,cAAc,IACnC;IACH,UAAU,CAAC,QAAQ,EAClB,YAAY,EAAE,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,KAAK,QAAQ,EAC3D,eAAe,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,WAAW,CAAC,GAC1D,OAAO,CAAC,WAAW,CAAC,CAAC;IACxB,WAAW,IAAI,SAAS,GAAG,SAAS,CAAC;IACrC,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC/D,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC;IAChE,KAAK,IAAI,IAAI,CAAC;IACd,UAAU,IAAI,IAAI,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,6BAA6B,CACxC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,GAAG,cAAc,IACnC;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,KAAK,oCAAoC,CACxC,SAAS,SAAS,MAAM,EACxB,WAAW,IACR;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,KAAK,mCAAmC,CACvC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,IAClB;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAsHF,wBAAgB,sBAAsB,CAAC,SAAS,SAAS,MAAM,EAAE,WAAW,EAC3E,OAAO,EAAE,oCAAoC,CAAC,SAAS,EAAE,WAAW,CAAC,GACnE,gBAAgB,CAAC,SAAS,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC5D,wBAAgB,sBAAsB,CACrC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,EAErB,OAAO,EAAE,mCAAmC,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,GAC1E,gBAAgB,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC"}
+{"version":3,"file":"lazy-handle-client.d.ts","sourceRoot":"","sources":["../../src/host/lazy-handle-client.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,CAAC,SAAS,SAAS,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;AAC1E,KAAK,eAAe,CAAC,MAAM,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAEtE,KAAK,cAAc,GAAG,eAAe,GAAG,OAAO,GAAG,aAAa,CAAC;AAChE,KAAK,QAAQ,CAAC,MAAM,SAAS,MAAM,IAAI;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;CACpB,CAAC;AAQF,MAAM,MAAM,gBAAgB,CAC3B,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,GAAG,cAAc,IACnC;IACH,UAAU,CAAC,QAAQ,EAClB,YAAY,EAAE,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,KAAK,QAAQ,EAC3D,eAAe,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,WAAW,CAAC,GAC1D,OAAO,CAAC,WAAW,CAAC,CAAC;IACxB,WAAW,IAAI,SAAS,GAAG,SAAS,CAAC;IACrC,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,MAAM,IAAI,CAAC;IAC/D,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC;IAChE,KAAK,IAAI,IAAI,CAAC;IACd,UAAU,IAAI,IAAI,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,6BAA6B,CACxC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,GAAG,cAAc,IACnC;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,KAAK,oCAAoC,CACxC,SAAS,SAAS,MAAM,EACxB,WAAW,IACR;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,YAAY,CAAC,EAAE,cAAc,CAAC;IAC9B,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,KAAK,mCAAmC,CACvC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,IAClB;IACH,yBAAyB,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,SAAS,GAAG,SAAS,CAAC;IAC9E,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAuHF,wBAAgB,sBAAsB,CAAC,SAAS,SAAS,MAAM,EAAE,WAAW,EAC3E,OAAO,EAAE,oCAAoC,CAAC,SAAS,EAAE,WAAW,CAAC,GACnE,gBAAgB,CAAC,SAAS,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;AAC5D,wBAAgB,sBAAsB,CACrC,SAAS,SAAS,MAAM,EACxB,WAAW,EACX,MAAM,SAAS,MAAM,EAErB,OAAO,EAAE,mCAAmC,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,GAC1E,gBAAgB,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC"}

package/dist/host/lazy-handle-client.js

@@ -11,7 +11,7 @@ const DEFAULT_LIFECYCLE_STAGES = {
 const createLazyHandleClientWithStages = (input) => {
     let handleId;
     let tail = Promise.resolve();
-    let isIdle = true;
+    let queuedCommandCount = 0;
     let epoch = 0;
     const { stages } = input;
     let stage = input.initialStage ?? stages.uninitialized;
@@ -53,12 +53,12 @@ const createLazyHandleClientWithStages = (input) => {
             }
             return settlement;
         };
-        const run = isIdle ? execute() : tail.then(execute, execute);
-        isIdle = false;
+        const run = queuedCommandCount === 0 ? execute() : tail.then(execute, execute);
+        queuedCommandCount += 1;
         tail = run.then(() => {
-            isIdle = true;
+            queuedCommandCount -= 1;
         }, () => {
-            isIdle = true;
+            queuedCommandCount -= 1;
         });
         return run;
     };

package/dist/index.d.ts

@@ -7,8 +7,9 @@ export { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
 export type { ErrorEvent, ProtocolErrorCode } from "./errors.js";
 export { ErrorCategory, ErrorCategorySchema, ErrorEventSchema, ProtocolError, } from "./errors.js";
 export { type ClaimPendingFlowAssignmentsRequest, type ClaimPendingFlowAssignmentsResponse, claimPendingFlowAssignmentsRequestSchema, claimPendingFlowAssignmentsResponseSchema, type FlowAssignmentExternalIdIdentityTypeValue, type FlowAssignmentIdentityTypeValue, type FlowAssignmentRecipientRequest, type FlowAssignmentRecord, type FlowAssignmentStatus, type FlowAssignmentTargetingContext, flowAssignmentRecipientRequestSchema, flowAssignmentRecordSchema, flowAssignmentStatusSchema, flowAssignmentTargetingContextSchema, type ListPendingFlowAssignmentsResponse, listPendingFlowAssignmentsResponseSchema, nullableUpdateFlowAssignmentLifecycleResponseSchema, type ReleaseFlowAssignmentClaimRequest, type ReleaseFlowAssignmentClaimResponse, releaseFlowAssignmentClaimRequestSchema, releaseFlowAssignmentClaimResponseSchema, type UpdateFlowAssignmentLifecycleRequest, type UpdateFlowAssignmentLifecycleResponse, updateFlowAssignmentLifecycleRequestSchema, updateFlowAssignmentLifecycleResponseSchema, } from "./flow-assignments.js";
-export { type FlowDisplaySyncRequest, type FlowDisplaySyncResponse, flowDisplaySyncRequestSchema, flowDisplaySyncResponseSchema, type RuntimeDisplayAttentionPolicy, type RuntimeDisplayBroadcastOpportunity, type RuntimeDisplayBroadcasts, type RuntimeDisplayEligibility, type RuntimeDisplayTrigger, runtimeDisplayAttentionPolicySchema, runtimeDisplayBroadcastOpportunitySchema, runtimeDisplayBroadcastsSchema, runtimeDisplayEligibilitySchema, runtimeDisplayTriggerSchema, } from "./flow-display.js";
+export { type FlowDisplaySyncRequest, type FlowDisplaySyncResponse, flowDisplaySyncRequestSchema, flowDisplaySyncResponseSchema, type RuntimeDisplayAttentionPolicy, type RuntimeDisplayBroadcastOpportunity, type RuntimeDisplayBroadcasts, type RuntimeDisplayEligibility, type RuntimeDisplayTrigger, resolveFlowDisplayAttentionPolicyConfig, runtimeDisplayAttentionPolicySchema, runtimeDisplayBroadcastOpportunitySchema, runtimeDisplayBroadcastsSchema, runtimeDisplayEligibilitySchema, runtimeDisplayTriggerSchema, } from "./flow-display.js";
 export { buildIdentityTypeGuidanceMessage, getIdentityTypeSuggestion, IDENTITY_TYPE_VALUES, type IdentityTypeValue, isIdentityTypeValue, type StandardIdentityTypeValue, } from "./identity-type.js";
+export { type CaptureInstanceFeedbackRequest, type CaptureInstanceFeedbackResponse, captureInstanceFeedbackRequestSchema, captureInstanceFeedbackResponseSchema, type InstanceFeedbackDataType, type InstanceFeedbackValence, instanceFeedbackDataTypeSchema, instanceFeedbackValenceSchema, } from "./instance-feedback.js";
 export { type PreviewConnectionPairRequest, type PreviewConnectionPairResponse, previewConnectionPairRequestSchema, previewConnectionPairResponseSchema, } from "./preview-connection.js";
 export { PREVIEW_PAIRING_TRANSPORT_SOURCE, type PreviewPairingHostAck, type PreviewPairingHostRequest, type PreviewPairingHostResult, previewPairingHostAckSchema, previewPairingHostRequestSchema, previewPairingHostResultSchema, } from "./preview-pairing-transport.js";
 export { isPublicGrantScope, type PublicGrantScope, publicGrantScopeIdSchema, } from "./public-grant-scope.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -6,8 +6,9 @@ export { coreCommandPayloadSchema, } from "./core-commands.js";
 export { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
 export { ErrorCategory, ErrorCategorySchema, ErrorEventSchema, ProtocolError, } from "./errors.js";
 export { claimPendingFlowAssignmentsRequestSchema, claimPendingFlowAssignmentsResponseSchema, flowAssignmentRecipientRequestSchema, flowAssignmentRecordSchema, flowAssignmentStatusSchema, flowAssignmentTargetingContextSchema, listPendingFlowAssignmentsResponseSchema, nullableUpdateFlowAssignmentLifecycleResponseSchema, releaseFlowAssignmentClaimRequestSchema, releaseFlowAssignmentClaimResponseSchema, updateFlowAssignmentLifecycleRequestSchema, updateFlowAssignmentLifecycleResponseSchema, } from "./flow-assignments.js";
-export { flowDisplaySyncRequestSchema, flowDisplaySyncResponseSchema, runtimeDisplayAttentionPolicySchema, runtimeDisplayBroadcastOpportunitySchema, runtimeDisplayBroadcastsSchema, runtimeDisplayEligibilitySchema, runtimeDisplayTriggerSchema, } from "./flow-display.js";
+export { flowDisplaySyncRequestSchema, flowDisplaySyncResponseSchema, resolveFlowDisplayAttentionPolicyConfig, runtimeDisplayAttentionPolicySchema, runtimeDisplayBroadcastOpportunitySchema, runtimeDisplayBroadcastsSchema, runtimeDisplayEligibilitySchema, runtimeDisplayTriggerSchema, } from "./flow-display.js";
 export { buildIdentityTypeGuidanceMessage, getIdentityTypeSuggestion, IDENTITY_TYPE_VALUES, isIdentityTypeValue, } from "./identity-type.js";
+export { captureInstanceFeedbackRequestSchema, captureInstanceFeedbackResponseSchema, instanceFeedbackDataTypeSchema, instanceFeedbackValenceSchema, } from "./instance-feedback.js";
 export { previewConnectionPairRequestSchema, previewConnectionPairResponseSchema, } from "./preview-connection.js";
 export { PREVIEW_PAIRING_TRANSPORT_SOURCE, previewPairingHostAckSchema, previewPairingHostRequestSchema, previewPairingHostResultSchema, } from "./preview-pairing-transport.js";
 export { isPublicGrantScope, publicGrantScopeIdSchema, } from "./public-grant-scope.js";

package/dist/instance-feedback.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/mini";
+export declare const instanceFeedbackDataTypeSchema: z.ZodMiniEnum<{
+    boolean: "boolean";
+    categorical: "categorical";
+    numeric: "numeric";
+}>;
+export declare const instanceFeedbackValenceSchema: z.ZodMiniEnum<{
+    positive: "positive";
+    negative: "negative";
+    neutral: "neutral";
+}>;
+export declare const captureInstanceFeedbackRequestSchema: z.ZodMiniObject<{
+    targetBindingToken: z.ZodMiniString<string>;
+    capturedAt: z.ZodMiniString<string>;
+    comment: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    dataType: z.ZodMiniEnum<{
+        boolean: "boolean";
+        categorical: "categorical";
+        numeric: "numeric";
+    }>;
+    label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    reasonCategories: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    scoreValue: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
+    valence: z.ZodMiniEnum<{
+        positive: "positive";
+        negative: "negative";
+        neutral: "neutral";
+    }>;
+}, z.core.$strip>;
+export declare const captureInstanceFeedbackResponseSchema: z.ZodMiniObject<{
+    capturedAt: z.ZodMiniString<string>;
+    evaluationId: z.ZodMiniString<string>;
+    status: z.ZodMiniLiteral<"accepted">;
+}, z.core.$strip>;
+export type InstanceFeedbackDataType = z.output<typeof instanceFeedbackDataTypeSchema>;
+export type InstanceFeedbackValence = z.output<typeof instanceFeedbackValenceSchema>;
+export type CaptureInstanceFeedbackRequest = z.output<typeof captureInstanceFeedbackRequestSchema>;
+export type CaptureInstanceFeedbackResponse = z.output<typeof captureInstanceFeedbackResponseSchema>;
+//# sourceMappingURL=instance-feedback.d.ts.map

package/dist/instance-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-feedback.d.ts","sourceRoot":"","sources":["../src/instance-feedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAyB9B,eAAO,MAAM,8BAA8B;;;;EAIzC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;iBA0B/C,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;iBAIhD,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,8BAA8B,CACrC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,6BAA6B,CACpC,CAAC;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,MAAM,CACpD,OAAO,oCAAoC,CAC3C,CAAC;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CACrD,OAAO,qCAAqC,CAC5C,CAAC"}

package/dist/instance-feedback.js

@@ -0,0 +1,49 @@
+import * as z from "zod/mini";
+const maxCaptureRequestCommentLength = 64 * 1024;
+const maxReasonCategoryCount = 20;
+const maxTargetBindingTokenLength = 4096;
+const canonicalUtcTimestampLength = "2026-07-01T12:00:00.000Z".length;
+const canonicalUtcTimestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+const isCanonicalUtcTimestamp = (value) => {
+    if (value.length !== canonicalUtcTimestampLength ||
+        !canonicalUtcTimestampPattern.test(value)) {
+        return false;
+    }
+    const date = new Date(value);
+    return !Number.isNaN(date.getTime()) && date.toISOString() === value;
+};
+const finiteNumberSchema = z.number().check(z.refine(Number.isFinite, {
+    message: "Expected a finite number.",
+}));
+export const instanceFeedbackDataTypeSchema = z.enum([
+    "boolean",
+    "categorical",
+    "numeric",
+]);
+export const instanceFeedbackValenceSchema = z.enum([
+    "positive",
+    "negative",
+    "neutral",
+]);
+export const captureInstanceFeedbackRequestSchema = z.object({
+    targetBindingToken: z
+        .string()
+        .check(z.trim(), z.minLength(1), z.maxLength(maxTargetBindingTokenLength)),
+    capturedAt: z.string().check(z.trim(), z.minLength(1), z.refine(isCanonicalUtcTimestamp, {
+        message: "capturedAt must be a canonical UTC timestamp.",
+    })),
+    comment: z.optional(z.nullable(z.string().check(z.maxLength(maxCaptureRequestCommentLength)))),
+    dataType: instanceFeedbackDataTypeSchema,
+    label: z.optional(z.nullable(z.string().check(z.maxLength(255)))),
+    name: z.optional(z.string().check(z.trim(), z.minLength(1), z.maxLength(255))),
+    reasonCategories: z.optional(z
+        .array(z.string().check(z.trim(), z.minLength(1), z.maxLength(128)))
+        .check(z.maxLength(maxReasonCategoryCount))),
+    scoreValue: z.optional(z.nullable(finiteNumberSchema)),
+    valence: instanceFeedbackValenceSchema,
+});
+export const captureInstanceFeedbackResponseSchema = z.object({
+    capturedAt: z.string(),
+    evaluationId: z.string().check(z.trim(), z.minLength(1)),
+    status: z.literal("accepted"),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@getuserfeedback/protocol",
-	"version": "3.0.14",
+	"version": "3.1.1",
 	"description": "getuserfeedback widget protocol — host surface and (later) wire protocol",
 	"keywords": [
 		"getuserfeedback",
@@ -124,6 +124,12 @@
 			"import": "./dist/flow-display.js",
 			"default": "./dist/flow-display.js"
 		},
+		"./instance-feedback": {
+			"types": "./dist/instance-feedback.d.ts",
+			"bun": "./src/instance-feedback.ts",
+			"import": "./dist/instance-feedback.js",
+			"default": "./dist/instance-feedback.js"
+		},
 		"./trpc-envelope": {
 			"types": "./dist/trpc-envelope.d.ts",
 			"bun": "./src/trpc-envelope.ts",

package/src/attention-policy.ts

@@ -6,12 +6,24 @@ export const attentionExclusiveSurfaceStrategySchema = z.enum(["queue"]);
 
 export const attentionBlockedBroadcastStrategySchema = z.enum(["queue"]);
 
-export const attentionPolicyConfigSchema = z.strictObject({
+const legacyAttentionPolicyConfigFields = {
 	version: z.string().check(z.trim(), z.minLength(1)),
 	source: attentionPolicySourceSchema,
 	recentFlowCooldownMs: z.number().check(z.positive()),
 	exclusiveSurfaceStrategy: attentionExclusiveSurfaceStrategySchema,
 	blockedBroadcastStrategy: attentionBlockedBroadcastStrategySchema,
+};
+
+export const legacyAttentionPolicyConfigSchema = z.strictObject(
+	legacyAttentionPolicyConfigFields,
+);
+
+// V2 is the additive policy envelope for the flow-display wire contract.
+// Keep legacy strict, and add future policy controls here instead of creating
+// another versioned sibling field for every new setting.
+export const attentionPolicyConfigSchema = z.looseObject({
+	...legacyAttentionPolicyConfigFields,
+	recentInAppCooldownMs: z._default(z.number().check(z.nonnegative()), 0),
 });
 
 export type AttentionPolicyConfig = z.output<
@@ -22,6 +34,7 @@ export const DEFAULT_ATTENTION_POLICY_CONFIG: AttentionPolicyConfig = {
 	version: "attention-policy-default-v1",
 	source: "default",
 	recentFlowCooldownMs: 5 * 60 * 1000,
+	recentInAppCooldownMs: 0,
 	exclusiveSurfaceStrategy: "queue",
 	blockedBroadcastStrategy: "queue",
 };

package/src/core-commands.ts

@@ -58,7 +58,38 @@ const prefetchPayloadSchema = z.strictObject({
 	flowHandleId: z.optional(flowHandleIdSchema),
 });
 
-const openCorePayloadSchema = z.strictObject({
+const inlineFlowThemeSchema = z.strictObject({
+	css: z.optional(z.string()),
+	themeRuntimeArtifactId: z.optional(
+		z.string().check(z.trim(), z.minLength(1)),
+	),
+	themeVersionId: z.optional(z.string().check(z.trim(), z.minLength(1))),
+});
+
+const inlineFlowSchema = z.strictObject({
+	definition: z.unknown().check(
+		z.check((ctx) => {
+			if (ctx.value !== undefined) {
+				return;
+			}
+			ctx.issues.push({
+				code: "custom",
+				input: ctx.value,
+				message: "Inline flow definition is required.",
+				continue: false,
+			});
+		}),
+	),
+	theme: z.optional(inlineFlowThemeSchema),
+});
+
+const prefetchInlinePayloadSchema = z.strictObject({
+	kind: z.literal("prefetch"),
+	flow: inlineFlowSchema,
+	flowHandleId: z.optional(flowHandleIdSchema),
+});
+
+const openPersistedCorePayloadSchema = z.strictObject({
 	kind: z.literal("open"),
 	flowId: flowIdSchema,
 	flowHandleId: z.optional(flowHandleIdSchema),
@@ -66,13 +97,28 @@ const openCorePayloadSchema = z.strictObject({
 	hideCloseButton: z.optional(z.boolean()),
 });
 
-const prerenderCorePayloadSchema = z.strictObject({
+const openInlineCorePayloadSchema = z.strictObject({
+	kind: z.literal("open"),
+	flow: inlineFlowSchema,
+	flowHandleId: z.optional(flowHandleIdSchema),
+	metadata: z.optional(responseMetadataInputSchema),
+	hideCloseButton: z.optional(z.boolean()),
+});
+
+const prerenderPersistedCorePayloadSchema = z.strictObject({
 	kind: z.literal("prerender"),
 	flowId: flowIdSchema,
 	flowHandleId: z.optional(flowHandleIdSchema),
 	hideCloseButton: z.optional(z.boolean()),
 });
 
+const prerenderInlineCorePayloadSchema = z.strictObject({
+	kind: z.literal("prerender"),
+	flow: inlineFlowSchema,
+	flowHandleId: z.optional(flowHandleIdSchema),
+	hideCloseButton: z.optional(z.boolean()),
+});
+
 const closeCorePayloadSchema = z.object({
 	kind: z.literal("close"),
 	flowHandleId: z.optional(flowHandleIdSchema),
@@ -140,10 +186,13 @@ const resetPayloadSchema = z.object({
 	kind: z.literal("reset"),
 });
 
-const coreCommandPayloadWithoutIdentifySchema = z.discriminatedUnion("kind", [
-	openCorePayloadSchema,
-	prefetchPayloadSchema,
-	prerenderCorePayloadSchema,
+const coreCommandPayloadWithoutIdentifySchema = z.union([
+	z.union([openPersistedCorePayloadSchema, openInlineCorePayloadSchema]),
+	z.union([prefetchPayloadSchema, prefetchInlinePayloadSchema]),
+	z.union([
+		prerenderPersistedCorePayloadSchema,
+		prerenderInlineCorePayloadSchema,
+	]),
 	hostContextUpdatedPayloadSchema,
 	hostSignalPayloadSchema,
 	setTargetingPlanPayloadSchema,

package/src/flow-display.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import {
 	flowDisplaySyncRequestSchema,
 	flowDisplaySyncResponseSchema,
+	resolveFlowDisplayAttentionPolicyConfig,
 } from "./flow-display";
 
 describe("flow display sync contracts", () => {
@@ -55,6 +56,179 @@ describe("flow display sync contracts", () => {
 		expect(result.attentionPolicy).toBeUndefined();
 	});
 
+	it("keeps the legacy attention policy response shape backward compatible", () => {
+		const result = flowDisplaySyncResponseSchema.parse({
+			fetchedAt: "2026-06-18T00:00:00.000Z",
+			attentionPolicy: {
+				version: "attention-policy-organization-override-v1",
+				source: "custom",
+				recentFlowCooldownMs: 45_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+			},
+			attentionPolicyV2: {
+				version: "attention-policy-organization-override-v1",
+				source: "custom",
+				recentFlowCooldownMs: 45_000,
+				recentInAppCooldownMs: 60_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+			},
+			assignments: {
+				claimed: [],
+			},
+			broadcasts: {
+				version: "empty",
+				opportunities: [],
+			},
+		});
+
+		expect(result.attentionPolicy).toEqual({
+			version: "attention-policy-organization-override-v1",
+			source: "custom",
+			recentFlowCooldownMs: 45_000,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+		});
+		expect(result.attentionPolicyV2).toEqual({
+			version: "attention-policy-organization-override-v1",
+			source: "custom",
+			recentFlowCooldownMs: 45_000,
+			recentInAppCooldownMs: 60_000,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+		});
+	});
+
+	it("rejects new attention policy fields on the legacy response field", () => {
+		expect(() =>
+			flowDisplaySyncResponseSchema.parse({
+				fetchedAt: "2026-06-18T00:00:00.000Z",
+				attentionPolicy: {
+					version: "attention-policy-organization-override-v1",
+					source: "custom",
+					recentFlowCooldownMs: 45_000,
+					recentInAppCooldownMs: 60_000,
+					exclusiveSurfaceStrategy: "queue",
+					blockedBroadcastStrategy: "queue",
+				},
+				assignments: {
+					claimed: [],
+				},
+				broadcasts: {
+					version: "empty",
+					opportunities: [],
+				},
+			}),
+		).toThrow();
+	});
+
+	it("accepts future additive fields on the v2 attention policy envelope", () => {
+		const result = flowDisplaySyncResponseSchema.parse({
+			fetchedAt: "2026-06-18T00:00:00.000Z",
+			attentionPolicyV2: {
+				version: "attention-policy-organization-override-v1",
+				source: "custom",
+				recentFlowCooldownMs: 45_000,
+				recentInAppCooldownMs: 60_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+				futureChannelStrategy: "digest",
+			},
+			assignments: {
+				claimed: [],
+			},
+			broadcasts: {
+				version: "empty",
+				opportunities: [],
+			},
+		});
+
+		expect(result.attentionPolicyV2).toEqual({
+			version: "attention-policy-organization-override-v1",
+			source: "custom",
+			recentFlowCooldownMs: 45_000,
+			recentInAppCooldownMs: 60_000,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+			futureChannelStrategy: "digest",
+		});
+		expect(resolveFlowDisplayAttentionPolicyConfig(result)).toEqual({
+			version: "attention-policy-organization-override-v1",
+			source: "custom",
+			recentFlowCooldownMs: 45_000,
+			recentInAppCooldownMs: 60_000,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+		});
+	});
+
+	it("resolves the v2 attention policy before the legacy fallback", () => {
+		const result = flowDisplaySyncResponseSchema.parse({
+			fetchedAt: "2026-06-18T00:00:00.000Z",
+			attentionPolicy: {
+				version: "attention-policy-legacy-v1",
+				source: "custom",
+				recentFlowCooldownMs: 45_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+			},
+			attentionPolicyV2: {
+				version: "attention-policy-v2-v1",
+				source: "custom",
+				recentFlowCooldownMs: 90_000,
+				recentInAppCooldownMs: 30_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+			},
+			assignments: {
+				claimed: [],
+			},
+			broadcasts: {
+				version: "empty",
+				opportunities: [],
+			},
+		});
+
+		expect(resolveFlowDisplayAttentionPolicyConfig(result)).toEqual({
+			version: "attention-policy-v2-v1",
+			source: "custom",
+			recentFlowCooldownMs: 90_000,
+			recentInAppCooldownMs: 30_000,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+		});
+	});
+
+	it("resolves legacy attention policy with default v2-only fields", () => {
+		const result = flowDisplaySyncResponseSchema.parse({
+			fetchedAt: "2026-06-18T00:00:00.000Z",
+			attentionPolicy: {
+				version: "attention-policy-legacy-v1",
+				source: "custom",
+				recentFlowCooldownMs: 45_000,
+				exclusiveSurfaceStrategy: "queue",
+				blockedBroadcastStrategy: "queue",
+			},
+			assignments: {
+				claimed: [],
+			},
+			broadcasts: {
+				version: "empty",
+				opportunities: [],
+			},
+		});
+
+		expect(resolveFlowDisplayAttentionPolicyConfig(result)).toEqual({
+			version: "attention-policy-legacy-v1",
+			source: "custom",
+			recentFlowCooldownMs: 45_000,
+			recentInAppCooldownMs: 0,
+			exclusiveSurfaceStrategy: "queue",
+			blockedBroadcastStrategy: "queue",
+		});
+	});
+
 	it("accepts runtime broadcast opportunities", () => {
 		const result = flowDisplaySyncResponseSchema.parse({
 			fetchedAt: "2026-06-18T00:00:00.000Z",

package/src/flow-display.ts

@@ -3,6 +3,7 @@ import * as z from "zod/mini";
 import {
 	type AttentionPolicyConfig,
 	attentionPolicyConfigSchema,
+	legacyAttentionPolicyConfigSchema,
 } from "./attention-policy.js";
 import {
 	flowAssignmentIdentitySchema,
@@ -86,7 +87,8 @@ export const flowDisplaySyncRequestSchema = z.object({
 
 export const flowDisplaySyncResponseSchema = z.object({
 	fetchedAt: z.string(),
-	attentionPolicy: z.optional(attentionPolicyConfigSchema),
+	attentionPolicy: z.optional(legacyAttentionPolicyConfigSchema),
+	attentionPolicyV2: z.optional(attentionPolicyConfigSchema),
 	assignments: z.object({
 		claimed: z.array(flowAssignmentRecordSchema),
 	}),
@@ -115,3 +117,28 @@ export type FlowDisplaySyncResponse = z.output<
 	typeof flowDisplaySyncResponseSchema
 >;
 export type FlowDisplayAttentionPolicyConfig = AttentionPolicyConfig;
+
+export const resolveFlowDisplayAttentionPolicyConfig = (
+	displaySync: Pick<
+		FlowDisplaySyncResponse,
+		"attentionPolicy" | "attentionPolicyV2"
+	>,
+): FlowDisplayAttentionPolicyConfig | undefined => {
+	const policy = displaySync.attentionPolicyV2 ?? displaySync.attentionPolicy;
+	if (!policy) {
+		return undefined;
+	}
+
+	return {
+		version: policy.version,
+		source: policy.source,
+		recentFlowCooldownMs: policy.recentFlowCooldownMs,
+		recentInAppCooldownMs:
+			"recentInAppCooldownMs" in policy &&
+			typeof policy.recentInAppCooldownMs === "number"
+				? policy.recentInAppCooldownMs
+				: 0,
+		exclusiveSurfaceStrategy: policy.exclusiveSurfaceStrategy,
+		blockedBroadcastStrategy: policy.blockedBroadcastStrategy,
+	};
+};

package/src/host/lazy-handle-client.ts

@@ -77,7 +77,7 @@ const createLazyHandleClientWithStages = <
 }): LazyHandleClient<THandleId, TSettlement, TStage> => {
 	let handleId: THandleId | undefined;
 	let tail = Promise.resolve();
-	let isIdle = true;
+	let queuedCommandCount = 0;
 	let epoch = 0;
 	const { stages } = input;
 	let stage = input.initialStage ?? stages.uninitialized;
@@ -127,14 +127,15 @@ const createLazyHandleClientWithStages = <
 			return settlement;
 		};
 
-		const run = isIdle ? execute() : tail.then(execute, execute);
-		isIdle = false;
+		const run =
+			queuedCommandCount === 0 ? execute() : tail.then(execute, execute);
+		queuedCommandCount += 1;
 		tail = run.then(
 			() => {
-				isIdle = true;
+				queuedCommandCount -= 1;
 			},
 			() => {
-				isIdle = true;
+				queuedCommandCount -= 1;
 			},
 		);
 		return run;

package/src/index.ts

@@ -88,6 +88,7 @@ export {
 	type RuntimeDisplayBroadcasts,
 	type RuntimeDisplayEligibility,
 	type RuntimeDisplayTrigger,
+	resolveFlowDisplayAttentionPolicyConfig,
 	runtimeDisplayAttentionPolicySchema,
 	runtimeDisplayBroadcastOpportunitySchema,
 	runtimeDisplayBroadcastsSchema,
@@ -102,6 +103,16 @@ export {
 	isIdentityTypeValue,
 	type StandardIdentityTypeValue,
 } from "./identity-type.js";
+export {
+	type CaptureInstanceFeedbackRequest,
+	type CaptureInstanceFeedbackResponse,
+	captureInstanceFeedbackRequestSchema,
+	captureInstanceFeedbackResponseSchema,
+	type InstanceFeedbackDataType,
+	type InstanceFeedbackValence,
+	instanceFeedbackDataTypeSchema,
+	instanceFeedbackValenceSchema,
+} from "./instance-feedback.js";
 export {
 	type PreviewConnectionPairRequest,
 	type PreviewConnectionPairResponse,

package/src/instance-feedback.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "bun:test";
+
+import { captureInstanceFeedbackRequestSchema } from "./instance-feedback";
+
+const validCaptureRequest = {
+	capturedAt: "2026-07-01T12:00:00.000Z",
+	dataType: "boolean",
+	scoreValue: 1,
+	targetBindingToken: "binding-token",
+	valence: "positive",
+} as const;
+
+describe("captureInstanceFeedbackRequestSchema", () => {
+	it("accepts canonical millisecond UTC capture timestamps", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse(validCaptureRequest)
+				.success,
+		).toBe(true);
+	});
+
+	it("rejects non-canonical capture timestamps", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				capturedAt: "2026-07-01T12:00:00Z",
+			}).success,
+		).toBe(false);
+	});
+
+	it("rejects impossible capture timestamps", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				capturedAt: "2026-02-31T00:00:00.000Z",
+			}).success,
+		).toBe(false);
+	});
+
+	it("rejects oversized capture timestamps", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				capturedAt: `${"2".repeat(4096)}Z`,
+			}).success,
+		).toBe(false);
+	});
+
+	it("caps target binding tokens before verification", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				targetBindingToken: "x".repeat(4097),
+			}).success,
+		).toBe(false);
+	});
+
+	it("caps reason categories at the capture boundary limit", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				reasonCategories: Array.from(
+					{ length: 21 },
+					(_, index) => `reason-${index}`,
+				),
+			}).success,
+		).toBe(false);
+	});
+
+	it("caps comments at the public capture body budget", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				comment: "x".repeat(64 * 1024 + 1),
+			}).success,
+		).toBe(false);
+	});
+
+	it("rejects non-finite score values", () => {
+		expect(
+			captureInstanceFeedbackRequestSchema.safeParse({
+				...validCaptureRequest,
+				scoreValue: Number.POSITIVE_INFINITY,
+			}).success,
+		).toBe(false);
+	});
+});

package/src/instance-feedback.ts

@@ -0,0 +1,83 @@
+import * as z from "zod/mini";
+
+const maxCaptureRequestCommentLength = 64 * 1024;
+const maxReasonCategoryCount = 20;
+const maxTargetBindingTokenLength = 4096;
+const canonicalUtcTimestampLength = "2026-07-01T12:00:00.000Z".length;
+const canonicalUtcTimestampPattern =
+	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+const isCanonicalUtcTimestamp = (value: string) => {
+	if (
+		value.length !== canonicalUtcTimestampLength ||
+		!canonicalUtcTimestampPattern.test(value)
+	) {
+		return false;
+	}
+
+	const date = new Date(value);
+	return !Number.isNaN(date.getTime()) && date.toISOString() === value;
+};
+const finiteNumberSchema = z.number().check(
+	z.refine(Number.isFinite, {
+		message: "Expected a finite number.",
+	}),
+);
+
+export const instanceFeedbackDataTypeSchema = z.enum([
+	"boolean",
+	"categorical",
+	"numeric",
+]);
+
+export const instanceFeedbackValenceSchema = z.enum([
+	"positive",
+	"negative",
+	"neutral",
+]);
+
+export const captureInstanceFeedbackRequestSchema = z.object({
+	targetBindingToken: z
+		.string()
+		.check(z.trim(), z.minLength(1), z.maxLength(maxTargetBindingTokenLength)),
+	capturedAt: z.string().check(
+		z.trim(),
+		z.minLength(1),
+		z.refine(isCanonicalUtcTimestamp, {
+			message: "capturedAt must be a canonical UTC timestamp.",
+		}),
+	),
+	comment: z.optional(
+		z.nullable(z.string().check(z.maxLength(maxCaptureRequestCommentLength))),
+	),
+	dataType: instanceFeedbackDataTypeSchema,
+	label: z.optional(z.nullable(z.string().check(z.maxLength(255)))),
+	name: z.optional(
+		z.string().check(z.trim(), z.minLength(1), z.maxLength(255)),
+	),
+	reasonCategories: z.optional(
+		z
+			.array(z.string().check(z.trim(), z.minLength(1), z.maxLength(128)))
+			.check(z.maxLength(maxReasonCategoryCount)),
+	),
+	scoreValue: z.optional(z.nullable(finiteNumberSchema)),
+	valence: instanceFeedbackValenceSchema,
+});
+
+export const captureInstanceFeedbackResponseSchema = z.object({
+	capturedAt: z.string(),
+	evaluationId: z.string().check(z.trim(), z.minLength(1)),
+	status: z.literal("accepted"),
+});
+
+export type InstanceFeedbackDataType = z.output<
+	typeof instanceFeedbackDataTypeSchema
+>;
+export type InstanceFeedbackValence = z.output<
+	typeof instanceFeedbackValenceSchema
+>;
+export type CaptureInstanceFeedbackRequest = z.output<
+	typeof captureInstanceFeedbackRequestSchema
+>;
+export type CaptureInstanceFeedbackResponse = z.output<
+	typeof captureInstanceFeedbackResponseSchema
+>;

package/src/protocol-root.test.ts

@@ -63,6 +63,7 @@ describe("@getuserfeedback/protocol root contract", () => {
 			version: "attention-policy-default-v1",
 			source: "default",
 			recentFlowCooldownMs: 5 * 60 * 1000,
+			recentInAppCooldownMs: 0,
 			exclusiveSurfaceStrategy: "queue",
 			blockedBroadcastStrategy: "queue",
 		});