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

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 {};

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 = {};