@delmaredigital/payload-experiments 0.3.0-rc.4 → 0.4.0-rc.1

package/dist/admin/surface/results/useResults.d.ts

@@ -29,6 +29,14 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
     canManage?: boolean;
 }): {
     api: {
+        wrapBlock: (body: import("../../../types/endpoints.js").WrapBlockBody) => Promise<ApiResult<Record<string, unknown>>>;
+        pages: (query: {
+            collection: string;
+            q?: string;
+            path?: string;
+            page?: number;
+        }, signal?: AbortSignal) => Promise<ApiResult<import("../../../types/endpoints.js").PagesResult>>;
+        placementStatus: (body: import("../../../types/endpoints.js").PlacementStatusBody) => Promise<ApiResult<import("../../../types/endpoints.js").PlacementStatusResult>>;
         start: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         allocate: (id: DocId, body: import("../../../types/endpoints.js").AllocateBody, options?: {
             notFound?: string;
@@ -39,7 +47,7 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
             notFound?: string;
             codes?: Readonly<Record<string, string>>;
             fallback?: string;
-        }) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
+        }) => Promise<ApiResult<import("../../../types/endpoints.js").AddMetricResult>>;
         stop: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         decide: (id: DocId, body: import("../../../types/endpoints.js").DecideBody) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
         releaseHoldout: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
@@ -48,6 +56,7 @@ export declare function useResults(id: DocId, { apiRoute, canReadResults, canMan
         dismissContentEntry: (id: DocId, body: import("../../../types/endpoints.js").DismissContentEntryBody) => Promise<ApiResult<import("../../../types/endpoints.js").DismissContentEntryResult>>;
         restoreContentEntry: (id: DocId, body: import("../../../types/endpoints.js").RestoreContentEntryBody) => Promise<ApiResult<import("../../../types/endpoints.js").RestoreContentEntryResult>>;
         archive: (id: DocId, body: import("../../../types/endpoints.js").ArchiveBody) => Promise<ApiResult<import("../../../types/endpoints.js").TransitionSuccess>>;
+        clickKeys: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").ClickKeysResult>>;
         preflight: (id: DocId) => Promise<ApiResult<import("../../../types/endpoints.js").PreflightResult>>;
         previewToken: (id: DocId, arm: string) => Promise<ApiResult<import("../../../types/endpoints.js").PreviewTokenResult>>;
         results: (id: DocId, options?: {

package/dist/admin/surface/test/AdvancedSection.js

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ADVANCED_COPY as C } from '../../copy/advanced.js';
 import { exposureOptions } from './testPage.model.js';
 import { FieldErrors, positiveInteger, ReadOnly, reasonFor, save, SelectEdit, TextEdit } from './fields.js';
+import { PageHoldout } from './PageHoldout.js';
 import { Section } from './Section.js';
 const readOnlyFields = [
     'layer',
@@ -36,125 +37,131 @@ export function AdvancedSection({ test, surface }) {
             0
         ]
     ];
-    return /*#__PURE__*/ _jsx(Section, {
+    return /*#__PURE__*/ _jsxs(Section, {
         test: test,
         sectionId: "advanced",
-        children: /*#__PURE__*/ _jsxs("div", {
-            className: "xp-field-grid",
-            children: [
-                /*#__PURE__*/ _jsxs("div", {
-                    children: [
-                        /*#__PURE__*/ _jsx(SelectEdit, {
-                            label: C.exposurePolicy.label,
-                            value: doc.exposurePolicy,
-                            reason: reasonFor(test, 'exposurePolicy'),
-                            options: exposureOptions(doc.kind).map((value)=>({
-                                    value,
-                                    label: C.policies[value]
-                                })),
-                            onCommit: (value)=>save(test, 'exposurePolicy', ()=>({
-                                        exposurePolicy: value
-                                    }))
-                        }),
-                        /*#__PURE__*/ _jsx("p", {
-                            children: C.exposurePolicy.help
-                        }),
-                        /*#__PURE__*/ _jsx(FieldErrors, {
-                            test: test,
-                            path: "exposurePolicy"
-                        })
-                    ]
-                }),
-                surface.isAdmin ? /*#__PURE__*/ _jsxs("div", {
-                    children: [
-                        /*#__PURE__*/ _jsx(SelectEdit, {
-                            label: C.method.label,
-                            value: doc.analysis?.method ?? 'sequential',
-                            reason: reason,
-                            options: [
-                                {
-                                    value: 'sequential',
-                                    label: C.sequential
-                                },
-                                {
-                                    value: 'bayesian',
-                                    label: C.bayesian
-                                }
-                            ],
-                            onCommit: (value)=>change('method', value)
-                        }),
-                        /*#__PURE__*/ _jsx("p", {
-                            children: C.method.help
-                        }),
-                        /*#__PURE__*/ _jsx(FieldErrors, {
-                            test: test,
-                            path: "analysis.method"
-                        })
-                    ]
-                }) : null,
-                /*#__PURE__*/ _jsxs("div", {
-                    children: [
-                        /*#__PURE__*/ _jsx(SelectEdit, {
-                            label: C.cuped.label,
-                            value: doc.analysis?.cuped ?? 'auto',
-                            reason: reason,
-                            options: [
-                                {
-                                    value: 'auto',
-                                    label: C.auto
-                                },
-                                {
-                                    value: 'off',
-                                    label: C.off
-                                }
-                            ],
-                            onCommit: (value)=>change('cuped', value)
-                        }),
-                        /*#__PURE__*/ _jsx("p", {
-                            children: C.cuped.help
-                        }),
-                        /*#__PURE__*/ _jsx(FieldErrors, {
-                            test: test,
-                            path: "analysis.cuped"
-                        })
-                    ]
-                }),
-                numbers.map(([field, fallback, min])=>/*#__PURE__*/ _jsxs("div", {
+        children: [
+            doc.kind === 'page' ? /*#__PURE__*/ _jsx(PageHoldout, {
+                test: test,
+                surface: surface
+            }) : null,
+            /*#__PURE__*/ _jsxs("div", {
+                className: "xp-field-grid",
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
                         children: [
-                            /*#__PURE__*/ _jsx(TextEdit, {
-                                label: C[field].label,
-                                value: doc.analysis?.[field] ?? fallback,
-                                placeholder: field === 'attributionWindowHours' ? C.inheritedWindow : field === 'sequentialTuningParameter' ? C.automaticTuning : undefined,
-                                type: "number",
-                                min: min,
+                            /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.exposurePolicy.label,
+                                value: doc.exposurePolicy,
+                                reason: reasonFor(test, 'exposurePolicy'),
+                                options: exposureOptions(doc.kind).map((value)=>({
+                                        value,
+                                        label: C.policies[value]
+                                    })),
+                                onCommit: (value)=>save(test, 'exposurePolicy', ()=>({
+                                            exposurePolicy: value
+                                        }))
+                            }),
+                            /*#__PURE__*/ _jsx("p", {
+                                children: C.exposurePolicy.help
+                            }),
+                            /*#__PURE__*/ _jsx(FieldErrors, {
+                                test: test,
+                                path: "exposurePolicy"
+                            })
+                        ]
+                    }),
+                    surface.isAdmin ? /*#__PURE__*/ _jsxs("div", {
+                        children: [
+                            /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.method.label,
+                                value: doc.analysis?.method ?? 'sequential',
                                 reason: reason,
-                                validate: field === 'minExposuresPerArm' ? positiveInteger : undefined,
-                                onCommit: (raw)=>change(field, raw.trim() ? Number(raw) : null)
+                                options: [
+                                    {
+                                        value: 'sequential',
+                                        label: C.sequential
+                                    },
+                                    {
+                                        value: 'bayesian',
+                                        label: C.bayesian
+                                    }
+                                ],
+                                onCommit: (value)=>change('method', value)
                             }),
                             /*#__PURE__*/ _jsx("p", {
-                                children: C[field].help
+                                children: C.method.help
                             }),
                             /*#__PURE__*/ _jsx(FieldErrors, {
                                 test: test,
-                                path: `analysis.${field}`
+                                path: "analysis.method"
                             })
                         ]
-                    }, field)),
-                readOnlyFields.map((field)=>/*#__PURE__*/ _jsxs("div", {
+                    }) : null,
+                    /*#__PURE__*/ _jsxs("div", {
                         children: [
-                            /*#__PURE__*/ _jsx(ReadOnly, {
-                                label: C[field].label,
-                                value: field === 'slug' ? /*#__PURE__*/ _jsx("code", {
-                                    children: String(doc.slug)
-                                }) : typeof doc[field] === 'string' || typeof doc[field] === 'number' ? String(doc[field]) : C.none,
-                                reason: reasonFor(test, field)
+                            /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.cuped.label,
+                                value: doc.analysis?.cuped ?? 'auto',
+                                reason: reason,
+                                options: [
+                                    {
+                                        value: 'auto',
+                                        label: C.auto
+                                    },
+                                    {
+                                        value: 'off',
+                                        label: C.off
+                                    }
+                                ],
+                                onCommit: (value)=>change('cuped', value)
                             }),
                             /*#__PURE__*/ _jsx("p", {
-                                children: C[field].help
+                                children: C.cuped.help
+                            }),
+                            /*#__PURE__*/ _jsx(FieldErrors, {
+                                test: test,
+                                path: "analysis.cuped"
                             })
                         ]
-                    }, field))
-            ]
-        })
+                    }),
+                    numbers.map(([field, fallback, min])=>/*#__PURE__*/ _jsxs("div", {
+                            children: [
+                                /*#__PURE__*/ _jsx(TextEdit, {
+                                    label: C[field].label,
+                                    value: doc.analysis?.[field] ?? fallback,
+                                    placeholder: field === 'attributionWindowHours' ? C.inheritedWindow : field === 'sequentialTuningParameter' ? C.automaticTuning : undefined,
+                                    type: "number",
+                                    min: min,
+                                    reason: reason,
+                                    isValid: field === 'minExposuresPerArm' ? positiveInteger : undefined,
+                                    onCommit: (raw)=>change(field, raw.trim() ? Number(raw) : null)
+                                }),
+                                /*#__PURE__*/ _jsx("p", {
+                                    children: C[field].help
+                                }),
+                                /*#__PURE__*/ _jsx(FieldErrors, {
+                                    test: test,
+                                    path: `analysis.${field}`
+                                })
+                            ]
+                        }, field)),
+                    readOnlyFields.map((field)=>/*#__PURE__*/ _jsxs("div", {
+                            children: [
+                                /*#__PURE__*/ _jsx(ReadOnly, {
+                                    label: C[field].label,
+                                    value: field === 'slug' ? /*#__PURE__*/ _jsx("code", {
+                                        children: String(doc.slug)
+                                    }) : typeof doc[field] === 'string' || typeof doc[field] === 'number' ? String(doc[field]) : C.none,
+                                    reason: reasonFor(test, field)
+                                }),
+                                /*#__PURE__*/ _jsx("p", {
+                                    children: C[field].help
+                                })
+                            ]
+                        }, field))
+                ]
+            })
+        ]
     });
 }

package/dist/admin/surface/test/GoalSection.js

@@ -2,14 +2,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { fetchAllDocs } from '../../../lib/fetchAllDocs.js';
 import { Button } from '../../../ui/Button.js';
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { formatAdminURL } from 'payload/shared';
 import { TEST_PAGE as C } from '../../copy/testPage.js';
-import { metricSourceOptions } from '../../metricSource.model.js';
+import { METRIC_KIND_LABELS } from '../../copy/metrics.js';
+import { isClickSource } from '../../../goals/key.js';
+import { createApi } from '../../api.js';
+import { sourceFor } from '../../metricSource.model.js';
 import { reviewView } from '../../review/review.model.js';
 import { CheckboxList, FieldErrors, reasonFor, save, SelectEdit } from './fields.js';
 import { Section } from './Section.js';
 export function GoalSection({ test, surface }) {
+    const api = useMemo(()=>createApi(surface.apiRoute), [
+        surface.apiRoute
+    ]);
+    const [clickKeys, setClickKeys] = useState([]);
     const [metrics, setMetrics] = useState([]);
     const [failed, setFailed] = useState(false);
     const [loaded, setLoaded] = useState(false);
@@ -40,6 +47,40 @@ export function GoalSection({ test, surface }) {
         attempt
     ]);
     const doc = test.doc;
+    useEffect(()=>{
+        if (!surface.canManage) {
+            setClickKeys([]);
+            return;
+        }
+        let active = true;
+        let lastReturn = -Infinity;
+        let sequence = 0;
+        async function loadKeys() {
+            const request = ++sequence;
+            const result = await api.clickKeys(doc.id);
+            if (active && request === sequence) setClickKeys(result.ok && Array.isArray(result.data?.keys) ? result.data.keys : []);
+        }
+        const focus = ()=>{
+            if (document.visibilityState !== 'visible' || Date.now() - lastReturn < 100) return;
+            lastReturn = Date.now();
+            void loadKeys();
+        };
+        const visible = ()=>{
+            if (document.visibilityState === 'visible') focus();
+        };
+        void loadKeys();
+        window.addEventListener('focus', focus);
+        document.addEventListener('visibilitychange', visible);
+        return ()=>{
+            active = false;
+            window.removeEventListener('focus', focus);
+            document.removeEventListener('visibilitychange', visible);
+        };
+    }, [
+        api,
+        doc.id,
+        surface.canManage
+    ]);
     const reason = reasonFor(test, 'metrics');
     useEffect(()=>{
         if (!loaded) return;
@@ -66,12 +107,23 @@ export function GoalSection({ test, surface }) {
         doc.metrics,
         test
     ]);
-    const sources = metricSourceOptions(surface.metricSources);
     const unknownGoal = loaded ? C.missingGoal : C.goalUnavailable;
-    const options = metrics.map((metric)=>({
+    const options = metrics.map((metric)=>{
+        const kind = sourceFor(metric.source, surface.metricSources)?.kind;
+        return {
             value: String(metric.id),
-            label: `${metric.name} · ${sources.find((source)=>source.value === metric.source)?.badge ?? metric.source}`
-        }));
+            label: `${metric.name} · ${kind ? METRIC_KIND_LABELS[kind] : metric.source}`
+        };
+    });
+    const onPage = new Map(metrics.flatMap((metric)=>{
+        const found = isClickSource(metric.source) ? clickKeys.find((row)=>row.key === metric.source.slice(6)) : undefined;
+        return found ? [
+            [
+                String(metric.id),
+                `${metric.name} · ${found.label}`
+            ]
+        ] : [];
+    }));
     const chosen = [
         doc.metrics?.primary,
         ...doc.metrics?.guardrails ?? [],
@@ -94,6 +146,18 @@ export function GoalSection({ test, surface }) {
         ].map(String));
         return visible.filter((option)=>!blocked.has(option.value));
     };
+    const roleGroups = (role)=>onPage.size ? [
+            {
+                label: C.clickPageGroup,
+                options: roleOptions(role).filter((option)=>onPage.has(option.value)).map((option)=>({
+                        ...option,
+                        label: onPage.get(option.value)
+                    }))
+            },
+            {
+                options: roleOptions(role).filter((option)=>!onPage.has(option.value))
+            }
+        ] : undefined;
     const originalId = (value)=>metrics.find((metric)=>String(metric.id) === value)?.id ?? [
             test.doc.metrics?.primary,
             ...test.doc.metrics?.guardrails ?? [],
@@ -125,7 +189,7 @@ export function GoalSection({ test, surface }) {
         });
     const display = (ids)=>ids.length ? ids.map((id)=>options.find((option)=>option.value === String(id))?.label ?? unknownGoal).join(', ') : C.noGoal;
     const primary = metrics.find((metric)=>String(metric.id) === String(doc.metrics?.primary));
-    const kind = surface.metricSources.find((source)=>source.id === primary?.source)?.kind;
+    const kind = sourceFor(primary?.source, surface.metricSources)?.kind;
     const baseline = test.preflight?.baseline && String(test.preflight.baseline.metricId) === String(doc.metrics?.primary) ? reviewView(test.preflight, {
         primaryMetricKind: kind
     }).baseline : null;
@@ -171,6 +235,17 @@ export function GoalSection({ test, surface }) {
                     },
                     ...roleOptions('primary')
                 ],
+                groups: onPage.size ? [
+                    {
+                        options: [
+                            {
+                                value: '',
+                                label: C.chooseGoal
+                            }
+                        ]
+                    },
+                    ...roleGroups('primary')
+                ] : undefined,
                 reason: reason,
                 readOnlyValue: display(doc.metrics?.primary == null ? [] : [
                     doc.metrics.primary
@@ -180,6 +255,9 @@ export function GoalSection({ test, surface }) {
             /*#__PURE__*/ _jsx("p", {
                 children: C.goalHelp
             }),
+            primary && isClickSource(primary.source) ? /*#__PURE__*/ _jsx("p", {
+                children: C.clickGoalHelp
+            }) : null,
             baseline ? /*#__PURE__*/ _jsxs("p", {
                 children: [
                     primary?.name ? `${primary.name}: ` : '',
@@ -195,6 +273,7 @@ export function GoalSection({ test, surface }) {
                 label: C.guardrails,
                 value: (doc.metrics?.guardrails ?? []).map(String),
                 options: roleOptions('guardrails'),
+                groups: roleGroups('guardrails'),
                 reason: reason,
                 readOnlyValue: display(doc.metrics?.guardrails ?? []),
                 onToggle: (value, checked)=>toggle('guardrails', value, checked)
@@ -211,6 +290,7 @@ export function GoalSection({ test, surface }) {
                 label: C.secondary,
                 value: (doc.metrics?.secondary ?? []).map(String),
                 options: roleOptions('secondary'),
+                groups: roleGroups('secondary'),
                 reason: reason,
                 readOnlyValue: display(doc.metrics?.secondary ?? []),
                 onToggle: (value, checked)=>toggle('secondary', value, checked)
@@ -219,6 +299,9 @@ export function GoalSection({ test, surface }) {
                 test: test,
                 path: "metrics.secondary"
             }),
+            metrics.some((metric)=>isClickSource(metric.source)) ? /*#__PURE__*/ _jsx("p", {
+                children: C.clickGoalsNote
+            }) : null,
             test.errors.metrics ? /*#__PURE__*/ _jsx("p", {
                 role: "alert",
                 children: test.errors.metrics

package/dist/admin/surface/test/LengthSection.js

@@ -55,7 +55,7 @@ export function LengthSection({ test }) {
                                 type: "number",
                                 min: 1,
                                 reason: reason,
-                                validate: positiveInteger,
+                                isValid: positiveInteger,
                                 onCommit: (value)=>change('plannedDurationDays', value),
                                 help: weeksHint(doc.analysis?.plannedDurationDays ?? 28)
                             }),

package/dist/admin/surface/test/PageHoldout.d.ts

@@ -0,0 +1,3 @@
+import type { SectionProps } from '../contracts.js';
+/** Whole-page holdouts have no page of their own; their controls live under Advanced. */
+export declare function PageHoldout({ test }: SectionProps): import("react").JSX.Element;

package/dist/admin/surface/test/PageHoldout.js

@@ -0,0 +1,67 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { TEST_PAGE as C } from '../../copy/testPage.js';
+import { ARMS_COPY } from '../../copy/arms.js';
+import { addHoldoutArm, removeArm, splitEvenly } from '../../arms/arms.model.js';
+import { balanceWeight } from './testPage.model.js';
+import { FieldErrors, reasonFor, save, TextEdit } from './fields.js';
+import { Button } from '../../../ui/Button.js';
+/** Whole-page holdouts have no page of their own; their controls live under Advanced. */ export function PageHoldout({ test }) {
+    const doc = test.doc;
+    const arm = doc.arms.find((item)=>item.kind === 'holdout');
+    const index = doc.arms.findIndex((item)=>item.kind === 'holdout');
+    const reason = reasonFor(test, 'arms');
+    return /*#__PURE__*/ _jsxs("div", {
+        children: [
+            arm ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsx(TextEdit, {
+                        label: `${C.holdoutPrefix}${C.label}`,
+                        value: arm.label,
+                        reason: reason,
+                        onCommit: (label)=>save(test, 'arms', ()=>({
+                                    arms: doc.arms.map((item)=>item.key === arm.key ? {
+                                            ...item,
+                                            label
+                                        } : item)
+                                }))
+                    }),
+                    /*#__PURE__*/ _jsx(TextEdit, {
+                        label: `${C.holdoutPrefix}${C.weight}`,
+                        type: "number",
+                        min: 0,
+                        max: 100,
+                        value: arm.weight,
+                        reason: reason,
+                        isValid: (value)=>value.trim() !== '' && Number.isInteger(Number(value)) && Number(value) >= 0 && Number(value) <= 100,
+                        invalidMessage: C.invalidShare,
+                        onCommit: (value)=>save(test, 'arms', ()=>({
+                                    arms: balanceWeight(doc.arms, arm.key, Number(value))
+                                }))
+                    }),
+                    /*#__PURE__*/ _jsx(FieldErrors, {
+                        test: test,
+                        path: `arms.${index}`
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: !!reason,
+                        onClick: ()=>save(test, 'arms', ()=>({
+                                    arms: splitEvenly(removeArm(doc.arms, arm.key))
+                                })),
+                        children: C.remove
+                    })
+                ]
+            }) : /*#__PURE__*/ _jsx(Button, {
+                disabled: !!reason,
+                onClick: ()=>save(test, 'arms', ()=>({
+                            arms: addHoldoutArm(doc.arms)
+                        })),
+                children: C.addHoldout
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                className: "xp-ui-help",
+                children: ARMS_COPY.holdout
+            })
+        ]
+    });
+}

package/dist/admin/surface/test/TestPage.js

@@ -23,7 +23,8 @@ import './testPage.css';
 export function TestPage({ id, surface, onTitleChange }) {
     const [barHeight, setBarHeight] = useState();
     const test = useTestDocument(id, {
-        apiRoute: surface.apiRoute
+        apiRoute: surface.apiRoute,
+        refetchPreflightOnFocus: true
     });
     useEffect(()=>{
         if (test.doc?.name) onTitleChange?.(test.doc.name);

package/dist/admin/surface/test/VersionsSection.js

@@ -10,6 +10,8 @@ import { addHoldoutArm, addVariant, issuesByRow, removeArm, splitEvenly, totalWe
 import { allocationSentence } from '../../allocation.model.js';
 import { balanceWeight, orderedVersions, trafficShares } from './testPage.model.js';
 import { FieldErrors, ReadOnly, reasonFor, save, TextEdit } from './fields.js';
+import { PAGE_COPY } from '../../copy/pages.js';
+import { testPageCollection } from '../pagePicker/pagePicker.model.js';
 import { Section } from './Section.js';
 const COLOURS = {
     control: 'var(--xp-series-muted)',
@@ -49,6 +51,9 @@ export function VersionsSection({ test, surface, parts }) {
         test: test,
         sectionId: "versions",
         children: [
+            doc.kind === 'page' && testPageCollection(surface.pageCollections, doc, test.preflight?.pagePlacements)?.contentChecks === false ? /*#__PURE__*/ _jsx("p", {
+                children: PAGE_COPY.contentChecksOff
+            }) : null,
             reason ? /*#__PURE__*/ _jsx("p", {
                 className: "xp-ui-help",
                 children: reason
@@ -70,8 +75,10 @@ export function VersionsSection({ test, surface, parts }) {
                             /*#__PURE__*/ _jsx("span", {})
                         ]
                     }),
-                    ordered.map(({ arm, index })=>/*#__PURE__*/ _jsxs("article", {
+                    ordered.filter(({ arm })=>doc.kind !== 'page' || arm.kind !== 'holdout').map(({ arm, index })=>/*#__PURE__*/ _jsxs("article", {
                             className: "xp-version-row",
+                            id: `xp-version-${arm.key}`,
+                            tabIndex: -1,
                             children: [
                                 /*#__PURE__*/ _jsx(TextEdit, {
                                     label: `${GROUP_LABELS[arm.key]}: ${C.label}`,
@@ -93,7 +100,7 @@ export function VersionsSection({ test, surface, parts }) {
                                     reason: reason,
                                     hideLabel: true,
                                     disabled: Boolean(reason),
-                                    validate: (raw)=>raw.trim() !== '' && Number.isInteger(Number(raw)) && Number(raw) >= 0 && Number(raw) <= 100,
+                                    isValid: (raw)=>raw.trim() !== '' && Number.isInteger(Number(raw)) && Number(raw) >= 0 && Number(raw) <= 100,
                                     invalidMessage: C.invalidShare,
                                     onDraft: (value)=>setWeightEdit({
                                             key: arm.key,
@@ -177,11 +184,11 @@ export function VersionsSection({ test, surface, parts }) {
                         onClick: ()=>update((arms)=>addVariant(arms, doc.kind)),
                         children: C.addVersion
                     }),
-                    /*#__PURE__*/ _jsx(Button, {
+                    doc.kind !== 'page' ? /*#__PURE__*/ _jsx(Button, {
                         disabled: Boolean(reason) || doc.arms.some((arm)=>arm.kind === 'holdout'),
                         onClick: ()=>update(addHoldoutArm),
                         children: C.addHoldout
-                    }),
+                    }) : null,
                     /*#__PURE__*/ _jsx(Button, {
                         disabled: Boolean(reason),
                         onClick: ()=>update(splitEvenly),
@@ -189,7 +196,7 @@ export function VersionsSection({ test, surface, parts }) {
                     })
                 ]
             }),
-            doc.arms.some((arm)=>arm.kind === 'holdout') ? /*#__PURE__*/ _jsx("p", {
+            doc.kind !== 'page' && doc.arms.some((arm)=>arm.kind === 'holdout') ? /*#__PURE__*/ _jsx("p", {
                 className: "xp-ui-help",
                 children: ARMS_COPY.holdout
             }) : null,

package/dist/admin/surface/test/fields.d.ts

@@ -15,7 +15,7 @@ export declare function ReadOnly({ label, value, reason, labelAction }: {
     labelAction?: ReactNode;
 }): import("react").JSX.Element;
 /** Local typing is intentionally separate from staging: build the current group on commit. */
-export declare function TextEdit({ label, value, onCommit, reason, multiline, placeholder, type, min, max, required, onDraft, validate, invalidMessage, hideLabel, disabled, help }: {
+export declare function TextEdit({ label, value, onCommit, reason, multiline, placeholder, type, min, max, required, onDraft, isValid, invalidMessage, hideLabel, disabled, help }: {
     label: string;
     value: string | number;
     onCommit: (value: string) => void;
@@ -27,14 +27,21 @@ export declare function TextEdit({ label, value, onCommit, reason, multiline, pl
     min?: number;
     max?: number;
     required?: boolean;
-    validate?: (value: string) => boolean;
+    isValid?: (value: string) => boolean;
     invalidMessage?: string;
     hideLabel?: boolean;
     disabled?: boolean;
     help?: string;
 }): import("react").JSX.Element;
 export declare const positiveInteger: (raw: string) => boolean;
-export declare function SelectEdit({ label, value, options, reason, onCommit, readOnlyValue, labelAction }: {
+export type OptionGroup = {
+    label?: string;
+    options: readonly {
+        label: string;
+        value: string;
+    }[];
+};
+export declare function SelectEdit({ label, value, options, groups, reason, onCommit, readOnlyValue, labelAction }: {
     label: string;
     value: string;
     options: readonly {
@@ -45,8 +52,9 @@ export declare function SelectEdit({ label, value, options, reason, onCommit, re
     onCommit: (value: string) => void;
     readOnlyValue?: string;
     labelAction?: ReactNode;
+    groups?: readonly OptionGroup[];
 }): import("react").JSX.Element;
-export declare function CheckboxList({ label, value, options, reason, onToggle, readOnlyValue, searchable }: {
+export declare function CheckboxList({ label, value, options, groups, reason, onToggle, readOnlyValue, searchable }: {
     label: string;
     value: string[];
     options: readonly {
@@ -57,6 +65,7 @@ export declare function CheckboxList({ label, value, options, reason, onToggle,
     onToggle: (value: string, checked: boolean) => void;
     readOnlyValue?: string;
     searchable?: boolean;
+    groups?: readonly OptionGroup[];
 }): import("react").JSX.Element;
 export declare function TestName({ test }: SectionProps): import("react").JSX.Element;
 export declare function Hypothesis({ test }: SectionProps): import("react").JSX.Element;