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

package/dist/admin/surface/pagePicker/pagePicker.model.js

@@ -0,0 +1,25 @@
+import { normalisePath } from '../../../runtime/normalisePath.js';
+import { PAGE_COPY, usedAddressCopy, usedPageCopy } from '../../copy/pages.js';
+import { actionGroupLabel } from '../../actions/actions.model.js';
+/** The server resolves legacy collections; the client consumes its placements verbatim. */ export function testPageCollection(collections, doc, placements) {
+    const slug = doc.pageCollection || placements?.find((entry)=>entry.collection)?.collection;
+    return collections?.find((entry)=>entry.slug === slug);
+}
+export const controlFirst = (arms)=>[
+        ...arms
+    ].sort((a, b)=>Number(b.kind === 'control') - Number(a.kind === 'control'));
+/** Identity wins over address, so distinct documents sharing an address get actionable copy. */ export function disabledPageReason(row, ownKey, arms, placements, chosen, collection, collectionSlug) {
+    if (row.path === null || row.pathKey === null) return PAGE_COPY.noPath;
+    const others = controlFirst(arms).filter((arm)=>arm.key !== ownKey && arm.kind !== 'holdout');
+    for (const arm of others){
+        const selection = chosen[arm.key];
+        const remembered = selection && arm.pageTarget && normalisePath(selection.path) === normalisePath(arm.pageTarget) ? selection.id : undefined;
+        const id = remembered ?? placements?.find((entry)=>entry.arm === arm.key && (!collectionSlug || entry.collection === collectionSlug))?.id;
+        if (id != null ? String(id) === String(row.id) : Boolean(arm.pageTarget && normalisePath(arm.pageTarget) === row.pathKey)) {
+            return usedPageCopy(actionGroupLabel(arm.key, arm.label));
+        }
+    }
+    const same = others.find((arm)=>arm.pageTarget && normalisePath(arm.pageTarget) === row.pathKey);
+    return same ? usedAddressCopy(actionGroupLabel(same.key, same.label), row.path, collection) : null;
+}
+/** Pure request revision comparison, also used after an aborted transport resolves. */ export const isLatestPageRequest = (response, latest)=>response === latest;

package/dist/admin/surface/readiness/ActionDialogs.js

@@ -1,13 +1,15 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { DocsResponseError, fetchAllDocs } from '../../../lib/fetchAllDocs.js';
+import { usePlacementLabels, placementDetailKey } from '../../placements/usePlacementLabels.js';
+import { placementUncheckedCopy } from '../../copy/readiness.js';
 import { useEffect, useState } from 'react';
 import { Button } from '../../../ui/Button.js';
 import { TextInput } from '../../../ui/Inputs.js';
 import { Dialog } from '../../../ui/Dialog.js';
 import { MakeContentResult } from '../../actions/MakeContentResult.js';
 import { expectedConfirm, matchesConfirm } from '../../../transitions/confirmPhrases.js';
-import { ACTIONS_COPY as A } from '../../copy/actions.js';
+import { ACTIONS_COPY as A, addMetricWarningCopy } from '../../copy/actions.js';
 import { REVIEW_COPY as R } from '../../copy/review.js';
 import { READINESS_COPY as C } from '../../copy/readiness.js';
 import { API_MESSAGES, refusalMessage } from '../../copy/common.js';
@@ -187,6 +189,12 @@ import { useTransition } from './useTransition.js';
     const [loading, setLoading] = useState(true);
     const [loadError, setLoadError] = useState(null);
     const [metric, setMetric] = useState('');
+    const [warnings, setWarnings] = useState(null);
+    const placementLabels = usePlacementLabels({
+        details: (warnings ?? []).filter((warning)=>warning.code === 'placement-unchecked').map((warning)=>warning.detail),
+        preflight: test.preflight,
+        ...surface
+    });
     const [role, setRole] = useState('secondary');
     const transition = useTransition(test, onClose);
     useEffect(()=>{
@@ -217,85 +225,112 @@ import { useTransition } from './useTransition.js';
     const available = metrics.filter((item)=>!attached.has(String(item.id)));
     const selected = available.find((item)=>String(item.id) === metric);
     const disabled = transition.busy || test.hasUnsaved || test.saving === 'saving';
+    function close() {
+        if (transition.busy) return;
+        if (warnings) void test.reload();
+        onClose();
+    }
     return /*#__PURE__*/ _jsxs(Dialog, {
         open: true,
         dismissible: !transition.busy,
         title: C.addGoal,
-        onClose: ()=>{
-            if (!transition.busy) onClose();
-        },
+        onClose: close,
         children: [
-            /*#__PURE__*/ _jsx("p", {
-                children: C.addMetric
-            }),
-            loading ? /*#__PURE__*/ _jsx("p", {
-                role: "status",
-                children: R.loadingMetrics
-            }) : null,
-            /*#__PURE__*/ _jsxs("label", {
+            warnings ? warnings.map((warning, index)=>{
+                const placement = warning.code === 'placement-unchecked' ? placementLabels.get(placementDetailKey(warning.detail)) : undefined;
+                return /*#__PURE__*/ _jsx("p", {
+                    children: placement ? placement.href ? /*#__PURE__*/ _jsx("a", {
+                        href: placement.href,
+                        children: placementUncheckedCopy(placement.title)
+                    }) : placementUncheckedCopy(placement.title) : addMetricWarningCopy(warning)
+                }, index);
+            }) : /*#__PURE__*/ _jsxs(_Fragment, {
                 children: [
-                    R.role,
-                    /*#__PURE__*/ _jsxs("select", {
-                        value: role,
-                        disabled: disabled,
-                        onChange: (event)=>setRole(event.target.value),
+                    /*#__PURE__*/ _jsx("p", {
+                        children: C.addMetric
+                    }),
+                    loading ? /*#__PURE__*/ _jsx("p", {
+                        role: "status",
+                        children: R.loadingMetrics
+                    }) : null,
+                    /*#__PURE__*/ _jsxs("label", {
                         children: [
-                            /*#__PURE__*/ _jsx("option", {
-                                value: "secondary",
-                                children: R.supporting
-                            }),
-                            /*#__PURE__*/ _jsx("option", {
-                                value: "guardrail",
-                                children: R.guardrail
+                            R.role,
+                            /*#__PURE__*/ _jsxs("select", {
+                                value: role,
+                                disabled: disabled,
+                                onChange: (event)=>setRole(event.target.value),
+                                children: [
+                                    /*#__PURE__*/ _jsx("option", {
+                                        value: "secondary",
+                                        children: R.supporting
+                                    }),
+                                    /*#__PURE__*/ _jsx("option", {
+                                        value: "guardrail",
+                                        children: R.guardrail
+                                    })
+                                ]
                             })
                         ]
-                    })
-                ]
-            }),
-            /*#__PURE__*/ _jsxs("label", {
-                children: [
-                    R.metric,
-                    /*#__PURE__*/ _jsxs("select", {
-                        value: metric,
-                        disabled: disabled || loading,
-                        onChange: (event)=>setMetric(event.target.value),
+                    }),
+                    /*#__PURE__*/ _jsxs("label", {
                         children: [
-                            /*#__PURE__*/ _jsx("option", {
-                                value: "",
-                                children: R.chooseMetric
-                            }),
-                            available.map((item)=>/*#__PURE__*/ _jsx("option", {
-                                    value: String(item.id),
-                                    children: item.name
-                                }, item.id))
+                            R.metric,
+                            /*#__PURE__*/ _jsxs("select", {
+                                value: metric,
+                                disabled: disabled || loading,
+                                onChange: (event)=>setMetric(event.target.value),
+                                children: [
+                                    /*#__PURE__*/ _jsx("option", {
+                                        value: "",
+                                        children: R.chooseMetric
+                                    }),
+                                    available.map((item)=>/*#__PURE__*/ _jsx("option", {
+                                            value: String(item.id),
+                                            children: item.name
+                                        }, item.id))
+                                ]
+                            })
                         ]
+                    }),
+                    !loading && !loadError && !available.length ? /*#__PURE__*/ _jsx("p", {
+                        children: R.noMetrics
+                    }) : null,
+                    loadError || transition.error ? /*#__PURE__*/ _jsx("p", {
+                        role: "alert",
+                        children: loadError ?? transition.error
+                    }) : null,
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: disabled || loading || !!loadError || !selected,
+                        onClick: ()=>{
+                            // Goal and phase lookups share not-found; prefer the more likely missing goal without reading server text.
+                            if (selected && test.doc) void transition.run(async ()=>{
+                                const result = await createApi(surface.apiRoute).addMetric(test.doc.id, {
+                                    metric: selected.id,
+                                    role
+                                }, {
+                                    notFound: API_MESSAGES.goalNotFound
+                                });
+                                if (result.ok) {
+                                    if (result.data?.warnings?.length) setWarnings(result.data.warnings);
+                                    else {
+                                        await test.reload();
+                                        onClose();
+                                    }
+                                }
+                                return result;
+                            }, {
+                                reloadOnSuccess: false
+                            });
+                        },
+                        children: C.addGoal
                     })
                 ]
             }),
-            !loading && !loadError && !available.length ? /*#__PURE__*/ _jsx("p", {
-                children: R.noMetrics
-            }) : null,
-            loadError || transition.error ? /*#__PURE__*/ _jsx("p", {
-                role: "alert",
-                children: loadError ?? transition.error
-            }) : null,
-            /*#__PURE__*/ _jsx(Button, {
-                disabled: disabled || loading || !!loadError || !selected,
-                onClick: ()=>{
-                    // Goal and phase lookups share not-found; prefer the more likely missing goal without reading server text.
-                    if (selected && test.doc) void transition.run(()=>createApi(surface.apiRoute).addMetric(test.doc.id, {
-                            metric: selected.id,
-                            role
-                        }, {
-                            notFound: API_MESSAGES.goalNotFound
-                        }));
-                },
-                children: C.addGoal
-            }),
             /*#__PURE__*/ _jsx(Button, {
                 disabled: transition.busy,
-                onClick: onClose,
-                children: A.cancel
+                onClick: close,
+                children: warnings ? A.done : A.cancel
             })
         ]
     });

package/dist/admin/surface/readiness/Banner.js

@@ -7,8 +7,10 @@ import { jumpToSection } from '../test/jumpToSection.js';
 import { actionGroupLabel, availableActions } from '../../actions/actions.model.js';
 import { createApi } from '../../api.js';
 import { READINESS_COPY as C, decidedCopy, nextCopy, runningCopy, stoppedCopy } from '../../copy/readiness.js';
-import { READINESS, daysRemaining, displayDate, nextStep } from './readiness.model.js';
+import { READINESS, daysRemaining, displayDate, nextStep, pageReadinessContext } from './readiness.model.js';
 import { AddMetricAction, AllocateAction, ConfirmAction } from './ActionDialogs.js';
+import { preflightPlacementLabel } from '../../placements/placementLabels.js';
+import { placementUncheckedCopy } from '../../copy/readiness.js';
 import { useTransition } from './useTransition.js';
 const RUNNING_ACTIONS = [
     'stop',
@@ -49,10 +51,17 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
     ]);
     const decision = doc.decision;
     const winner = actionGroupLabel(decision?.winnerArm ?? 'control', doc.arms.find((item)=>item.key === decision?.winnerArm)?.label);
-    const next = nextStep(test.preflight, {
-        ...doc,
-        flagPoints: surface.flagPoints
-    });
+    const labelledPreflight = test.preflight ? {
+        ...test.preflight,
+        checks: test.preflight.checks.map((check)=>check.code === 'placement-unchecked' ? {
+                ...check,
+                detail: {
+                    ...check.detail,
+                    title: preflightPlacementLabel(check.detail, test.preflight, surface.adminRoute).title
+                }
+            } : check)
+    } : null;
+    const next = nextStep(labelledPreflight, pageReadinessContext(doc, test.preflight, surface));
     const setup = doc.status === 'draft' || doc.status === 'stopped';
     const ready = Boolean(test.preflight && !test.preflightPending && !test.preflightError && test.preflight.checks.every((check)=>check.ok));
     const unsaved = test.hasUnsaved || test.saving === 'saving';
@@ -96,7 +105,7 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
                             href: `#section-${next.section}`,
                             onClick: (event)=>{
                                 event.preventDefault();
-                                if (next.section !== 'header') jumpToSection(next.section);
+                                if (next.section !== 'header') jumpToSection(next.section, next.arm);
                             },
                             children: [
                                 sentence,
@@ -119,6 +128,21 @@ export function ReadinessContent({ test, surface, resultsVersion, bar = false })
             test.preflight?.checks.filter((check)=>check.code === 'make-content-unsupported' && check.warning).map((check)=>/*#__PURE__*/ _jsx("p", {
                     children: READINESS[check.code].next(check.detail, doc)
                 }, check.code)),
+            test.preflight?.checks.filter((check)=>check.warning && [
+                    'goal-in-some-versions',
+                    'placement-unchecked'
+                ].includes(check.code)).map((check, index)=>{
+                const placement = check.code === 'placement-unchecked' ? preflightPlacementLabel(check.detail, test.preflight, surface.adminRoute) : undefined;
+                return /*#__PURE__*/ _jsx("p", {
+                    children: placement ? placement.href ? /*#__PURE__*/ _jsx("a", {
+                        href: placement.href,
+                        children: placementUncheckedCopy(placement.title)
+                    }) : placementUncheckedCopy(placement.title) : READINESS[check.code].next(check.detail, doc)
+                }, `${check.code}:${index}`);
+            }),
+            test.preflight?.goalNotes?.map((note)=>/*#__PURE__*/ _jsx("p", {
+                    children: note.message
+                }, note.metricId)),
             doc.status === 'stopped' ? /*#__PURE__*/ _jsx("p", {
                 children: stoppedCopy(displayDate(doc.stoppedAt))
             }) : null,

package/dist/admin/surface/readiness/readiness.model.d.ts

@@ -1,18 +1,22 @@
 import type { ReadinessCode, PreflightResult } from '../../../types/endpoints.js';
 import type { SerializedFlagPoint } from '../../../types/admin.js';
 import type { TestDocument } from '../testDocument.model.js';
+import type { SurfaceProps } from '../contracts.js';
 import { type SectionId } from '../contracts.js';
 export type ReadinessContext = Pick<TestDocument, 'arms' | 'unitType' | 'flagPoint'> & {
+    collectionLabel?: string;
+    pagePlacements?: PreflightResult['pagePlacements'];
     flagPoints?: readonly Pick<SerializedFlagPoint, 'id' | 'params'>[];
 };
 /** Exhaustive mapping of the checkStart ReadinessCode union, including all ten invariant checks. */
 export declare const READINESS: Record<ReadinessCode, {
     section: SectionId | 'header';
     next(detail: unknown, ctx: ReadinessContext): string | null;
-    nextStep?: string;
+    nextStep?: string | ((detail: unknown, ctx: ReadinessContext) => string);
 }>;
 export declare function nextStep(preflight: PreflightResult | null, ctx: ReadinessContext): {
     nextStep?: string | undefined;
+    arm?: import("../../../types/contracts.js").ArmKey | undefined;
     section: "header" | SectionId;
     sentence: string;
     code: ReadinessCode;
@@ -22,3 +26,6 @@ export declare function sectionDone(test: {
 }): Record<SectionId, boolean>;
 export declare function displayDate(value: unknown): string | null;
 export declare function daysRemaining(doc: TestDocument, now: number): number | null;
+export declare function pageReadinessContext(doc: TestDocument, preflight: PreflightResult | null, surface: SurfaceProps): ReadinessContext;
+/** First affected row in arm order; shared by the wizard and the test-page jump. */
+export declare function readinessArm(code: ReadinessCode, detail: unknown, ctx: ReadinessContext): import("../../../types/contracts.js").ArmKey | undefined;

package/dist/admin/surface/readiness/readiness.model.js

@@ -1,6 +1,9 @@
+import { SURFACE_COPY } from '../../copy/surface.js';
 import { formatDate } from '../../format/date.js';
 import { actionGroupLabel } from '../../actions/actions.model.js';
-import { unsupportedContentCopy, versionPageUnavailableCopy, versionPageUncheckedCopy, placementFailureCopy, pageInUseCopy, unpublishedPageCopy, READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
+import { asymmetricGoalsCopy, placementUncheckedCopy, interactingTestsCopy, sameAddressCopy, identicalVersionCopy, unsupportedContentCopy, versionPageUnavailableCopy, versionPageUncheckedCopy, placementFailureCopy, pageInUseCopy, unpublishedPageCopy, READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
+import { normalisePath } from '../../../runtime/normalisePath.js';
+import { testPageCollection } from '../pagePicker/pagePicker.model.js';
 import { SECTION_ORDER } from '../contracts.js';
 const object = (value)=>value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 const first = (value)=>object(Array.isArray(value) ? value[0] : value);
@@ -17,8 +20,30 @@ const row = (section, next)=>({
 const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.versionFallback)));
 /** Exhaustive mapping of the checkStart ReadinessCode union, including all ten invariant checks. */ export const READINESS = {
     'make-content-unsupported': row('header', (detail)=>unsupportedContentCopy(text(detail, 'This page'))),
+    'goal-in-some-versions': {
+        ...row('win', (detail)=>asymmetricGoalsCopy(detail)),
+        nextStep: 'Edit the versions'
+    },
+    'placement-unchecked': {
+        ...row('versions', (detail)=>placementUncheckedCopy(text(object(detail).title ?? object(detail).path, 'This page'))),
+        nextStep: (detail)=>`Open ${text(object(detail).title ?? object(detail).path, 'the page')}`
+    },
     'invalid-status': row('header', ()=>null),
     'no-placements': row('what', (detail)=>detail === undefined ? C.noPlacements : placementFailureCopy(detail)),
+    'placement-unpublished': {
+        ...row('versions', (detail)=>(Array.isArray(detail) && detail.length ? detail : [
+                detail
+            ]).map((placement)=>`The block you're testing is only on a draft of ${text(object(placement).title, 'this page')}. Publish the page before you start.`).join('\n')),
+        nextStep: 'Publish the page'
+    },
+    'duplicate-version-row': {
+        ...row('versions', (detail)=>`The Experiment block on ${text(first(detail).title, 'this page')} has the same version twice. Remove one of them, then save.`),
+        nextStep: (detail)=>`Edit ${text(first(detail).title, 'this page')}`
+    },
+    'interacting-tests': {
+        ...row('versions', (detail)=>interactingTestsCopy(text(first(detail).path, 'this page'), text(first(detail).status, 'running'), text(first(detail).name, 'another test'), first(detail).version === true)),
+        nextStep: (detail)=>`Open ${text(first(detail).name, 'the test')}${first(detail).version === true ? `\nEdit ${text(first(detail).path, 'this page')}` : ''}`
+    },
     'empty-slot': row('versions', (detail, ctx)=>{
         const placements = Array.isArray(detail) ? detail : [];
         const missing = ctx.arms.find((item)=>item.kind !== 'holdout' && placements.some((placement)=>{
@@ -50,14 +75,39 @@ const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.ver
     'layer-full': row('versions', ()=>C.full),
     'layer-unit-mismatch': row('header', ()=>C.differentPeople),
     'page-in-use': {
-        ...row('versions', (detail)=>{
+        ...row('versions', (detail, ctx)=>{
             const paths = object(detail).paths;
-            return pageInUseCopy(text(Array.isArray(paths) ? paths[0] : undefined, 'this page'));
+            const path = text(Array.isArray(paths) ? paths[0] : undefined, 'this page');
+            return pageInUseCopy(path, pageArm(path, ctx)?.kind === 'variant');
         }),
-        nextStep: C.chooseDifferentPage
+        nextStep: C.choosePages
+    },
+    'page-no-targets': {
+        ...row('versions', ()=>C.noTargets),
+        nextStep: 'Choose pages'
+    },
+    'unknown-collection': row('versions', ()=>"That page type isn't set up for tests."),
+    'version-identical': {
+        ...row('versions', (detail, ctx)=>identicalVersionCopy(text(object(detail).path, object(detail).title ? `${group(object(detail).arm, ctx)} on ${text(object(detail).title, 'this page')}` : group(object(detail).arm, ctx)))),
+        nextStep: (detail, ctx)=>`Edit ${text(object(detail).path, group(object(detail).arm, ctx))}`
+    },
+    'version-same-address': {
+        ...row('versions', (detail, ctx)=>sameAddressCopy(group(object(detail).arm, ctx), group(object(detail).otherArm, ctx), text(object(detail).path, 'this address'), ctx.collectionLabel)),
+        nextStep: 'Choose pages'
+    },
+    'page-target-unpublished': {
+        ...row('versions', (detail, ctx)=>{
+            const path = text(typeof detail === 'string' ? detail : object(detail).path, 'This page');
+            const arm = ctx.arms.find((item)=>item.key === object(detail).arm) ?? pageArm(path, ctx);
+            const placement = (arm ? ctx.pagePlacements?.find((entry)=>entry.arm === arm.key) : undefined) ?? ctx.pagePlacements?.find((entry)=>normalisePath(entry.path) === normalisePath(path));
+            return unpublishedPageCopy(path, ctx.pagePlacements && ctx.collectionLabel ? {
+                original: arm?.kind === 'control',
+                found: placement?.id != null && placement.published === false,
+                collection: ctx.collectionLabel
+            } : undefined);
+        }),
+        nextStep: C.choosePages
     },
-    'page-no-targets': row('versions', ()=>C.noTargets),
-    'page-target-unpublished': row('versions', (detail)=>unpublishedPageCopy(text(detail, 'This page'))),
     'page-targets-unchecked': row('versions', ()=>C.uncheckedPages),
     'version-page-unavailable': row('versions', (detail)=>versionPageUnavailableCopy(text(detail, 'This page'))),
     'version-page-unchecked': row('versions', (detail)=>versionPageUncheckedCopy(text(detail, 'This page'))),
@@ -91,15 +141,28 @@ export function nextStep(preflight, ctx) {
         ...SECTION_ORDER
     ]){
         for (const check of preflight?.checks ?? []){
+            if (!Object.hasOwn(READINESS, check.code)) {
+                if (!check.ok && section === SECTION_ORDER[0]) return {
+                    section,
+                    sentence: SURFACE_COPY.next,
+                    code: check.code
+                };
+                continue;
+            }
             const mapping = READINESS[check.code];
             if (check.ok || mapping.section !== section) continue;
             const sentence = mapping.next(check.detail, ctx);
+            const nextStep = typeof mapping.nextStep === 'function' ? mapping.nextStep(check.detail, ctx) : mapping.nextStep;
+            const arm = readinessArm(check.code, check.detail, ctx);
             if (sentence) return {
                 section,
                 sentence,
                 code: check.code,
-                ...mapping.nextStep ? {
-                    nextStep: mapping.nextStep
+                ...arm ? {
+                    arm
+                } : {},
+                ...nextStep ? {
+                    nextStep
                 } : {}
             };
         }
@@ -109,7 +172,7 @@ export function nextStep(preflight, ctx) {
 export function sectionDone(test) {
     return Object.fromEntries(SECTION_ORDER.map((section)=>[
             section,
-            test.preflight ? !test.preflight.checks.some((check)=>!check.ok && READINESS[check.code].section === section) : section === 'who' || section === 'advanced'
+            test.preflight ? !test.preflight.checks.some((check)=>!check.ok && (Object.hasOwn(READINESS, check.code) ? READINESS[check.code].section : SECTION_ORDER[0]) === section) : section === 'who' || section === 'advanced'
         ]));
 }
 export function displayDate(value) {
@@ -121,3 +184,22 @@ export function daysRemaining(doc, now) {
     const start = typeof doc.startedAt === 'string' ? Date.parse(doc.startedAt) : NaN;
     return typeof days === 'number' && days > 0 && Number.isFinite(start) ? Math.max(0, Math.ceil(days - (now - start) / 86_400_000)) : null;
 }
+function pageArm(path, ctx) {
+    return ctx.arms.find((arm)=>arm.pageTarget && normalisePath(arm.pageTarget) === normalisePath(path));
+}
+export function pageReadinessContext(doc, preflight, surface) {
+    return {
+        ...doc,
+        flagPoints: surface.flagPoints,
+        pagePlacements: preflight?.pagePlacements,
+        collectionLabel: testPageCollection(surface.pageCollections, doc, preflight?.pagePlacements)?.label
+    };
+}
+/** First affected row in arm order; shared by the wizard and the test-page jump. */ export function readinessArm(code, detail, ctx) {
+    if (code === 'version-same-address') return ctx.arms.find((arm)=>arm.key === object(detail).arm)?.key;
+    if (code === 'page-no-targets') return ctx.arms.find((arm)=>arm.kind !== 'holdout' && !arm.pageTarget)?.key;
+    const paths = code === 'page-in-use' ? object(detail).paths : code === 'page-target-unpublished' ? [
+        detail
+    ] : [];
+    return ctx.arms.find((arm)=>arm.kind !== 'holdout' && arm.pageTarget && Array.isArray(paths) && paths.some((path)=>typeof path === 'string' && normalisePath(path) === normalisePath(arm.pageTarget)))?.key;
+}

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

@@ -8,7 +8,9 @@ export declare function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, o
     onRefusal(message: string): void;
 }): import("react").JSX.Element;
 /** An inaccessible or deleted author never hides the recorded release date. */
-export declare function PagesReleased({ decision, apiRoute }: {
+export declare function PagesReleased({ decision, apiRoute, userId, userCollection: collection }: {
     decision: PageReleaseDecision;
     apiRoute: string;
+    userId?: DocId;
+    userCollection?: string;
 }): import("react").JSX.Element;

package/dist/admin/surface/results/ReleasePages.js

@@ -1,7 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { useAuth, useConfig } from '@payloadcms/ui';
 import { Button } from '../../../ui/Button.js';
 import { Dialog } from '../../../ui/Dialog.js';
 import { createApi } from '../../api.js';
@@ -63,10 +62,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         ]
     });
 }
-/** An inaccessible or deleted author never hides the recorded release date. */ export function PagesReleased({ decision, apiRoute }) {
-    const { user } = useAuth();
-    const { config } = useConfig();
-    const collection = config.admin.user;
+/** An inaccessible or deleted author never hides the recorded release date. */ export function PagesReleased({ decision, apiRoute, userId, userCollection: collection }) {
     const by = decision.pagesReleasedBy;
     const [resolved, setResolved] = useState(null);
     const key = JSON.stringify([
@@ -74,7 +70,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         collection,
         by
     ]);
-    const own = pagesReleasedBy(by, user?.id);
+    const own = pagesReleasedBy(by, userId);
     useEffect(()=>{
         if (!by || own || !collection) return;
         const controller = new AbortController();
@@ -109,7 +105,7 @@ export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal
         key,
         own
     ]);
-    const name = own ?? pagesReleasedBy(by, user?.id, resolved?.key === key ? resolved.author : null);
+    const name = own ?? pagesReleasedBy(by, userId, resolved?.key === key ? resolved.author : null);
     return /*#__PURE__*/ _jsx("p", {
         children: pagesReleasedCopy(formatDate(decision.pagesReleasedAt), name)
     });

package/dist/admin/surface/results/ResultsBody.js

@@ -27,6 +27,7 @@ import { DecideDialog } from '../../actions/DecideDialog.js';
 import { Banner } from '../../../ui/Banner.js';
 import { canReleasePages } from '../../results/releasePages.model.js';
 import { PagesReleased, ReleasePagesDialog } from './ReleasePages.js';
+import { usePlacementLabels } from '../../placements/usePlacementLabels.js';
 export function ResultsBody({ id, surface, onRecomputed, onPagesReleased, renderPage }) {
     // A different test owns an independent selection and action lifecycle.
     return /*#__PURE__*/ _jsx(ResultsContent, {
@@ -116,12 +117,20 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
         isDecidedTestRound,
         winnerLabel: winner
     }) : null;
+    const placementLabels = usePlacementLabels({
+        details: shown?.health?.filter((item)=>item.code === 'placement-unchecked').map((item)=>item.detail) ?? [],
+        apiRoute: surface.apiRoute,
+        adminRoute: surface.adminRoute,
+        canManage: manage,
+        collectionTitles: surface.collectionTitles
+    });
     const context = {
         status,
         phase,
         inLayer: doc?.layer != null,
         layerSlices: doc?.layerSlices,
-        allocation: doc?.allocation
+        allocation: doc?.allocation,
+        placementLabels
     };
     const primary = phase?.metrics.find((metric)=>metric.role === 'primary');
     // The endpoint decides the current round; historical rounds are read-only.
@@ -147,7 +156,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
     // Release details come only from the manager's own document, never the results response.
     const released = manage && doc?.decision?.pagesReleasedAt ? /*#__PURE__*/ _jsx(PagesReleased, {
         decision: doc.decision,
-        apiRoute: surface.apiRoute
+        apiRoute: surface.apiRoute,
+        userId: surface.userId,
+        userCollection: surface.userCollection
     }) : null;
     const meta = /*#__PURE__*/ _jsxs(_Fragment, {
         children: [
@@ -263,6 +274,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                         }, context),
                         sinceShipping: rolloutLine(shown, phase, phases, decision ?? undefined)
                     }),
+                    primary?.clickGoal ? /*#__PURE__*/ _jsx("p", {
+                        children: C.clickPrimary
+                    }) : null,
                     /*#__PURE__*/ _jsxs("div", {
                         className: "xp-stat-tiles",
                         children: [
@@ -309,6 +323,9 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                             })
                         ]
                     }) : null,
+                    shown.goalFairnessNotice ? /*#__PURE__*/ _jsx("p", {
+                        children: shown.goalFairnessNotice
+                    }) : null,
                     /*#__PURE__*/ _jsx(DataQualityPanel, {
                         problem: shown.verdict.code === 'data-problem',
                         items: dataQuality(shown, context)
@@ -340,6 +357,7 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                         })
                     }),
                     /*#__PURE__*/ _jsx(PreviewLinks, {
+                        apiRoute: surface.apiRoute,
                         experimentId: id,
                         flagPoint: doc?.flagPoint,
                         placements: placements,
@@ -360,6 +378,7 @@ function ResultsContent({ id, surface, onRecomputed, onPagesReleased, renderPage
                 ]
             }) : null,
             deciding && manage && phase ? /*#__PURE__*/ _jsx(DecideDialog, {
+                apiRoute: surface.apiRoute,
                 id: id,
                 arms: phase.arms,
                 checks: checks,

package/dist/admin/surface/results/ResultsHeader.js

@@ -8,7 +8,7 @@ import { Banner, StatusChip } from '../../../ui/Feedback.js';
 import { createApi } from '../../api.js';
 import { availableActions, actionGroupLabel } from '../../actions/actions.model.js';
 import { AllocateAction, ConfirmAction } from '../readiness/ActionDialogs.js';
-import { READINESS, daysRemaining, displayDate, nextStep } from '../readiness/readiness.model.js';
+import { READINESS, daysRemaining, displayDate, nextStep, pageReadinessContext } from '../readiness/readiness.model.js';
 import { READINESS_COPY as R, runningCopy, stoppedCopy, decidedCopy } from '../../copy/readiness.js';
 import { RESULTS_COPY as C } from '../../copy/results.js';
 import { TEST_PAGE } from '../../copy/testPage.js';
@@ -54,10 +54,7 @@ export function ResultsHeader({ test, surface, resultsVersion, children, actions
             'allocate',
             'stop'
         ].indexOf(b.id) : 0);
-    const next = nextStep(test.preflight, {
-        ...doc,
-        flagPoints: surface.flagPoints
-    });
+    const next = nextStep(test.preflight, pageReadinessContext(doc, test.preflight, surface));
     const ready = Boolean(test.preflight && !test.preflightPending && !test.preflightError && test.preflight.checks.every((check)=>check.ok));
     const startReason = next?.sentence ?? (!ready ? test.preflightError ? R.checkError : R.checking : undefined);
     const action = available.find((item)=>item.id === selected);