@u-krupaveho-kraba/form-schemas 0.2.0 → 0.4.0

package/schemas/campaign.js

@@ -3,7 +3,10 @@ import { FormSchema } from "./form.js";
 export const FormReferenceSchema = z.object({
     ref: z.string(),
 });
-export const CampaignFormDefinitionSchema = z.union([FormSchema, FormReferenceSchema]);
+export const CampaignFormDefinitionSchema = z.union([
+    FormSchema,
+    FormReferenceSchema,
+]);
 export const VariantSchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -19,44 +22,85 @@ export const CampaignScheduleSchema = z.object({
     startsAt: z.optional(z.string()),
     endsAt: z.optional(z.string()),
 });
-// Used identically at Campaign level and CampaignItem level. `frequency`
-// used to be forbidden below the Campaign (the old SlotTargetingSchema,
-// ticket 117) because DisplayRuleState's display-count tracking was
-// per-campaign only. Every CampaignItem now owns its own display-budget
-// key (form-shared's displayKey), so that restriction no longer protects
-// anything -- one shape serves both levels.
+// Used on CampaignItem (the only level left post-ADR-0025's Campaign
+// removal).
 export const CampaignTargetingSchema = z.object({
     urlPatterns: z.optional(z.array(z.string())),
     schedule: z.optional(CampaignScheduleSchema),
     frequency: z.optional(FrequencyTargetingSchema),
 });
-export const ImmediateTriggerSchema = z.object({ type: z.literal("immediate") });
-export const DelayTriggerSchema = z.object({ type: z.literal("delay"), seconds: z.number() });
+export const ImmediateTriggerSchema = z.object({
+    type: z.literal("immediate"),
+});
+export const DelayTriggerSchema = z.object({
+    type: z.literal("delay"),
+    seconds: z.number(),
+});
 export const ScrollDepthTriggerSchema = z.object({
     type: z.literal("scroll_depth"),
     percent: z.number(),
 });
-export const ExitIntentTriggerSchema = z.object({ type: z.literal("exit_intent") });
+export const ExitIntentTriggerSchema = z.object({
+    type: z.literal("exit_intent"),
+});
 export const TriggerConditionSchema = z.discriminatedUnion("type", [
     ImmediateTriggerSchema,
     DelayTriggerSchema,
     ScrollDepthTriggerSchema,
     ExitIntentTriggerSchema,
 ]);
-// One independently-evaluated item in a Campaign -- replaces ticket 117's
-// CampaignSlotSchema union (VariantSchema | VariantGroupSchema). Default:
-// concurrent with every other item in the same Campaign. `exclusiveWith`,
+// The unit of independent client-side evaluation -- since ADR 0025 (Campaign
+// wrapper deleted), the only level left in the schema. Default: concurrent
+// with every other item published for the same Website. `exclusiveWith`,
 // when shared by two or more items, makes them compete instead (first
-// eligible one, by array order, wins) -- see CampaignSchema's cross-item
-// check below for the one invariant this field needs enforced.
-export const CampaignItemSchema = z.object({
+// eligible one, by array order, wins) -- see CampaignItemsFileSchema's
+// cross-item checks below for the invariants this and `id` need enforced.
+//
+// `trigger` is optional (ADR 0028, reversing this schema's own original
+// choice) -- a CampaignItem with no rule configured at all is now an
+// ordinary item, not a distinct mode; the widget defaults a missing
+// trigger to `{type: "immediate"}` at evaluation time (see
+// apps/form-widget/src/lib/runWidget.ts) rather than this schema forcing
+// every producer to write that default explicitly.
+//
+// The single source of truth for CampaignItem's shared envelope fields --
+// `packages/form-shared`'s `CampaignItemBase` and `apps/form-editor`'s own
+// copy both derive from this schema (`z.infer`/`Pick`) rather than
+// hand-declaring the same field set a third and fourth time (architecture
+// review, 2026-09-10).
+export const CampaignItemBaseSchema = z.object({
+    // Stable, author-assigned -- also the display-budget key (see
+    // types/displayRuleState.ts), the DOM mount attribute, and the Submit
+    // Payload/Funnel Event `itemId` (ADR 0025). Never an array index:
+    // reordering the item list must not change what an item's stored display
+    // history refers to. Required unique across every item published for one
+    // Website -- there is no outer wrapper left to namespace two items
+    // sharing an id.
     id: z.string(),
+    // Human label for the authoring UI ("Footer bar", "Black Friday banner")
+    // -- never shown to an End Customer.
     name: z.optional(z.string()),
     targeting: z.optional(CampaignTargetingSchema),
-    trigger: TriggerConditionSchema,
+    trigger: z.optional(TriggerConditionSchema),
     exclusiveWith: z.optional(z.string()),
-    variants: z.array(VariantSchema),
+    // Freeform, integrator-set reporting/attribution tag (ADR 0025) -- lets
+    // several independent items share one identity in the integrator's own
+    // reporting (e.g. Ecomail populates it from its own form_campaigns.id).
+    // Inert at evaluation time: no role in uniqueness, exclusiveWith
+    // clustering, or eligibility. This is the direct replacement for what the
+    // deleted Campaign wrapper's `id`/`name` used to provide structurally.
+    campaignId: z.optional(z.string()),
 });
+// ADR 0028: a CampaignItem carries its own content directly -- either a
+// single `definition` (the common, non-AB case) or `variants` (opt-in AB
+// test), never both, never neither. Kept as a plain `z.union` rather than a
+// `z.discriminatedUnion` -- there is no literal tag field to discriminate
+// on, same precedent as CampaignFormDefinitionSchema one level down (a
+// Form-shaped object vs. a `{ref}`-shaped one, disambiguated structurally).
+export const CampaignItemSchema = z.union([
+    z.object({ ...CampaignItemBaseSchema.shape, variants: z.array(VariantSchema) }),
+    z.object({ ...CampaignItemBaseSchema.shape, definition: CampaignFormDefinitionSchema }),
+]);
 // A lone item carrying an exclusiveWith value no sibling shares behaves
 // identically to one with no value at all (a cluster of one just always
 // wins), so it's never a runtime bug -- but it's always either dead
@@ -64,9 +108,11 @@ export const CampaignItemSchema = z.object({
 // typo in one of the two values. Reject it at publish time rather than
 // let it ship silently as a no-op field. `.check()` runs after the object
 // itself validates, so `items` here is already `CampaignItem[]`-shaped.
-function eachExclusiveWithValueIsShared(campaign) {
+// Post-ADR-0025: clusters across the *entire* flat item list for a Website
+// in one pass, not scoped to any wrapper.
+function eachExclusiveWithValueIsShared(file) {
     const counts = new Map();
-    for (const item of campaign.items) {
+    for (const item of file.items) {
         if (item.exclusiveWith === undefined)
             continue;
         counts.set(item.exclusiveWith, (counts.get(item.exclusiveWith) ?? 0) + 1);
@@ -74,31 +120,33 @@ function eachExclusiveWithValueIsShared(campaign) {
     return [...counts.values()].every((count) => count >= 2);
 }
 const EXCLUSIVE_WITH_SHARED_MESSAGE = "exclusiveWith value is used by only one item -- either remove it or add a second item that shares it";
-export const CampaignSchema = z
+// ADR 0025: CampaignItem.id now does every job the deleted Campaign.id used
+// to do (DOM mount attribute, displayKey namespacing, analytics identity),
+// so it must be unique across the whole flat item list for a Website --
+// there is no outer wrapper left to namespace two items sharing an id.
+function everyItemIdIsUnique(file) {
+    const ids = file.items.map((item) => item.id);
+    return new Set(ids).size === ids.length;
+}
+const ITEM_ID_UNIQUE_MESSAGE = "item id is used by more than one item -- CampaignItem.id must be unique within a Website's item list";
+export const CampaignItemsFileSchema = z
     .object({
-    id: z.string(),
-    name: z.string(),
-    version: z.literal(1),
-    targeting: z.optional(CampaignTargetingSchema),
+    formatVersion: z.literal(1),
+    account: z.string(),
+    website: z.string(),
     items: z.array(CampaignItemSchema),
 })
-    .check(z.refine(eachExclusiveWithValueIsShared, EXCLUSIVE_WITH_SHARED_MESSAGE));
+    .check(z.refine(eachExclusiveWithValueIsShared, EXCLUSIVE_WITH_SHARED_MESSAGE), z.refine(everyItemIdIsUnique, ITEM_ID_UNIQUE_MESSAGE));
 // Ticket 113: field names match the real, already-deployed Ecomail publish
 // job's actual index-entry output, not FormReferenceSchema's {ref} shape.
-export const CampaignEntryRefSchema = z.object({
+// Renamed from CampaignEntry(Ref)Schema by ADR 0025 -- one entry now
+// references/inlines a single CampaignItem, not a whole (deleted) Campaign.
+export const CampaignItemEntryRefSchema = z.object({
     id: z.string(),
     url: z.string(),
     rules: z.optional(z.unknown()),
 });
-export const CampaignEntrySchema = z.union([CampaignEntryRefSchema, CampaignSchema]);
-// The campaigns.json v1 envelope (ADR 0008) -- see the CampaignsFile doc
-// comment in form-shared/src/types/campaign.ts for how this relates to the
-// shipped index+per-file HTTP delivery split. Still v1: ticket 117's
-// CampaignSlot shape never shipped to a real customer (127/128/129 landed
-// 2026-08-12, zero adoption yet), so this revision replaces it in place.
-export const CampaignsFileSchema = z.object({
-    formatVersion: z.literal(1),
-    account: z.string(),
-    website: z.string(),
-    campaigns: z.array(CampaignSchema),
-});
+export const CampaignItemEntrySchema = z.union([
+    CampaignItemEntryRefSchema,
+    CampaignItemSchema,
+]);

package/schemas/element.js

@@ -1,17 +1,20 @@
 import * as z from "zod/mini";
-import { BaseElementPropertiesSchema, ButtonElementPropertiesSchema, CheckboxElementPropertiesSchema, HtmlElementPropertiesSchema, ImageElementPropertiesSchema, RadioElementPropertiesSchema, SelectElementPropertiesSchema, SpacerElementPropertiesSchema, TextElementPropertiesSchema, TextInputElementPropertiesSchema, } from "./elementProperties.js";
+import { BaseElementPropertiesSchema, ButtonElementPropertiesSchema, ButtonWidthSchema, CheckboxElementPropertiesSchema, CountdownElementPropertiesSchema, FloatingImageElementPropertiesSchema, GifElementPropertiesSchema, HtmlElementPropertiesSchema, ImageElementPropertiesSchema, RadioElementPropertiesSchema, SelectElementPropertiesSchema, SpacerElementPropertiesSchema, TextElementPropertiesSchema, TextInputElementPropertiesSchema, } from "./elementProperties.js";
 export const ElementTypeSchema = z.enum([
     "text_input",
     "text",
     "block",
     "button",
     "image",
+    "floating_image",
+    "gif",
     "column",
     "checkbox",
     "radio",
     "select",
     "html",
     "spacer",
+    "countdown",
 ]);
 // mirrors the Element<T, P> generic helper in form-shared/types/element.ts.
 // Takes a raw shape (not a ZodMiniObject) — matching zod's own `extend()`
@@ -32,11 +35,14 @@ export const ButtonElementSchema = elementSchema("button", ButtonElementProperti
 export const TextElementSchema = elementSchema("text", TextElementPropertiesSchema.shape);
 export const TextInputElementSchema = elementSchema("text_input", TextInputElementPropertiesSchema.shape);
 export const ImageElementSchema = elementSchema("image", ImageElementPropertiesSchema.shape);
+export const FloatingImageElementSchema = elementSchema("floating_image", FloatingImageElementPropertiesSchema.shape);
+export const GifElementSchema = elementSchema("gif", GifElementPropertiesSchema.shape);
 export const CheckboxElementSchema = elementSchema("checkbox", CheckboxElementPropertiesSchema.shape);
 export const RadioElementSchema = elementSchema("radio", RadioElementPropertiesSchema.shape);
 export const SelectElementSchema = elementSchema("select", SelectElementPropertiesSchema.shape);
 export const HtmlElementSchema = elementSchema("html", HtmlElementPropertiesSchema.shape);
 export const SpacerElementSchema = elementSchema("spacer", SpacerElementPropertiesSchema.shape);
+export const CountdownElementSchema = elementSchema("countdown", CountdownElementPropertiesSchema.shape);
 export const BlockColumnElementSchema = z.object({
     id: z.string(),
     type: z.literal("column"),
@@ -50,6 +56,7 @@ export const BlockColumnElementSchema = z.object({
 });
 const blockLayoutBase = {
     ...BaseElementPropertiesSchema.shape,
+    width: z.optional(ButtonWidthSchema),
 };
 export const BlockElementPropertiesSchema = z.discriminatedUnion("block_type", [
     z.object({
@@ -65,7 +72,11 @@ export const BlockElementPropertiesSchema = z.discriminatedUnion("block_type", [
     z.object({
         ...blockLayoutBase,
         block_type: z.literal("triple_column"),
-        columns: z.tuple([BlockColumnElementSchema, BlockColumnElementSchema, BlockColumnElementSchema]),
+        columns: z.tuple([
+            BlockColumnElementSchema,
+            BlockColumnElementSchema,
+            BlockColumnElementSchema,
+        ]),
     }),
 ]);
 export const BlockElementSchema = z.object({
@@ -78,6 +89,8 @@ export const FormElementSchema = z.discriminatedUnion("type", [
     TextElementSchema,
     TextInputElementSchema,
     ImageElementSchema,
+    FloatingImageElementSchema,
+    GifElementSchema,
     CheckboxElementSchema,
     RadioElementSchema,
     SelectElementSchema,
@@ -85,4 +98,5 @@ export const FormElementSchema = z.discriminatedUnion("type", [
     BlockColumnElementSchema,
     HtmlElementSchema,
     SpacerElementSchema,
+    CountdownElementSchema,
 ]);

package/schemas/elementProperties.js

@@ -16,9 +16,19 @@ export const LinkTargetSchema = z.object({
     url: z.string(),
     openInNewTab: z.optional(z.boolean()),
 });
+// ADR 0026: where a successful Submit lands. Omitted/undefined means "use
+// the effective default" -- the Thank You Page when the Form has one,
+// otherwise no navigation (today's behavior).
+export const PostSubmitDestinationSchema = z.enum([
+    "next_step",
+    "thank_you_page",
+]);
 export const ButtonActionSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("next_step") }),
-    z.object({ type: z.literal("submit") }),
+    z.object({
+        type: z.literal("submit"),
+        onSuccess: z.optional(PostSubmitDestinationSchema),
+    }),
     z.object({ type: z.literal("close") }),
     z.object({ type: z.literal("jump_to"), targetStepId: z.string() }),
     z.object({ type: z.literal("redirect"), ...LinkTargetSchema.shape }),
@@ -38,6 +48,13 @@ export const ButtonElementPropertiesSchema = z.object({
     fontSize: z.optional(z.number()),
     fontWeight: z.optional(z.enum(["normal", "bold"])),
     fontStyle: z.optional(z.enum(["normal", "italic"])),
+    // Alignment of the text inside the button's own box -- distinct from
+    // `align` below, which positions the button itself within its wrapper.
+    textAlign: z.optional(ButtonAlignSchema),
+    // A CSS gradient function string (e.g. "linear-gradient(90deg, ...)"),
+    // layered on top of the base `backgroundColor` (BaseContainerProperties)
+    // rather than replacing it -- same background-image/-color split LPE uses.
+    backgroundImage: z.optional(z.string()),
     hover: z.optional(z.object({
         backgroundColor: z.optional(z.string()),
         fontColor: z.optional(z.string()),
@@ -47,7 +64,14 @@ export const ButtonElementPropertiesSchema = z.object({
     height: z.optional(z.number()),
     align: z.optional(ButtonAlignSchema),
 });
-export const InputTypeSchema = z.enum(["text", "email", "telephone", "number", "date", "url"]);
+export const InputTypeSchema = z.enum([
+    "text",
+    "email",
+    "telephone",
+    "number",
+    "date",
+    "url",
+]);
 export const InputFieldSchema = z.object({
     type: InputTypeSchema,
     name: z.string(),
@@ -62,7 +86,12 @@ export const PreferenceOptionSchema = z.object({
     value: z.string(),
     label: z.string(),
 });
-export const PreferenceTypeSchema = z.enum(["checkbox", "hidden", "radio", "select"]);
+export const PreferenceTypeSchema = z.enum([
+    "checkbox",
+    "hidden",
+    "radio",
+    "select",
+]);
 export const PreferenceSchema = z.object({
     id: z.union([z.string(), z.number()]),
     name: z.string(),
@@ -80,7 +109,9 @@ export const PreferenceSchema = z.object({
 // -- which already wants a "true = valid" predicate -- can use it directly;
 // the one caller that wants the opposite (editorStore.ts's save-gate)
 // negates it at that single call site instead.
-export const satisfiesCustomKeyRequirement = (value) => !(value.preference === null && value.custom_options !== undefined && !value.customKey);
+export const satisfiesCustomKeyRequirement = (value) => !(value.preference === null &&
+    value.custom_options !== undefined &&
+    !value.customKey);
 const CUSTOM_KEY_REQUIRED_MESSAGE = "customKey is required when custom_options is used without a linked preference";
 export const PreferenceElementPropertiesSchema = z
     .object({
@@ -91,14 +122,44 @@ export const PreferenceElementPropertiesSchema = z
     required: z.boolean(),
 })
     .check(z.refine(satisfiesCustomKeyRequirement, CUSTOM_KEY_REQUIRED_MESSAGE));
+// Shared corner-radius preset for Checkbox's `shape` and Select's
+// `controlRadius` -- same value set and same icon-button-group UI, applied
+// to two different controls (ADR 0023: select's control styling stays
+// independent, but the *shape vocabulary* is deliberately shared).
+export const BoxShapeSchema = z.enum(["square", "rounded", "pill"]);
+// Stacked (default, today's only behavior) vs. inline option layout --
+// shared by Checkbox and Radio, meaningless for Select (a single dropdown).
+export const PreferenceFieldLayoutSchema = z.enum(["vertical", "horizontal"]);
 export const SelectElementPropertiesSchema = z
     .object({
     ...PreferenceElementPropertiesSchema.shape,
     placeholder: z.string(),
+    labelColor: z.optional(z.string()),
+    controlTextColor: z.optional(z.string()),
+    controlBackgroundColor: z.optional(z.string()),
+    controlBorderColor: z.optional(z.string()),
+    controlRadius: z.optional(BoxShapeSchema),
+})
+    .check(z.refine(satisfiesCustomKeyRequirement, CUSTOM_KEY_REQUIRED_MESSAGE));
+export const CheckboxElementPropertiesSchema = z
+    .object({
+    ...PreferenceElementPropertiesSchema.shape,
+    accentColor: z.optional(z.string()),
+    labelColor: z.optional(z.string()),
+    shape: z.optional(BoxShapeSchema),
+    layout: z.optional(PreferenceFieldLayoutSchema),
+})
+    .check(z.refine(satisfiesCustomKeyRequirement, CUSTOM_KEY_REQUIRED_MESSAGE));
+export const RadioStyleSchema = z.enum(["outline", "filled"]);
+export const RadioElementPropertiesSchema = z
+    .object({
+    ...PreferenceElementPropertiesSchema.shape,
+    accentColor: z.optional(z.string()),
+    labelColor: z.optional(z.string()),
+    style: z.optional(RadioStyleSchema),
+    layout: z.optional(PreferenceFieldLayoutSchema),
 })
     .check(z.refine(satisfiesCustomKeyRequirement, CUSTOM_KEY_REQUIRED_MESSAGE));
-export const CheckboxElementPropertiesSchema = PreferenceElementPropertiesSchema;
-export const RadioElementPropertiesSchema = PreferenceElementPropertiesSchema;
 export const TextElementPropertiesSchema = z.object({
     text: z.string(),
     color: z.string(),
@@ -114,22 +175,82 @@ export const TextElementPropertiesSchema = z.object({
 export const HtmlElementPropertiesSchema = z.object({
     html: z.string(),
 });
+// Mirrors ButtonWidthSchema's full/custom split, minus "auto" -- see
+// ImageWidth's doc comment in form-shared/types/elementProperties.ts.
+export const ImageWidthSchema = z.union([
+    z.literal("full"),
+    z.object({ unit: z.enum(["px", "%"]), value: z.number() }),
+]);
 export const ImageElementPropertiesSchema = z.object({
     src: z.string(),
+    alt: z.optional(z.string()),
     link: z.optional(LinkTargetSchema),
-    width: z.optional(z.object({ unit: z.enum(["px", "%"]), value: z.number() })),
+    width: z.optional(ImageWidthSchema),
     align: z.optional(z.enum(["left", "center", "right"])),
     objectFit: z.optional(z.enum(["cover", "contain", "fill"])),
     objectPosition: z.optional(z.string()),
 });
-// pre-authored for the upcoming floating_image element (currently commented
-// out in form-shared's ElementType/FormElementSchema) — not yet a consumer.
+// Mirrors FloatingImageElementProperties in
+// form-shared/types/elementProperties.ts -- spelled out explicitly (not
+// derived from ImageElementPropertiesSchema) for the same reason the
+// TypeScript type is: `width`/`align` don't carry over unchanged (`width`
+// becomes a required number set via on-canvas resize, not the full/auto/
+// custom ImageWidthSchema; `align` is dropped, meaningless once the element
+// is taken out of flow), and `position` is a free {x,y} pixel offset set by
+// dragging, not the popup Form's anchor+distance shape.
 export const FloatingImageElementPropertiesSchema = z.object({
     src: z.string(),
+    alt: z.optional(z.string()),
+    link: z.optional(LinkTargetSchema),
+    objectFit: z.optional(z.enum(["cover", "contain", "fill"])),
+    objectPosition: z.optional(z.string()),
+    position: z.object({
+        x: z.number(),
+        y: z.number(),
+    }),
+    width: z.number(),
+    height: z.number(),
 });
+// Same shape as ImageElementPropertiesSchema -- mirrors
+// GifElementProperties in form-shared/types/elementProperties.ts.
+export const GifElementPropertiesSchema = ImageElementPropertiesSchema;
 export const SpacerElementPropertiesSchema = z.object({
     height: z.number(),
     showDivider: z.optional(z.boolean()),
     dividerColor: z.optional(z.string()),
     dividerThickness: z.optional(z.number()),
 });
+// "fixed_time" is an evergreen duration -- it restarts fresh from `duration`
+// every time a visitor loads the page (per-visitor, e.g. a "hurry, offer
+// ends in 10 minutes" nudge). "fixed_date" is one real calendar deadline,
+// the same for every visitor. Mirrors OptiMonk's countdown mode split.
+export const CountdownModeSchema = z.enum(["fixed_date", "fixed_time"]);
+export const CountdownDurationSchema = z.object({
+    days: z.number(),
+    hours: z.number(),
+    minutes: z.number(),
+    seconds: z.number(),
+});
+export const CountdownLabelsSchema = z.object({
+    days: z.string(),
+    hours: z.string(),
+    minutes: z.string(),
+    seconds: z.string(),
+});
+export const CountdownElementPropertiesSchema = z.object({
+    mode: CountdownModeSchema,
+    // Local wall-clock datetime string ("YYYY-MM-DDTHH:mm"), used when
+    // mode === "fixed_date" -- matches a native <input type="datetime-local">
+    // value directly, and JS's Date constructor already parses a timezone-less
+    // date-time string as local time, so no timezone field is needed.
+    targetDate: z.string(),
+    // Used when mode === "fixed_time"; restarted from this on every mount.
+    duration: CountdownDurationSchema,
+    showLabels: z.boolean(),
+    labels: CountdownLabelsSchema,
+    fontFamily: z.optional(z.string()),
+    fontSize: z.optional(z.number()),
+    color: z.optional(z.string()),
+    labelColor: z.optional(z.string()),
+    boxBackgroundColor: z.optional(z.string()),
+});

package/schemas/form.js

@@ -2,7 +2,12 @@ import * as z from "zod/mini";
 import { HexSchema } from "./helpers.js";
 import { StepSchema } from "./step.js";
 import { BasicFormDisplaySchema, MobilePopupFormDisplaySchema, PopupFormDisplaySchema, SliderFormDisplaySchema, } from "./formDisplay.js";
-export const FormTypeSchema = z.enum(["popup", "basic", "slider", "mobile_popup"]);
+export const FormTypeSchema = z.enum([
+    "popup",
+    "basic",
+    "slider",
+    "mobile_popup",
+]);
 export const FormLanguageSchema = z.enum(["cs", "en"]);
 export const FormThemeSchema = z.object({
     corners: z.enum(["none", "sm", "md", "lg"]),
@@ -19,15 +24,35 @@ const formBase = {
     usedFonts: z.array(z.string()),
 };
 export const FormSchema = z.discriminatedUnion("type", [
-    z.object({ ...formBase, type: z.literal("basic"), display: BasicFormDisplaySchema }),
-    z.object({ ...formBase, type: z.literal("popup"), display: PopupFormDisplaySchema }),
-    z.object({ ...formBase, type: z.literal("slider"), display: SliderFormDisplaySchema }),
-    z.object({ ...formBase, type: z.literal("mobile_popup"), display: MobilePopupFormDisplaySchema }),
+    z.object({
+        ...formBase,
+        type: z.literal("basic"),
+        display: BasicFormDisplaySchema,
+    }),
+    z.object({
+        ...formBase,
+        type: z.literal("popup"),
+        display: PopupFormDisplaySchema,
+    }),
+    z.object({
+        ...formBase,
+        type: z.literal("slider"),
+        display: SliderFormDisplaySchema,
+    }),
+    z.object({
+        ...formBase,
+        type: z.literal("mobile_popup"),
+        display: MobilePopupFormDisplaySchema,
+    }),
 ]);
-// Renamed from FormCampaignSchema (ADR 0016) -- mirrors MountedForm in form-shared.
+// Renamed from FormCampaignSchema (ADR 0016) -- mirrors MountedForm in
+// form-shared. `campaignId` is optional (ADR 0025): sourced 1:1 from the
+// winning CampaignItem's own optional reporting tag, present only when an
+// integrator set one.
 export const MountedFormSchema = z.object({
     id: z.string(),
     name: z.string(),
     definition: FormSchema,
     variantId: z.optional(z.string()),
+    campaignId: z.optional(z.string()),
 });

package/schemas/formDisplay.js

@@ -7,6 +7,7 @@ export const FormBorderSchema = z.object({
     style: BorderStyleSchema,
     sides: z.optional(z.enum(["all", "top", "right", "bottom", "left"])),
     useTheme: z.optional(z.boolean()),
+    radius: z.optional(z.number()),
 });
 export const FormShadowSchema = z.object({
     offsetX: z.number(),

package/schemas/step.js

@@ -6,10 +6,14 @@ export const StepDisplayPropertiesSchema = z.object({
     backgroundColor: z.optional(HexSchema),
     minHeight: z.optional(z.number()),
 });
+// ADR 0026: marks the Step shown once a Submit succeeds. Omitted/undefined
+// means an ordinary content step -- there is no explicit "content" literal.
+export const StepKindSchema = z.literal("thankYou");
 export const StepSchema = z.object({
     type: z.literal("step"),
     name: z.string(),
     elements: z.array(FormElementSchema),
     id: z.string(),
     displayProperties: StepDisplayPropertiesSchema,
+    kind: z.optional(StepKindSchema),
 });

package/types/index.d.ts

@@ -11,8 +11,11 @@ export * from "./schemas/campaign.js";
  */
 export declare function getFormJsonSchema(): Record<string, unknown>;
 /**
- * Serializes the Campaign contract as standard JSON Schema — the artifact
- * exported to ecomailapp so its PHP publish job can validate against the
- * real schema instead of drifting silently (ticket 115/118, ADR 0017).
+ * Serializes the CampaignItem contract as standard JSON Schema — the
+ * artifact exported to ecomailapp so its PHP publish job can validate each
+ * item it builds against the real schema instead of drifting silently
+ * (ticket 115/118, ADR 0017). Renamed from `getCampaignJsonSchema` by ADR
+ * 0025: there is no `Campaign` wrapper left to serialize, `CampaignItem` is
+ * now the atomic authored/published unit.
  */
-export declare function getCampaignJsonSchema(): Record<string, unknown>;
+export declare function getCampaignItemJsonSchema(): Record<string, unknown>;