@delmaredigital/payload-experiments 0.2.0-rc.7 → 0.3.0-rc.1

package/README.md

@@ -1,5 +1,7 @@
 # @delmaredigital/payload-experiments
 
+> ⚠️ Upgrading to 0.3? For 0.3.0-rc.1, every `linkIdentity` call must supply `verified`; it now returns an outcome. Run `payload migrate:create` for the nullable `xp_identities.verified_at` column and `user_id` index, plus the release-pages columns listed in the CHANGELOG (`decision_pages_released_at` / `decision_pages_released_by` on `xp_experiments` and their `version_` counterparts on `_xp_experiments_v`). Existing identity links become unverified; see the CHANGELOG for optional backfill.
+
 > ⚠️ Upgrading to 0.2? After upgrading, run `payload generate:importmap`: the Tests surface is registered through admin.dependencies, and without it the Tests routes show a 'not installed' message instead of the Tests screen. In 0.2.0-rc.2, the Tests server views moved from `/rsc` to `/admin/rsc`, so the import map must be regenerated when upgrading from rc.1 too. The old experiments edit-form components are gone from `/admin/client`, and the `xp-experiments` admin list and edit views now redirect to the Tests surface.
 
 A/B testing for Payload CMS and Next.js, with results inside the admin and data
@@ -87,7 +89,7 @@ permission is granted only for `true`. Optional `access.admin` and
 `access.readResults` default to `manage`; `access.readIdentities` defaults to
 `admin`. Use `admin` for code experiments and changing the analysis method.
 Other plugin options are `flagPoints`, `metricSources`, `eventSources`,
-`attributeKeys`, `puck` and `events`:
+`attributeKeys`, `pages`, `puck` and `events`:
 
 - `attributeKeys` declares targeting attributes as `{ type, values? }`, with
   `type` one of `string`, `number`, `boolean`; optional string `values` supplies
@@ -261,11 +263,8 @@ Other server integrations:
   outside a Next request; a user-only server conversion can supply `userId`.
   Record revenue through trusted server code or a metric source, never a client
   beacon.
-- `linkIdentity(serverRuntime, { headers, userId })` belongs on **every**
-  user-creation and sign-in path. It links the signed anonymous cookie to the
-  opaque user id using insert-ignore on its own connection and never throws into
-  sign-in. For visitor experiments using user-keyed outcomes, credit goes to the
-  earliest-exposed linked visitor; cross-group links are reported separately.
+- `linkIdentity(serverRuntime, { headers, userId, verified })` belongs on every
+  user-creation and proving sign-in path; see Identity linking below.
 - `eraseUser(payload, { userId })` deletes the user's identities and associated
   events transactionally and returns `{ identities, events }` counts. Call it
   from the host's authorized user-erasure flow.
@@ -279,11 +278,72 @@ Other server integrations:
   failure is logged and the content save proceeds.
 - `experimentMetadata(serverRuntime, path)` returns metadata to merge into the
   page's Next metadata: live variant targets get noindex and an Original
-  canonical; archived losing paths point canonically to the winner.
+  canonical; archived losing paths point canonically to the winner. It reads
+  the signed request context via `headers()`, so it decides from the URL the
+  visitor requested, not the rewritten route, and the Original's URL is never
+  noindex. Call it only from a dynamic `generateMetadata`, never inside
+  `'use cache'`; `path` is the fallback when the proxy did not run.
   `experimentSitemapFilter(path, manifest)` is a synchronous build-time filter:
   pass a privately server-loaded manifest and keep paths for which it returns
   `true`, excluding live variants and archived losing paths.
 
+## Identity linking
+
+Call `linkIdentity(serverRuntime, { headers, userId, verified })` on every
+user-creation and proving sign-in path. It links the signed anonymous cookie
+to an opaque user id on its own connection and never throws into sign-in.
+`verified` is required. Pass `true` only when **this request proves, in this
+browser, that the person owns the account**: a magic-link or one-time-code
+callback, password sign-in, or OAuth callback. It does not mean "a session
+exists" or "the account's email is verified". Registration alone uses `false`.
+
+```ts
+// Registration, before proof of account ownership:
+await linkIdentity(serverRuntime, { headers, userId, verified: false })
+// After successful magic-link/code verification in this browser:
+await linkIdentity(serverRuntime, { headers, userId, verified: true })
+// After a successful password sign-in (or OAuth callback):
+await linkIdentity(serverRuntime, { headers, userId, verified: true })
+```
+
+An auth "after" hook that fires whenever a new session cookie is set also
+fires on routine session refreshes; pass `verified: true` only from proving
+sign-in paths, never from a refresh.
+
+The result is `'linked'` for an inserted link, `'verified'` for an upgraded
+unverified link, `'skipped'` for no consent, no valid unit cookie or an existing
+link with nothing to change, and `'failed'` for an error (safely logged).
+First link per browser wins; a different account never replaces it.
+
+For visitor experiments with user-keyed events, verified links are always
+eligible. Unverified links are eligible only before the first verification
+across all of that user's browsers, or indefinitely if nobody ever verifies.
+Each event goes to the earliest exposed eligible visitor. Eligible links
+spanning groups are reported as a diagnostic. User-keyed CUPED covariates use
+the same eligibility rule at each visitor's first exposure and credit one
+aggregate value to the earliest eligible visitor per user.
+
+Accepted limits:
+
+- Cross-device: register in A, verify on B, keep using A. A's events after B's
+  proof are not credited until a proving sign-in on A upgrades A. Events before
+  B's proof, including the registration funnel, remain credited. Once A is
+  upgraded, its link is verified and eligible for all its events, so the next
+  results run also credits A's events from between B's proof and the upgrade.
+- Password set before verification: a later password sign-in is proof the
+  plugin accepts. Whether unverified registration may set a password is a host
+  authentication concern.
+- Shared device: a different user's verified sign-in never relinks an already
+  linked browser and returns `'skipped'`; that user's events get no credit
+  through that browser.
+- If someone registers another person's email from their own browser and that
+  person never signs in, a later user-keyed event the host records against that
+  account (for example an offline gift) is credited to the registering browser.
+  It needs a deliberate registration of someone else's email plus an event
+  matched to that account, and it moves one unit's value, never assignment.
+  There is no time window, so recurring gifts from never-signed-in donors keep
+  counting.
+
 ## Results
 
 The host owns scheduling and authentication. Call
@@ -368,7 +428,8 @@ a user-keyed source. Visitor experiments can use a user-keyed source through
 linked identities.
 
 Optional `covariate({ units: [{ unitId, firstExposureTs }], lookbackDays })`
-returns `[{ unitId, value }]` for pre-exposure CUPED adjustment (the plugin asks for a 14-day lookback). Percentile
+returns `[{ unitId, value }]`, one aggregate value per unit for pre-exposure
+CUPED adjustment (the plugin asks for a 14-day lookback). Percentile
 revenue capping reuses `query` over the 90 days before Start; the resolved cap
 is frozen for the round. Capping affects decision statistics, while results
 also show uncapped totals. Count and binomial metrics are never capped.
@@ -389,6 +450,41 @@ are recorded with `trackConversion`. Beacon conversions for a non-writable name
 are dropped silently. Only listed names become `events:<name>` sources. They
 support visitor and user units and do not represent counts or revenue in v1.
 
+### Whole-page options
+
+| Option | Purpose |
+| --- | --- |
+| `pages.collections` | Optional array of `{ slug, pathOf, findByPath }`. `pathOf(doc)` derives a public path from the slug (used to protect live test paths); `findByPath(path, req)` resolves a published page to `{ id, published: true }`, or returns `null`. Start and readiness check every non-holdout version, including the Original. Registered collections must exist when this plugin runs. Localized publication status and field-level `beforeChange` hooks that rewrite paths after the collection guard are unsupported; derive paths from fields finalized before collection hooks. Without this option, readiness warns that pages are unchecked and Start keeps its existing behaviour. |
+
+Do not swallow errors from nested updates of guarded page collections inside host hooks: a swallowed error leaves the guard's operation frame in place for the rest of the request because Payload's Local API does not call `afterError`.
+
+For a collection with drafts enabled, use a published-only slug lookup with the
+manager's request and `overrideAccess: false`:
+
+```ts
+pages: {
+  collections: [{
+    slug: 'pages',
+    pathOf: doc => typeof doc.slug === 'string' ? `/${doc.slug}` : null,
+    findByPath: async (path, req) => {
+      const { docs } = await req.payload.find({
+        collection: 'pages', req, overrideAccess: false, draft: false, depth: 0, limit: 1,
+        where: { and: [
+          { slug: { equals: path.slice(1) } },
+          { _status: { equals: 'published' } },
+        ] },
+      })
+      return docs[0] ? { id: docs[0].id, published: true } : null
+    },
+  }],
+},
+```
+
+Adapt both callbacks for the site's homepage path. These checks run before Start;
+they do not protect pages from later deletion, unpublishing or renaming. Keep an
+archived winner published at the same address: archived test URLs still point to it.
+No migration is needed.
+
 ### `admin` options
 
 Host links and kind descriptions are optional. For a host using payload-puck's
@@ -632,10 +728,32 @@ changes block actions**; save first so they use the saved experiment.
 - The Puck picker lists 100 experiments.
 - The Puck experiment picker always calls `/api`; hosts with a custom API route
   see an empty picker.
-- Making a winner permanent skips pages in collections that are localized,
-  have hidden fields, or contain fields the manager cannot read or update. Those pages
-  are listed with a note to update them by hand.
 - Content-change markers are recorded on publish only (on save for collections
   without drafts).
 - Results cover the whole round; breakdowns by segment or dimension are not
   available in v1.
+
+### Limits
+
+| Capability | Limit |
+|---|---|
+| Make it the content: localized collections | not supported yet |
+| Make it the content: field defaults | An update-denied field empty in both versions may publish its default because Payload applies defaults when reading. |
+
+## Theme
+
+The admin inherits Payload's neutral palette by default. Set one host accent:
+
+```ts
+theme: { accent: '#1f3a68' }
+```
+
+`theme.accent` accepts `#rgb` or `#rrggbb`; empty or undefined uses the default.
+The plugin derives darker hover/active fills (clamped to keep text contrast), a
+contrasting focus ring, and an opaque 8% subtle tint.
+In dark mode it raises HSL lightness when needed to reach 3:1 against the
+reference dark surface, then selects white or near-black foreground text.
+The WCAG 2.x gate requires at least 4.5:1 **foreground text on the accent fill**
+in each theme (the accent is used as a fill, not as page text). A failing
+colour is refused with its ratio. Status chips retain Payload semantic colours.
+`deriveAccent` is also exported from `/puck/editor` for editor integrations.

package/dist/admin/PreviewLinks.d.ts

@@ -1,6 +1,7 @@
 import type { DocId } from '../types/contracts.js';
 import type { PreflightResult } from '../types/endpoints.js';
-export declare function PreviewLinks({ experimentId, placements, arms }: {
+export declare function PreviewLinks({ experimentId, placements, arms, flagPoint }: {
+    flagPoint?: string;
     experimentId: DocId;
     placements: PreflightResult['placements'];
     arms: readonly {

package/dist/admin/PreviewLinks.js

@@ -1,13 +1,13 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
-import { Button } from '@payloadcms/ui';
+import { Button } from '../ui/Button.js';
 import { armLabel } from './labels.js';
 import { useApi } from './useApi.js';
 import { REVIEW_COPY as C } from './copy/review.js';
 import { API_MESSAGES } from './copy/common.js';
 import { previewPages } from './previewLinks.model.js';
-export function PreviewLinks({ experimentId, placements, arms }) {
+export function PreviewLinks({ experimentId, placements, arms, flagPoint }) {
     const api = useApi();
     const inFlight = useRef(false);
     const [busy, setBusy] = useState(false);
@@ -40,7 +40,8 @@ export function PreviewLinks({ experimentId, placements, arms }) {
     return /*#__PURE__*/ _jsxs("div", {
         className: "xp-preview-links",
         children: [
-            previewPages(placements).map((placement)=>/*#__PURE__*/ _jsxs("div", {
+            previewPages(placements, flagPoint).map((placement)=>/*#__PURE__*/ _jsxs("div", {
+                    className: "xp-preview-row",
                     children: [
                         /*#__PURE__*/ _jsxs("p", {
                             children: [
@@ -48,19 +49,26 @@ export function PreviewLinks({ experimentId, placements, arms }) {
                                 placement.slotCount > 1 ? ` ${C.placedTimes(placement.slotCount)}` : null
                             ]
                         }),
-                        placement.url ? arms.filter((arm)=>arm.kind !== 'holdout' && arm.key !== 'holdout').map((arm)=>/*#__PURE__*/ _jsxs(Button, {
-                                disabled: busy,
-                                onClick: ()=>{
-                                    void preview(placement.url, arm.key);
-                                },
-                                children: [
-                                    C.preview,
-                                    " ",
-                                    arm.label?.trim() || armLabel(arm.key)
-                                ]
-                            }, arm.key)) : /*#__PURE__*/ _jsx(Button, {
-                            disabled: true,
-                            children: C.noPreview
+                        /*#__PURE__*/ _jsx("div", {
+                            className: "xp-ui-button-group",
+                            children: placement.url ? arms.filter((arm)=>arm.kind !== 'holdout' && arm.key !== 'holdout').map((arm)=>/*#__PURE__*/ _jsxs(Button, {
+                                    variant: "secondary",
+                                    size: "sm",
+                                    disabled: busy,
+                                    onClick: ()=>{
+                                        void preview(placement.url, arm.key);
+                                    },
+                                    children: [
+                                        C.preview,
+                                        " ",
+                                        arm.label?.trim() || armLabel(arm.key)
+                                    ]
+                                }, arm.key)) : /*#__PURE__*/ _jsx(Button, {
+                                variant: "secondary",
+                                size: "sm",
+                                disabled: true,
+                                children: C.noPreview
+                            })
                         })
                     ]
                 }, placement.key)),

package/dist/admin/actions/ConfirmDialog.d.ts

@@ -1,13 +1,16 @@
-import '../theme.css';
 import type { ReactNode } from 'react';
 import type { DocId } from '../../types/contracts.js';
 import type { ExperimentAction } from './actions.model.js';
-export declare function DialogFrame({ title, onClose, children }: {
+export declare function DialogFrame({ title, onClose, children, initialFocus, dismissible }: {
+    dismissible?: boolean;
+    initialFocus?: 'cancel';
     title: string;
     onClose: () => void;
     children: ReactNode;
-}): import("react").ReactPortal;
-export declare function ConfirmDialog({ id, action, winnerLabel, onClose }: {
+}): import("react").JSX.Element;
+export declare function ConfirmDialog({ id, action, winnerLabel, onClose, canManage, isDecided }: {
+    canManage?: boolean;
+    isDecided?: boolean;
     id: DocId;
     action: ExperimentAction;
     winnerLabel: string;

package/dist/admin/actions/ConfirmDialog.js

@@ -1,99 +1,45 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import '../theme.css';
-import { theme } from '../theme.js';
-import { useEffect, useId, useRef, useState } from 'react';
-import { createPortal } from 'react-dom';
-import { Button, TextInput } from '@payloadcms/ui';
+import { useRef, useState } from 'react';
+import { Button } from '../../ui/Button.js';
+import { TextInput } from '../../ui/Inputs.js';
+import { Dialog } from '../../ui/Dialog.js';
 import { expectedConfirm, matchesConfirm } from '../../transitions/confirmPhrases.js';
 import { useApi } from '../useApi.js';
 import { reloadPage } from '../reload.js';
 import { ACTIONS_COPY as C } from '../copy/actions.js';
 import { API_MESSAGES } from '../copy/common.js';
 import { MakeContentResult } from './MakeContentResult.js';
-export function DialogFrame({ title, onClose, children }) {
-    const heading = useId();
-    const ref = useRef(null);
-    useEffect(()=>{
-        const previous = document.activeElement;
-        ref.current?.focus();
-        return ()=>{
-            if (previous instanceof HTMLElement && previous.isConnected) previous.focus();
-        };
-    }, []);
-    return /*#__PURE__*/ createPortal(/*#__PURE__*/ _jsx("div", {
-        style: {
-            position: 'fixed',
-            inset: 0,
-            zIndex: 1000,
-            background: theme.color.overlay,
-            display: 'grid',
-            placeItems: 'center'
-        },
-        children: /*#__PURE__*/ _jsxs("div", {
-            ref: ref,
-            role: "dialog",
-            "aria-modal": "true",
-            "aria-labelledby": heading,
-            tabIndex: -1,
-            style: {
-                background: theme.color.bg,
-                color: theme.color.text,
-                border: `1px solid ${theme.color.borderStrong}`,
-                padding: '2rem',
-                width: 'min(36rem, 90vw)',
-                maxHeight: '90vh',
-                overflow: 'auto',
-                borderRadius: theme.radius.small
-            },
-            onKeyDown: (event)=>{
-                if (event.defaultPrevented) return;
-                if (event.key === 'Escape') {
-                    event.preventDefault();
-                    event.stopPropagation();
-                    onClose();
-                }
-                if (event.key === 'Tab') {
-                    const items = Array.from(ref.current?.querySelectorAll('button:not(:disabled), input:not(:disabled), textarea:not(:disabled), select:not(:disabled), [tabindex="0"]') ?? []);
-                    const first = items[0], last = items.at(-1);
-                    if (!first) {
-                        event.preventDefault();
-                        ref.current?.focus();
-                    } else if (event.shiftKey && (document.activeElement === first || document.activeElement === ref.current)) {
-                        event.preventDefault();
-                        last?.focus();
-                    } else if (!event.shiftKey && (document.activeElement === last || document.activeElement === ref.current)) {
-                        event.preventDefault();
-                        first.focus();
-                    }
-                }
-            },
-            children: [
-                /*#__PURE__*/ _jsx("h2", {
-                    id: heading,
-                    children: title
-                }),
-                children
-            ]
-        })
-    }), document.body);
+export function DialogFrame({ title, onClose, children, initialFocus, dismissible = true }) {
+    return /*#__PURE__*/ _jsx(Dialog, {
+        open: true,
+        dismissible: dismissible,
+        initialFocus: initialFocus,
+        title: title,
+        onClose: onClose,
+        children: children
+    });
 }
-export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
+export function ConfirmDialog({ id, action, winnerLabel, onClose, canManage = false, isDecided = false }) {
     const api = useApi();
     const [typed, setTyped] = useState('');
     const [busy, setBusy] = useState(false);
+    const [reportBusy, setReportBusy] = useState(false);
     const inFlight = useRef(false);
     const [error, setError] = useState(null);
     const [content, setContent] = useState(null);
     const phrase = action.confirm.phrase ? expectedConfirm(action.confirm.phrase.action, winnerLabel) : null;
     const enabled = !busy && (!phrase || matchesConfirm(phrase, typed));
-    async function submit() {
+    async function submit(finish = false) {
         if (inFlight.current || !enabled) return;
         inFlight.current = true;
         setBusy(true);
         setError(null);
         let result;
-        if (action.archive) result = await api.archive(id, {
+        if (finish) result = await api.archive(id, {
+            mode: 'after-content'
+        });
+        else if (action.archive) result = await api.archive(id, {
             ...action.archive,
             ...phrase ? {
                 confirmation: typed.trim()
@@ -112,7 +58,7 @@ export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
             }
             result = response;
         }
-        if (result.ok && action.id !== 'make-content') {
+        if (result.ok && (finish || action.id !== 'make-content')) {
             reloadPage();
             return;
         }
@@ -126,18 +72,27 @@ export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
         });
     }
     function close() {
-        if (busy) return;
+        if (busy || reportBusy) return;
         if (content) reloadPage();
         onClose();
     }
     return /*#__PURE__*/ _jsxs(DialogFrame, {
+        dismissible: !busy && !reportBusy,
+        initialFocus: action.id === 'start' ? undefined : 'cancel',
         title: action.confirm.title,
         onClose: close,
         children: [
             content ? /*#__PURE__*/ _jsx(MakeContentResult, {
                 result: content,
-                onRetry: submit,
-                busy: busy
+                id: id,
+                api: api,
+                canManage: canManage,
+                isDecided: content.doc?.status ? content.doc.status === 'decided' : isDecided,
+                onRetry: ()=>submit(),
+                onFinish: ()=>submit(true),
+                busy: busy,
+                onBusyChange: setReportBusy,
+                onActionStart: ()=>setError(null)
             }) : /*#__PURE__*/ _jsxs(_Fragment, {
                 children: [
                     /*#__PURE__*/ _jsx("p", {
@@ -155,8 +110,7 @@ export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
                                 ]
                             }),
                             /*#__PURE__*/ _jsx(TextInput, {
-                                path: "xp-confirmation",
-                                hasMany: false,
+                                id: "xp-confirmation",
                                 label: C.confirmation,
                                 value: typed,
                                 readOnly: busy,
@@ -177,7 +131,7 @@ export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
                 },
                 children: action.label
             }),
-            error?.retryable ? /*#__PURE__*/ _jsx(Button, {
+            error?.retryable && !content ? /*#__PURE__*/ _jsx(Button, {
                 disabled: !enabled,
                 onClick: ()=>{
                     void submit();
@@ -185,7 +139,8 @@ export function ConfirmDialog({ id, action, winnerLabel, onClose }) {
                 children: C.retry
             }) : null,
             /*#__PURE__*/ _jsx(Button, {
-                disabled: busy,
+                "data-dialog-cancel": true,
+                disabled: busy || reportBusy,
                 onClick: close,
                 children: content ? C.done : C.cancel
             })

package/dist/admin/actions/DecideDialog.d.ts

@@ -1,7 +1,9 @@
 import type { DocId } from '../../types/contracts.js';
+import type { PreflightResult } from '../../types/endpoints.js';
 import type { ActionGroup } from './actions.model.js';
-export declare function DecideDialog({ id, arms, onClose }: {
+export declare function DecideDialog({ id, arms, checks, onClose }: {
     id: DocId;
     arms: readonly ActionGroup[];
+    checks?: PreflightResult['checks'];
     onClose: () => void;
 }): import("react").JSX.Element;

package/dist/admin/actions/DecideDialog.js

@@ -1,13 +1,16 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { Button, SelectInput, TextareaInput, TextInput } from '@payloadcms/ui';
+import { Button } from '../../ui/Button.js';
+import { Select, Textarea, TextInput } from '../../ui/Inputs.js';
+import { unsupportedContentCopy } from '../copy/readiness.js';
 import { useApi } from '../useApi.js';
 import { reloadPage } from '../reload.js';
+import { RESULTS_COPY } from '../copy/results.js';
 import { ACTIONS_COPY as C, decideCopy } from '../copy/actions.js';
 import { decideState } from './decide.model.js';
 import { DialogFrame } from './ConfirmDialog.js';
-export function DecideDialog({ id, arms, onClose }) {
+export function DecideDialog({ id, arms, checks = [], onClose }) {
     const api = useApi();
     const [snapshot, setSnapshot] = useState(null);
     const [chosenArm, setChosenArm] = useState(null);
@@ -85,6 +88,8 @@ export function DecideDialog({ id, arms, onClose }) {
     const enabled = !busy && !loading && !loadFailed && state.canSubmit;
     const label = state.options.find((option)=>option.value === chosenArm)?.label;
     return /*#__PURE__*/ _jsxs(DialogFrame, {
+        dismissible: !busy,
+        initialFocus: "cancel",
         title: C.decide,
         onClose: ()=>{
             if (!busy) onClose();
@@ -94,27 +99,39 @@ export function DecideDialog({ id, arms, onClose }) {
                 role: "status",
                 children: C.loading
             }) : null,
-            /*#__PURE__*/ _jsx(SelectInput, {
-                path: "xp-winner",
+            /*#__PURE__*/ _jsxs(Select, {
+                id: "xp-winner",
                 name: "xp-winner",
                 label: C.group,
-                options: state.options,
                 value: chosenArm ?? '',
-                readOnly: busy || loading,
+                disabled: busy || loading,
                 required: true,
-                onChange: (option)=>{
-                    setChosenArm(option && !Array.isArray(option) ? String(option.value) : null);
+                onChange: (event)=>{
+                    setChosenArm(event.target.value || null);
                     setTyped('');
-                }
+                },
+                children: [
+                    /*#__PURE__*/ _jsx("option", {
+                        value: "",
+                        children: RESULTS_COPY.chooseGroup
+                    }),
+                    state.options.map((option)=>/*#__PURE__*/ _jsx("option", {
+                            value: option.value,
+                            children: option.label
+                        }, option.value))
+                ]
             }),
             label ? /*#__PURE__*/ _jsx("p", {
                 children: decideCopy(label, arms.some((group)=>group.key === 'holdout'), chosenArm === 'control')
             }) : null,
+            checks.filter((check)=>check.code === 'make-content-unsupported' && check.warning).map((check)=>/*#__PURE__*/ _jsx("p", {
+                    children: unsupportedContentCopy(typeof check.detail === 'string' ? check.detail : 'This page')
+                }, check.code)),
             state.reason ? /*#__PURE__*/ _jsx("p", {
                 children: state.reason
             }) : null,
-            /*#__PURE__*/ _jsx(TextareaInput, {
-                path: "xp-note",
+            /*#__PURE__*/ _jsx(Textarea, {
+                id: "xp-note",
                 label: C.note,
                 value: note,
                 required: state.guarded,
@@ -133,8 +150,7 @@ export function DecideDialog({ id, arms, onClose }) {
                         ]
                     }),
                     /*#__PURE__*/ _jsx(TextInput, {
-                        path: "xp-decide-confirmation",
-                        hasMany: false,
+                        id: "xp-decide-confirmation",
                         label: C.confirmation,
                         value: typed,
                         readOnly: busy,
@@ -164,6 +180,7 @@ export function DecideDialog({ id, arms, onClose }) {
                 children: C.retry
             }) : null,
             /*#__PURE__*/ _jsx(Button, {
+                "data-dialog-cancel": true,
                 disabled: busy,
                 onClick: onClose,
                 children: C.cancel

package/dist/admin/actions/MakeContentResult.d.ts

@@ -1,6 +1,17 @@
+import type { DocId } from '../../types/contracts.js';
 import type { MakeContentResult as Result } from '../../types/endpoints.js';
-export declare function MakeContentResult({ result, onRetry, busy }: {
+import type { createApi } from '../api.js';
+type Props = {
     result: Result;
     onRetry: () => void | Promise<void>;
     busy?: boolean;
-}): import("react").JSX.Element;
+    id?: DocId;
+    api?: ReturnType<typeof createApi>;
+    canManage?: boolean;
+    isDecided?: boolean;
+    onFinish?: () => void | Promise<void>;
+    onBusyChange?: (busy: boolean) => void;
+    onActionStart?: () => void;
+};
+export declare function MakeContentResult({ result, onRetry, busy, id, api, canManage, isDecided, onFinish, onBusyChange, onActionStart }: Props): import("react").JSX.Element;
+export {};