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

package/dist/admin/actions/MakeContentResult.js

@@ -1,49 +1,148 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useRef, useState } from 'react';
-import { Button } from '@payloadcms/ui';
-import { ACTIONS_COPY as C } from '../copy/actions.js';
-export function MakeContentResult({ result, onRetry, busy = false }) {
+import { useLayoutEffect, useRef, useState } from 'react';
+import { contentDone } from '../../contentDone.js';
+import { Button } from '../../ui/Button.js';
+import { Banner } from '../../ui/Banner.js';
+import { API_MESSAGES } from '../copy/common.js';
+import { ACTIONS_COPY as C, contentReportCopy } from '../copy/actions.js';
+export function MakeContentResult({ result, onRetry, busy = false, id, api, canManage = false, isDecided = false, onFinish, onBusyChange, onActionStart }) {
     const inFlight = useRef(false);
+    const container = useRef(null);
+    const focusTarget = useRef(null);
     const [pending, setPending] = useState(false);
-    async function retry() {
+    const [error, setError] = useState(null);
+    const [report, setReport] = useState({
+        source: result,
+        docs: result.docs
+    });
+    // A Retry supplies a new report. Entry actions use the authoritative returned doc.
+    if (report.source !== result) setReport({
+        source: result,
+        docs: result.docs
+    });
+    const docs = report.source === result ? report.docs : result.docs;
+    const editable = canManage && isDecided;
+    useLayoutEffect(()=>{
+        if (busy || pending || !focusTarget.current) return;
+        const target = focusTarget.current === 'finish' ? container.current?.querySelector('[data-finish-archiving]') : focusTarget.current;
+        target?.focus();
+        focusTarget.current = null;
+    }, [
+        docs,
+        busy,
+        pending
+    ]);
+    async function run(action) {
         if (inFlight.current || busy) return;
         inFlight.current = true;
         setPending(true);
+        setError(null);
+        onActionStart?.();
+        onBusyChange?.(true);
         try {
-            await onRetry();
+            await action();
+        } catch  {
+            setError(API_MESSAGES.network);
         } finally{
             inFlight.current = false;
             setPending(false);
+            onBusyChange?.(false);
         }
     }
-    const failed = result.docs.some((doc)=>!doc.ok);
+    async function changeEntry(entry, button) {
+        if (!editable || !api || id === undefined) return;
+        const response = await (entry.dismissedAt ? api.restoreContentEntry : api.dismissContentEntry)(id, {
+            collection: entry.collection,
+            id: entry.id
+        });
+        if (!response.ok) {
+            setError(response.message);
+            return;
+        }
+        const decision = response.data?.doc.decision;
+        const updated = decision?.contentReport?.docs?.find((doc)=>doc.collection === entry.collection && String(doc.id) === String(entry.id));
+        if (!updated) {
+            setError(API_MESSAGES.unreadable);
+            return;
+        }
+        const updatedDocs = docs.map((doc)=>doc.collection === entry.collection && String(doc.id) === String(entry.id) ? updated : doc);
+        focusTarget.current = !entry.dismissedAt && !contentDone(docs) && contentDone(updatedDocs) && onFinish ? 'finish' : button;
+        setReport((current)=>({
+                ...current,
+                docs: updatedDocs
+            }));
+    }
+    const retryable = docs.some((doc)=>!doc.ok && !doc.dismissedAt);
     return /*#__PURE__*/ _jsxs("div", {
+        ref: container,
         "aria-live": "polite",
         children: [
+            error ? /*#__PURE__*/ _jsx(Banner, {
+                tone: "error",
+                children: error
+            }) : null,
+            result.doc?.status === 'archived' ? /*#__PURE__*/ _jsx("p", {
+                children: C.contentArchived
+            }) : null,
             /*#__PURE__*/ _jsx("ul", {
-                children: result.docs.map((doc, index)=>/*#__PURE__*/ _jsxs("li", {
+                children: docs.map((doc, index)=>{
+                    const label = 'title' in doc && typeof doc.title === 'string' && doc.title || `${doc.collection}/${doc.id}`;
+                    return /*#__PURE__*/ _jsxs("li", {
                         children: [
-                            'title' in doc && typeof doc.title === 'string' && doc.title || `${doc.collection}/${doc.id}`,
-                            ": ",
-                            doc.ok ? C.updated : C.failed,
-                            doc.error ? ` — ${doc.error}` : ''
+                            /*#__PURE__*/ _jsxs("span", {
+                                children: [
+                                    label,
+                                    ": ",
+                                    doc.ok ? C.updated : doc.dismissedAt ? C.dismissed : C.failed,
+                                    !doc.dismissedAt && (doc.detail !== undefined || doc.error !== undefined || !doc.ok) ? ` — ${contentReportCopy(doc.detail ?? doc.error, doc.ok)}` : ''
+                                ]
+                            }),
+                            !doc.ok && editable && api && id !== undefined ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    doc.dismissedAt ? ' · ' : ' ',
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        variant: "quiet",
+                                        size: "sm",
+                                        "aria-disabled": busy || pending || undefined,
+                                        "aria-label": doc.dismissedAt ? C.undoLabel(label) : C.dismissLabel(label),
+                                        onClick: (event)=>{
+                                            const button = event.currentTarget;
+                                            void run(()=>changeEntry(doc, button));
+                                        },
+                                        children: doc.dismissedAt ? C.undo : C.dismiss
+                                    })
+                                ]
+                            }) : null
                         ]
-                    }, `${doc.collection}/${doc.id}/${index}`))
+                    }, `${doc.collection}/${doc.id}/${index}`);
+                })
             }),
-            failed ? /*#__PURE__*/ _jsxs(_Fragment, {
+            editable && retryable ? /*#__PURE__*/ _jsxs(_Fragment, {
                 children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        children: C.dismissHelp
+                    }),
                     /*#__PURE__*/ _jsx("p", {
                         children: C.partial
                     }),
                     /*#__PURE__*/ _jsx(Button, {
-                        disabled: busy || pending,
+                        "aria-disabled": busy || pending || undefined,
                         onClick: ()=>{
-                            void retry();
+                            void run(onRetry);
                         },
                         children: C.retry
                     })
                 ]
+            }) : null,
+            editable && contentDone(docs) && onFinish ? /*#__PURE__*/ _jsx(Button, {
+                "data-finish-archiving": true,
+                variant: "primary",
+                disabled: busy || pending,
+                onClick: ()=>{
+                    void run(onFinish);
+                },
+                children: C.finish
             }) : null
         ]
     });

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

@@ -1,13 +1,11 @@
 import type { ExperimentKind, Status } from '../../types/contracts.js';
-import type { ArchiveBody, MakeContentResult } from '../../types/endpoints.js';
+import type { ArchiveBody, ContentReport } from '../../types/endpoints.js';
 export type ActionGroup = {
     key: string;
     label?: string;
     kind?: string;
 };
-export type ContentReport = {
-    docs: MakeContentResult['docs'];
-} | MakeContentResult['docs'];
+export type { ContentReport } from '../../types/endpoints.js';
 export type ActionDecision = {
     winnerArm?: string | null;
     holdoutReleasedAt?: string | null;

package/dist/admin/actions/actions.model.js

@@ -1,3 +1,4 @@
+import { contentDone } from '../../contentDone.js';
 import { armLabel } from '../labels.js';
 import { ACTIONS_COPY as C, hardCodedLabel, makeContentCopy, releaseCopy } from '../copy/actions.js';
 import { REVIEW_COPY } from '../copy/review.js';
@@ -45,8 +46,6 @@ export function availableActions({ status, kind, arms, decision, canManage }) {
     const winner = arms.find((group)=>group.key === decision?.winnerArm);
     const label = actionGroupLabel(decision?.winnerArm ?? 'control', winner?.label);
     const rolloutOpen = arms.some((group)=>group.key === 'holdout') && Boolean(decision?.winnerArm) && decision?.winnerArm !== 'control' && !decision?.holdoutReleasedAt;
-    const report = decision?.contentReport;
-    const docs = Array.isArray(report) ? report : report?.docs;
     return [
         ...rolloutOpen ? [
             action('release-holdout', C.release, releaseCopy(label))
@@ -54,7 +53,7 @@ export function availableActions({ status, kind, arms, decision, canManage }) {
         ...kind !== 'code' ? [
             action('make-content', C.makeContent, makeContentCopy(label, kind), 'primary')
         ] : [],
-        ...docs?.length && docs.every((doc)=>doc.ok) ? [
+        ...contentDone(decision?.contentReport) ? [
             action('after-content', C.finish, C.finishBody, 'secondary', {
                 mode: 'after-content'
             })

package/dist/admin/allocation.model.js

@@ -1,6 +1,5 @@
 import { armLabel } from './labels.js';
-import { LOCKED_MESSAGES } from './copy/common.js';
-import { eachVersion, groupShare, holdoutClause, layerSentence, participation, peopleLabel, uncounted } from './copy/audience.js';
+import { eachVersion, groupShare, holdoutClause, holdoutRemainder, layerSentence, participation, peopleLabel, uncounted } from './copy/audience.js';
 const percent = (value)=>String(Math.round(value * 10) / 10);
 export function allocationSentence({ allocation, unitType, arms, layer, status }) {
     const groups = arms.filter((group)=>group.kind !== 'holdout');
@@ -8,10 +7,9 @@ export function allocationSentence({ allocation, unitType, arms, layer, status }
     const equal = groups.every((group)=>group.weight === groups[0].weight);
     const shares = equal ? eachVersion(percent(allocation * groups[0].weight / 100)) : groups.map((group)=>groupShare(percent(allocation * group.weight / 100), armLabel(group.key, group.label))).join(', ');
     const holdout = arms.find((group)=>group.kind === 'holdout');
-    let sentence = participation(percent(allocation), peopleLabel[unitType], shares) + (holdout ? holdoutClause(percent(holdout.weight)) : uncounted);
-    if ((layer || status === 'running') && !sentence.endsWith('.')) sentence += '.';
+    let sentence = participation(percent(allocation), peopleLabel[unitType], shares) + (holdout ? holdoutClause(percent(holdout.weight)) : '') + (allocation < 100 ? holdout ? holdoutRemainder : uncounted : '');
+    if ((holdout || layer || status === 'running') && !sentence.endsWith('.')) sentence += '.';
     if (layer) sentence += layerSentence(layer.name, layer.used, layer.free);
-    if (status === 'running') sentence += ` ${LOCKED_MESSAGES.runningAllocation}`;
     return sentence;
 }
 // Payload arrays are flattened into row fields; their parent value is a row count.

package/dist/admin/api.d.ts

@@ -1,5 +1,6 @@
 import type { DocId } from '../types/contracts.js';
-import type { AddMetricBody, AllocateBody, ArchiveBody, DecideBody, MakeContentResult, PreflightResult, PreviewTokenResult, RefusalCode, ResultsResponse, SummaryResponse, TransitionSuccess } from '../types/endpoints.js';
+import type { RestoreContentEntryBody, RestoreContentEntryResult, DismissContentEntryBody, DismissContentEntryResult, AddMetricBody, AllocateBody, ArchiveBody, DecideBody, MakeContentResult, PreflightResult, PreviewTokenResult, RefusalCode, ResultsResponse, SummaryResponse, TransitionSuccess } from '../types/endpoints.js';
+import { refusalMessage } from './copy/common.js';
 export type ApiResult<T> = {
     ok: true;
     data: T | undefined;
@@ -10,23 +11,28 @@ export type ApiResult<T> = {
     message: string;
     retryable: boolean;
 };
+type RequestOptions = NonNullable<Parameters<typeof refusalMessage>[3]>;
 export declare function createApi(apiBase: string): {
     start: (id: DocId) => Promise<ApiResult<TransitionSuccess>>;
-    allocate: (id: DocId, body: AllocateBody) => Promise<ApiResult<TransitionSuccess>>;
-    addMetric: (id: DocId, body: AddMetricBody) => Promise<ApiResult<TransitionSuccess>>;
+    allocate: (id: DocId, body: AllocateBody, options?: RequestOptions) => Promise<ApiResult<TransitionSuccess>>;
+    addMetric: (id: DocId, body: AddMetricBody, options?: RequestOptions) => Promise<ApiResult<TransitionSuccess>>;
     stop: (id: DocId) => Promise<ApiResult<TransitionSuccess>>;
     decide: (id: DocId, body: DecideBody) => Promise<ApiResult<TransitionSuccess>>;
     releaseHoldout: (id: DocId) => Promise<ApiResult<TransitionSuccess>>;
+    releasePages: (id: DocId) => Promise<ApiResult<TransitionSuccess>>;
     makeContent: (id: DocId) => Promise<ApiResult<MakeContentResult>>;
+    dismissContentEntry: (id: DocId, body: DismissContentEntryBody) => Promise<ApiResult<DismissContentEntryResult>>;
+    restoreContentEntry: (id: DocId, body: RestoreContentEntryBody) => Promise<ApiResult<RestoreContentEntryResult>>;
     archive: (id: DocId, body: ArchiveBody) => Promise<ApiResult<TransitionSuccess>>;
     preflight: (id: DocId) => Promise<ApiResult<PreflightResult>>;
     previewToken: (id: DocId, arm: string) => Promise<ApiResult<PreviewTokenResult>>;
     results: (id: DocId, options?: {
         phase?: number;
         series?: boolean;
-    }) => Promise<ApiResult<ResultsResponse>>;
+    } & RequestOptions) => Promise<ApiResult<ResultsResponse>>;
     recompute: (id: DocId) => Promise<ApiResult<{
         snapshotId: string;
     }>>;
     summary: (ids: readonly DocId[]) => Promise<ApiResult<SummaryResponse>>;
 };
+export {};

package/dist/admin/api.js

@@ -1,8 +1,9 @@
 import { API_MESSAGES, refusalMessage } from './copy/common.js';
+import { CONTENT_ENTRY_REFUSALS } from './copy/actions.js';
 export function createApi(apiBase) {
     const base = `${apiBase.replace(/\/$/, '')}/xp/experiments`;
     const route = (id, action)=>`${base}/${encodeURIComponent(id)}/${action}`;
-    async function request(path, method, body) {
+    async function request(path, method, body, options) {
         try {
             const response = await fetch(path(), {
                 method,
@@ -28,7 +29,7 @@ export function createApi(apiBase) {
                     ...response.status === 501 ? {
                         code: 'not-implemented'
                     } : {},
-                    message: refusalMessage(undefined, response.status),
+                    message: refusalMessage(undefined, response.status, undefined, options),
                     retryable: response.status >= 500 && response.status !== 501
                 };
             }
@@ -46,7 +47,7 @@ export function createApi(apiBase) {
                 ...code ? {
                     code
                 } : {},
-                message: refusalMessage(code, response.status, typeof error?.message === 'string' ? error.message : undefined),
+                message: refusalMessage(code, response.status, typeof error?.message === 'string' ? error.message : undefined, options),
                 retryable: code === 'commit-unverified' || response.status >= 500 && response.status !== 501
             };
         } catch  {
@@ -58,15 +59,18 @@ export function createApi(apiBase) {
             };
         }
     }
-    const post = (id, action, body)=>request(()=>route(id, action), 'POST', body);
+    const post = (id, action, body, options)=>request(()=>route(id, action), 'POST', body, options);
     return {
         start: (id)=>post(id, 'start'),
-        allocate: (id, body)=>post(id, 'allocate', body),
-        addMetric: (id, body)=>post(id, 'add-metric', body),
+        allocate: (id, body, options)=>post(id, 'allocate', body, options),
+        addMetric: (id, body, options)=>post(id, 'add-metric', body, options),
         stop: (id)=>post(id, 'stop'),
         decide: (id, body)=>post(id, 'decide', body),
         releaseHoldout: (id)=>post(id, 'release-holdout'),
+        releasePages: (id)=>post(id, 'release-pages'),
         makeContent: (id)=>post(id, 'make-content'),
+        dismissContentEntry: (id, body)=>post(id, 'content-report/dismiss', body, CONTENT_ENTRY_REFUSALS),
+        restoreContentEntry: (id, body)=>post(id, 'content-report/restore', body, CONTENT_ENTRY_REFUSALS),
         archive: (id, body)=>post(id, 'archive', body),
         preflight: (id)=>request(()=>route(id, 'preflight'), 'GET'),
         previewToken: (id, arm)=>request(()=>`${route(id, 'preview-token')}?arm=${encodeURIComponent(arm)}`, 'GET'),
@@ -76,7 +80,7 @@ export function createApi(apiBase) {
                 if (options.series) query.set('series', '1');
                 const qs = query.toString();
                 return `${route(id, 'results')}${qs ? `?${qs}` : ''}`;
-            }, 'GET'),
+            }, 'GET', undefined, options),
         recompute: (id)=>post(id, 'recompute'),
         summary: async (ids)=>{
             const data = {};

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

@@ -8,13 +8,13 @@ export declare const ACTIONS_COPY: {
     readonly finish: "Finish archiving";
     readonly archive: "Archive";
     readonly discard: "Discard winner";
-    readonly startBody: "Start this experiment?";
+    readonly startBody: "Start this test?";
     readonly restartBody: "Starting again begins a new round; results restart.";
     readonly stopBody: "Everyone will see the Original. Starting again begins a new round; results restart.";
     readonly original: "Everyone will see the Original.";
     readonly discardBody: "Everyone goes back to the Original. The decision note is kept.";
-    readonly archiveBody: "Archive this experiment?";
-    readonly finishBody: "The content has been updated. Finish archiving this experiment.";
+    readonly archiveBody: "Archive this test?";
+    readonly finishBody: "The content has been updated. Finish archiving this test.";
     readonly noResults: "There are no results yet.";
     readonly noRecommendation: "The results don't recommend a group yet.";
     readonly different: "You chose a different group than the results recommend.";
@@ -25,12 +25,48 @@ export declare const ACTIONS_COPY: {
     readonly cancel: "Cancel";
     readonly retry: "Retry";
     readonly done: "Done";
+    readonly dismiss: "Dismiss";
+    readonly dismissed: "Dismissed";
+    readonly undo: "Undo";
+    readonly contentArchived: "The winner is now the content and the test is archived.";
+    readonly dismissLabel: (page: string) => string;
+    readonly undoLabel: (page: string) => string;
+    readonly dismissHelp: "Dismiss a page you'll update by hand, then finish archiving.";
+    readonly contentEntryNotDecided: "This test isn't decided, so its pages can't be changed.";
+    readonly contentEntryMissing: "This page is no longer in the list. Reload to see the current list.";
+    readonly contentEntryDismissed: "This page was already dismissed.";
+    readonly contentEntryNotDismissed: "This page isn't dismissed. Reload to see its current state.";
+    readonly contentEntryUpdated: "This page is already updated.";
+    readonly contentEntryNotFound: "This test no longer exists.";
+    readonly contentEntryFallback: "This page can't be changed right now. Reload to see its current state.";
     readonly loading: "Loading results…";
     readonly updated: "Updated";
     readonly failed: "Failed";
+    readonly contentReasons: {
+        localized: string;
+        locked: string;
+        forbidden: string;
+        'not-found': string;
+        validation: string;
+        'update-failed': string;
+    };
+    readonly missingContent: "This page no longer exists; nothing to change.";
     readonly partial: "Some pages couldn't be updated. Fix them and retry.";
 };
 export declare const decideCopy: (winner: string, holdout: boolean, original: boolean) => string;
 export declare const releaseCopy: (winner: string) => string;
 export declare const makeContentCopy: (winner: string, kind: "block" | "page" | "flag") => string;
 export declare const hardCodedLabel: (winner: string) => string;
+/** Old reports can contain host error text: never interpolate an unknown string. */
+export declare const contentReportCopy: (reason: string | undefined, ok?: boolean) => string;
+export declare const CONTENT_ENTRY_REFUSALS: {
+    readonly notFound: "This test no longer exists.";
+    readonly codes: {
+        readonly 'not-decided': "This test isn't decided, so its pages can't be changed.";
+        readonly 'entry-not-found': "This page is no longer in the list. Reload to see the current list.";
+        readonly 'entry-ok': "This page is already updated.";
+        readonly 'entry-dismissed': "This page was already dismissed.";
+        readonly 'entry-not-dismissed': "This page isn't dismissed. Reload to see its current state.";
+    };
+    readonly fallback: "This page can't be changed right now. Reload to see its current state.";
+};

package/dist/admin/copy/actions.js

@@ -8,13 +8,13 @@ export const ACTIONS_COPY = {
     finish: 'Finish archiving',
     archive: 'Archive',
     discard: 'Discard winner',
-    startBody: 'Start this experiment?',
+    startBody: 'Start this test?',
     restartBody: 'Starting again begins a new round; results restart.',
     stopBody: 'Everyone will see the Original. Starting again begins a new round; results restart.',
     original: 'Everyone will see the Original.',
     discardBody: 'Everyone goes back to the Original. The decision note is kept.',
-    archiveBody: 'Archive this experiment?',
-    finishBody: 'The content has been updated. Finish archiving this experiment.',
+    archiveBody: 'Archive this test?',
+    finishBody: 'The content has been updated. Finish archiving this test.',
     noResults: 'There are no results yet.',
     noRecommendation: "The results don't recommend a group yet.",
     different: 'You chose a different group than the results recommend.',
@@ -25,12 +25,48 @@ export const ACTIONS_COPY = {
     cancel: 'Cancel',
     retry: 'Retry',
     done: 'Done',
+    dismiss: 'Dismiss',
+    dismissed: 'Dismissed',
+    undo: 'Undo',
+    contentArchived: 'The winner is now the content and the test is archived.',
+    dismissLabel: (page)=>`Dismiss ${page}`,
+    undoLabel: (page)=>`Undo dismiss ${page}`,
+    dismissHelp: "Dismiss a page you'll update by hand, then finish archiving.",
+    contentEntryNotDecided: "This test isn't decided, so its pages can't be changed.",
+    contentEntryMissing: 'This page is no longer in the list. Reload to see the current list.',
+    contentEntryDismissed: 'This page was already dismissed.',
+    contentEntryNotDismissed: "This page isn't dismissed. Reload to see its current state.",
+    contentEntryUpdated: 'This page is already updated.',
+    contentEntryNotFound: 'This test no longer exists.',
+    contentEntryFallback: "This page can't be changed right now. Reload to see its current state.",
     loading: 'Loading results…',
     updated: 'Updated',
     failed: 'Failed',
+    contentReasons: {
+        localized: "This page has more than one language; Make it the content can't publish it safely yet. Copy the winning version by hand.",
+        locked: 'Someone is editing this page. Wait for them to finish, then retry.',
+        forbidden: "You can't read or update this page. Ask someone with access to update it by hand. If it was deleted or moved to trash, discard the winner to archive this test.",
+        'not-found': 'This page could not be found. Check whether it was deleted.',
+        validation: "This page couldn't be saved automatically. Update it by hand, then retry.",
+        'update-failed': "This page couldn't be updated this time. Retry; if it keeps happening, ask a developer."
+    },
+    missingContent: 'This page no longer exists; nothing to change.',
     partial: "Some pages couldn't be updated. Fix them and retry."
 };
 export const decideCopy = (winner, holdout, original)=>original ? ACTIONS_COPY.original : holdout ? `Everyone except the holdout will see ${winner}. The holdout keeps seeing the Original so we can measure the shipped change.` : `Everyone will see ${winner}.`;
 export const releaseCopy = (winner)=>`The holdout will see ${winner} too. Measuring since shipping ends.`;
-export const makeContentCopy = (winner, kind)=>kind === 'flag' ? `Saves ${winner}'s settings as the new defaults so the experiment can be archived.` : `Copies ${winner} into the page content so the experiment can be archived.`;
+export const makeContentCopy = (winner, kind)=>kind === 'flag' ? `Saves ${winner}'s settings as the new defaults so the test can be archived.` : `Copies ${winner} into the page content so the test can be archived.`;
 export const hardCodedLabel = (winner)=>`The developer has hard-coded ${winner}`;
+/** Old reports can contain host error text: never interpolate an unknown string. */ export const contentReportCopy = (reason, ok = false)=>reason === 'not-found' && ok ? ACTIONS_COPY.missingContent : ACTIONS_COPY.contentReasons[reason !== undefined && Object.hasOwn(ACTIONS_COPY.contentReasons, reason) ? reason : 'update-failed'];
+// Each dismiss/restore refusal code has its own sentence; server text is never shown.
+export const CONTENT_ENTRY_REFUSALS = {
+    notFound: ACTIONS_COPY.contentEntryNotFound,
+    codes: {
+        'not-decided': ACTIONS_COPY.contentEntryNotDecided,
+        'entry-not-found': ACTIONS_COPY.contentEntryMissing,
+        'entry-ok': ACTIONS_COPY.contentEntryUpdated,
+        'entry-dismissed': ACTIONS_COPY.contentEntryDismissed,
+        'entry-not-dismissed': ACTIONS_COPY.contentEntryNotDismissed
+    },
+    fallback: ACTIONS_COPY.contentEntryFallback
+};

package/dist/admin/copy/armSelect.js

@@ -1,11 +1,11 @@
 export const ARM_SELECT_COPY = {
-    experiment: 'Experiment',
+    experiment: 'Test',
     group: 'Group',
     clear: 'Clear',
-    forbidden: "You can't see experiments. Ask an admin.",
-    unavailable: "Experiments couldn't be loaded. Reload and try again.",
-    loading: 'Loading experiments…',
+    forbidden: "You can't see tests. Ask an admin.",
+    unavailable: "Tests couldn't be loaded. Reload and try again.",
+    loading: 'Loading tests…',
     running: 'Changing this content mid-test mixes two versions in one result',
     noFlagPoint: 'No setting is configured for this field.'
 };
-export const staleExperiment = (name)=>`This was set for an earlier experiment${name ? ` (${name})` : ''} and won't be used now.`;
+export const staleExperiment = (name)=>`This was set for an earlier test${name ? ` (${name})` : ''} and won't be used now.`;

package/dist/admin/copy/audience.d.ts

@@ -1,6 +1,6 @@
 export declare const AUDIENCE_COPY: {
     readonly listPlaceholder: "Type a value and press Enter";
-    readonly listDescription: "Add one value per chip, for example each page path.";
+    readonly listDescription: "Add one value per chip.";
     readonly removeValue: (value: string) => string;
     readonly removeSymbol: "×";
     readonly emptyListNote: "Add at least one value — an empty list can't be saved.";
@@ -25,6 +25,7 @@ export declare const eachVersion: (share: string) => string;
 export declare const groupShare: (share: string, label: string) => string;
 export declare const uncounted = "; the rest see the Original and are not counted";
 export declare const holdoutClause: (weight: string) => string;
+export declare const holdoutRemainder = "; everyone else sees the Original and is not counted";
 export declare const layerSentence: (name: string, used: number, free: number) => string;
 export declare const peopleLabel: {
     readonly visitor: "visitors";

package/dist/admin/copy/audience.js

@@ -1,6 +1,6 @@
 export const AUDIENCE_COPY = {
     listPlaceholder: 'Type a value and press Enter',
-    listDescription: 'Add one value per chip, for example each page path.',
+    listDescription: 'Add one value per chip.',
     removeValue: (value)=>`Remove ${value}`,
     removeSymbol: '×',
     emptyListNote: "Add at least one value — an empty list can't be saved."
@@ -24,7 +24,8 @@ export const participation = (allocation, people, groups)=>`${allocation}% of ${
 export const eachVersion = (share)=>`${share}% see each version`;
 export const groupShare = (share, label)=>`${share}% see ${label === 'Original' ? 'the Original' : label}`;
 export const uncounted = '; the rest see the Original and are not counted';
-export const holdoutClause = (weight)=>`; the holdout (${weight}% of them) sees the Original and is measured; everyone else sees the Original and is not counted.`;
+export const holdoutClause = (weight)=>`; the holdout (${weight}% of them) sees the Original and is measured`;
+export const holdoutRemainder = '; everyone else sees the Original and is not counted';
 export const layerSentence = (name, used, free)=>` Uses ${used} of the 100 slices in layer ${name}; ${free} are free.`;
 export const peopleLabel = {
     visitor: 'visitors',

package/dist/admin/copy/common.d.ts

@@ -1,5 +1,8 @@
 export declare const API_MESSAGES: {
-    readonly notFound: "This experiment no longer exists.";
+    readonly notFound: "This test no longer exists.";
+    readonly goalNotFound: "That goal no longer exists. Choose another goal.";
+    readonly roundChanged: "This round has changed. Reload the page.";
+    readonly roundNotFound: "That round no longer exists. Choose another round.";
     readonly commitUnverified: "The change may not have been saved. Reload and try again.";
     readonly notImplemented: "This isn't available yet.";
     readonly unauthenticated: "Your session has expired. Sign in again.";
@@ -9,12 +12,16 @@ export declare const API_MESSAGES: {
     readonly unreadable: "Couldn't read the server's response. Reload and try again.";
 };
 export declare const LOCKED_MESSAGES: {
-    readonly creation: "Set when the experiment was created.";
+    readonly creation: "Set when the test was created.";
     readonly running: "Locked while the test is running so everyone in this round sees the same thing. Stop the test to change it.";
-    readonly runningAllocation: "Raise it from the actions panel; lowering takes effect in the next round.";
-    readonly runningMetrics: "Add supporting metrics or guardrails from the actions panel; the main metric is fixed for this round.";
+    readonly runningAllocation: "To include more people, use \"Let more people in\" at the bottom of the page. To include fewer, stop the test; the change applies when you start it again.";
+    readonly runningMetrics: "Add a guardrail or something to watch with \"Add a goal\" at the bottom of the page; the main goal is fixed for this round.";
     readonly decided: "Locked after the decision.";
-    readonly archived: "Archived experiments can't be changed.";
+    readonly archived: "Archived tests can't be changed.";
     readonly other: "Can't be changed in this state.";
 };
-export declare function refusalMessage(code: string | undefined, status: number, message?: string): string;
+export declare function refusalMessage(code: string | undefined, status: number, message?: string, options?: {
+    notFound?: string;
+    codes?: Readonly<Record<string, string>>;
+    fallback?: string;
+}): string;

package/dist/admin/copy/common.js

@@ -1,5 +1,8 @@
 export const API_MESSAGES = {
-    notFound: 'This experiment no longer exists.',
+    notFound: 'This test no longer exists.',
+    goalNotFound: 'That goal no longer exists. Choose another goal.',
+    roundChanged: 'This round has changed. Reload the page.',
+    roundNotFound: 'That round no longer exists. Choose another round.',
     commitUnverified: 'The change may not have been saved. Reload and try again.',
     notImplemented: "This isn't available yet.",
     unauthenticated: 'Your session has expired. Sign in again.',
@@ -9,19 +12,22 @@ export const API_MESSAGES = {
     unreadable: "Couldn't read the server's response. Reload and try again."
 };
 export const LOCKED_MESSAGES = {
-    creation: 'Set when the experiment was created.',
+    creation: 'Set when the test was created.',
     running: 'Locked while the test is running so everyone in this round sees the same thing. Stop the test to change it.',
-    runningAllocation: 'Raise it from the actions panel; lowering takes effect in the next round.',
-    runningMetrics: 'Add supporting metrics or guardrails from the actions panel; the main metric is fixed for this round.',
+    runningAllocation: 'To include more people, use "Let more people in" at the bottom of the page. To include fewer, stop the test; the change applies when you start it again.',
+    runningMetrics: 'Add a guardrail or something to watch with "Add a goal" at the bottom of the page; the main goal is fixed for this round.',
     decided: 'Locked after the decision.',
-    archived: "Archived experiments can't be changed.",
+    archived: "Archived tests can't be changed.",
     other: "Can't be changed in this state."
 };
-export function refusalMessage(code, status, message) {
+export function refusalMessage(code, status, message, options) {
+    // A per-call code wins over the status branches: entry-not-found is a 404 that is not "this test no longer exists".
+    const mapped = code && options?.codes && Object.hasOwn(options.codes, code) ? options.codes[code] : undefined;
+    if (mapped !== undefined) return mapped;
     if (code === 'unauthenticated' || status === 401) return API_MESSAGES.unauthenticated;
-    if (code === 'not-found' || status === 404) return API_MESSAGES.notFound;
+    if (code === 'not-found' || status === 404) return options?.notFound ?? API_MESSAGES.notFound;
     if (code === 'commit-unverified') return API_MESSAGES.commitUnverified;
     if (code === 'not-implemented' || status === 501) return API_MESSAGES.notImplemented;
     if (code === 'forbidden' || status === 403) return API_MESSAGES.forbidden;
-    return message || API_MESSAGES.failed;
+    return options?.fallback ?? (message || API_MESSAGES.failed);
 }