@delmaredigital/payload-experiments 0.1.0-rc.7 → 0.2.0-rc.2

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

@@ -0,0 +1,198 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { TEST_PAGE as C } from '../../copy/testPage.js';
+import { metricSourceOptions } from '../../metricSource.model.js';
+import { reviewView } from '../../review/review.model.js';
+import { CheckboxList, FieldErrors, reasonFor, save, SelectEdit, TextEdit } from './fields.js';
+import { Section } from './Section.js';
+export function GoalSection({ test, surface }) {
+    const [metrics, setMetrics] = useState([]);
+    const [query, setQuery] = useState('');
+    const [failed, setFailed] = useState(false);
+    const [loaded, setLoaded] = useState(false);
+    const [attempt, setAttempt] = useState(0);
+    useEffect(()=>{
+        const controller = new AbortController();
+        void (async ()=>{
+            try {
+                const all = [];
+                let page = 1;
+                for(;;){
+                    const response = await fetch(`${surface.apiRoute.replace(/\/$/, '')}/xp-metrics?depth=0&limit=100&page=${page}`, {
+                        credentials: 'include',
+                        signal: controller.signal
+                    });
+                    if (!response.ok) throw new Error();
+                    const body = await response.json();
+                    if (!Array.isArray(body.docs)) throw new Error();
+                    all.push(...body.docs);
+                    if (!body.hasNextPage) break;
+                    page++;
+                }
+                if (!controller.signal.aborted) {
+                    setMetrics(all);
+                    setFailed(false);
+                    setLoaded(true);
+                }
+            } catch  {
+                if (!controller.signal.aborted) setFailed(true);
+            }
+        })();
+        return ()=>controller.abort();
+    }, [
+        surface.apiRoute,
+        attempt
+    ]);
+    const doc = test.doc;
+    const reason = reasonFor(test, 'metrics');
+    const sources = metricSourceOptions(surface.metricSources);
+    const unknownGoal = loaded ? C.missingGoal : C.goalUnavailable;
+    const options = metrics.map((metric)=>({
+            value: String(metric.id),
+            label: `${metric.name} · ${sources.find((source)=>source.value === metric.source)?.badge ?? metric.source}`
+        }));
+    const chosen = [
+        doc.metrics?.primary,
+        ...doc.metrics?.guardrails ?? [],
+        ...doc.metrics?.secondary ?? []
+    ].filter((id)=>id != null).map(String);
+    const visible = options.filter((option)=>chosen.includes(option.value) || option.label.toLowerCase().includes(query.toLowerCase()));
+    for (const id of chosen)if (!visible.some((option)=>option.value === id)) visible.push({
+        value: id,
+        label: unknownGoal
+    });
+    const roleOptions = (role)=>{
+        const blocked = new Set([
+            ...role !== 'primary' && doc.metrics?.primary != null ? [
+                doc.metrics.primary
+            ] : [],
+            ...role !== 'guardrails' ? doc.metrics?.guardrails ?? [] : [],
+            ...role !== 'secondary' ? doc.metrics?.secondary ?? [] : []
+        ].map(String));
+        return visible.filter((option)=>!blocked.has(option.value));
+    };
+    const originalId = (value)=>metrics.find((metric)=>String(metric.id) === value)?.id ?? [
+            test.doc.metrics?.primary,
+            ...test.doc.metrics?.guardrails ?? [],
+            ...test.doc.metrics?.secondary ?? []
+        ].find((id)=>id != null && String(id) === value);
+    const changePrimary = (value)=>{
+        const id = value ? originalId(value) : null;
+        if (id === undefined || id === (test.doc.metrics?.primary ?? null)) return;
+        save(test, 'metrics', ()=>({
+                metrics: {
+                    ...test.doc.metrics,
+                    primary: id
+                }
+            }));
+    };
+    const toggle = (role, value, checked)=>save(test, 'metrics', ()=>{
+            const current = test.doc.metrics;
+            const ids = current?.[role] ?? [];
+            const id = originalId(value);
+            return {
+                metrics: {
+                    ...current,
+                    [role]: checked && id != null ? ids.some((saved)=>String(saved) === value) ? ids : [
+                        ...ids,
+                        id
+                    ] : ids.filter((saved)=>String(saved) !== value)
+                }
+            };
+        });
+    const display = (ids)=>ids.length ? ids.map((id)=>options.find((option)=>option.value === String(id))?.label ?? unknownGoal).join(', ') : C.noGoal;
+    const primary = metrics.find((metric)=>String(metric.id) === String(doc.metrics?.primary));
+    const kind = surface.metricSources.find((source)=>source.id === primary?.source)?.kind;
+    const baseline = test.preflight?.baseline && String(test.preflight.baseline.metricId) === String(doc.metrics?.primary) ? reviewView(test.preflight, {
+        primaryMetricKind: kind
+    }).baseline : null;
+    return /*#__PURE__*/ _jsxs(Section, {
+        test: test,
+        sectionId: "win",
+        children: [
+            !reason ? /*#__PURE__*/ _jsx(TextEdit, {
+                label: C.searchGoals,
+                value: query,
+                onDraft: setQuery,
+                onCommit: setQuery
+            }) : null,
+            failed ? /*#__PURE__*/ _jsxs("p", {
+                role: "alert",
+                children: [
+                    C.goalsError,
+                    " ",
+                    /*#__PURE__*/ _jsx("button", {
+                        type: "button",
+                        onClick: ()=>setAttempt((n)=>n + 1),
+                        children: C.retry
+                    })
+                ]
+            }) : null,
+            /*#__PURE__*/ _jsx(SelectEdit, {
+                label: C.goal,
+                value: String(doc.metrics?.primary ?? ''),
+                options: [
+                    {
+                        value: '',
+                        label: C.chooseGoal
+                    },
+                    ...roleOptions('primary')
+                ],
+                reason: reason,
+                readOnlyValue: display(doc.metrics?.primary == null ? [] : [
+                    doc.metrics.primary
+                ]),
+                onCommit: changePrimary
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                children: C.goalHelp
+            }),
+            /*#__PURE__*/ _jsx("a", {
+                href: `${surface.adminRoute}/collections/xp-metrics`,
+                children: C.manageGoals
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "metrics.primary"
+            }),
+            /*#__PURE__*/ _jsx(CheckboxList, {
+                label: C.guardrails,
+                value: (doc.metrics?.guardrails ?? []).map(String),
+                options: roleOptions('guardrails'),
+                reason: reason,
+                readOnlyValue: display(doc.metrics?.guardrails ?? []),
+                onToggle: (value, checked)=>toggle('guardrails', value, checked)
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                children: C.guardrailHelp
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "metrics.guardrails"
+            }),
+            /*#__PURE__*/ _jsx(CheckboxList, {
+                label: C.secondary,
+                value: (doc.metrics?.secondary ?? []).map(String),
+                options: roleOptions('secondary'),
+                reason: reason,
+                readOnlyValue: display(doc.metrics?.secondary ?? []),
+                onToggle: (value, checked)=>toggle('secondary', value, checked)
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "metrics.secondary"
+            }),
+            baseline ? /*#__PURE__*/ _jsxs("p", {
+                children: [
+                    primary?.name ? `${primary.name}: ` : '',
+                    baseline
+                ]
+            }) : null,
+            test.errors.metrics ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: test.errors.metrics
+            }) : null
+        ]
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { SectionProps } from '../contracts.js';
+export declare function LengthSection({ test }: SectionProps): import("react").JSX.Element;

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

@@ -0,0 +1,87 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TEST_PAGE as C, suggestedWeeks, weeksHint } from '../../copy/testPage.js';
+import { durationSuggestion } from './testPage.model.js';
+import { FieldErrors, positiveInteger, reasonFor, save, TextEdit } from './fields.js';
+import { Section } from './Section.js';
+export function LengthSection({ test }) {
+    const doc = test.doc;
+    const reason = reasonFor(test, 'analysis');
+    const suggestion = durationSuggestion(test.preflight, doc.analysis?.plannedDurationDays);
+    const required = [
+        'manual',
+        'viewport'
+    ].includes(doc.exposurePolicy);
+    const change = (field, raw)=>save(test, 'analysis', ()=>({
+                analysis: {
+                    ...test.doc.analysis,
+                    [field]: raw.trim() ? Number(raw) : null
+                }
+            }));
+    return /*#__PURE__*/ _jsxs(Section, {
+        test: test,
+        sectionId: "length",
+        children: [
+            /*#__PURE__*/ _jsx(TextEdit, {
+                label: required ? `${C.reach} ${C.required}` : C.reach,
+                value: doc.analysis?.reachPerDay ?? '',
+                type: "number",
+                min: 1,
+                reason: reason,
+                required: required,
+                onCommit: (value)=>change('reachPerDay', value)
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                children: C.reachHelp
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "analysis.reachPerDay"
+            }),
+            suggestion ? /*#__PURE__*/ _jsxs("div", {
+                className: "xp-duration-suggestion",
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        children: suggestedWeeks(suggestion.weeks)
+                    }),
+                    !reason ? /*#__PURE__*/ _jsx("button", {
+                        type: "button",
+                        onClick: ()=>save(test, 'analysis', ()=>({
+                                    analysis: {
+                                        ...test.doc.analysis,
+                                        plannedDurationDays: suggestion.plannedDurationDays,
+                                        sequentialTuningParameter: suggestion.sequentialTuningParameter
+                                    }
+                                })),
+                        children: C.apply
+                    }) : null,
+                    !suggestion.feasible ? /*#__PURE__*/ _jsx("p", {
+                        children: C.infeasible
+                    }) : null
+                ]
+            }) : !test.preflight?.estimate ? /*#__PURE__*/ _jsx("p", {
+                children: doc.analysis?.reachPerDay == null ? C.noSuggestion : C.chooseGoalSuggestion
+            }) : null,
+            /*#__PURE__*/ _jsx(TextEdit, {
+                label: C.duration,
+                value: doc.analysis?.plannedDurationDays ?? 28,
+                type: "number",
+                min: 1,
+                reason: reason,
+                validate: positiveInteger,
+                onCommit: (value)=>change('plannedDurationDays', value)
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                children: weeksHint(doc.analysis?.plannedDurationDays ?? 28)
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "analysis.plannedDurationDays"
+            }),
+            test.errors.analysis ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: test.errors.analysis
+            }) : null
+        ]
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import type { SectionId, TestDocApi } from '../contracts.js';
+export declare function Section({ test, sectionId, children }: {
+    test: TestDocApi;
+    sectionId: SectionId;
+    children: ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { readinessParts } from '../readiness/parts.js';
+import { TEST_PAGE as C } from '../../copy/testPage.js';
+export function Section({ test, sectionId, children }) {
+    const done = readinessParts.sectionDone(test)[sectionId];
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "xp-test-section",
+        id: `section-${sectionId}`,
+        "aria-labelledby": `title-${sectionId}`,
+        children: [
+            /*#__PURE__*/ _jsxs("h2", {
+                id: `title-${sectionId}`,
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: done ? 'xp-section-check xp-section-check--done' : 'xp-section-check',
+                        "aria-label": done ? C.complete : C.incomplete,
+                        children: done ? C.completeMark : C.incompleteMark
+                    }),
+                    ' ',
+                    C.sections[sectionId]
+                ]
+            }),
+            children
+        ]
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { SectionProps } from '../contracts.js';
+export declare function TargetingSection({ test, surface }: SectionProps): import("react").JSX.Element;

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

@@ -0,0 +1,164 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { coerceValue, emptyListHint, humaniseAttribute, opLabel, opsFor, valueInput } from '../../targeting/targeting.model.js';
+import { TEST_PAGE as C, NUMBER_COMPARISONS } from '../../copy/testPage.js';
+import { CheckboxList, FieldErrors, reasonFor, save, SelectEdit, TextEdit } from './fields.js';
+import { Section } from './Section.js';
+export function TargetingSection({ test, surface }) {
+    const doc = test.doc;
+    const rules = doc.targeting ?? [];
+    const reason = reasonFor(test, 'targeting');
+    const update = (transform)=>save(test, 'targeting', ()=>({
+                targeting: transform(test.doc.targeting ?? [])
+            }));
+    const keys = Object.keys(surface.attributeKeys);
+    return /*#__PURE__*/ _jsx(Section, {
+        test: test,
+        sectionId: "who",
+        children: /*#__PURE__*/ _jsxs("details", {
+            children: [
+                /*#__PURE__*/ _jsx("summary", {
+                    children: rules.length ? C.rulesSummary : C.everyone
+                }),
+                rules.map((rule, index)=>{
+                    const attribute = surface.attributeKeys[rule.attribute];
+                    const input = valueInput(attribute, rule.op);
+                    const setRule = (partial)=>update((current)=>current.map((row, i)=>i === index ? {
+                                    ...row,
+                                    ...partial
+                                } : row));
+                    const hint = emptyListHint(rule.op, rule.value);
+                    const changeValue = (raw)=>{
+                        const current = test.doc.targeting?.[index];
+                        const schema = current && surface.attributeKeys[current.attribute];
+                        if (!current || !schema) return;
+                        const value = coerceValue(schema.type, current.op, raw);
+                        if (value !== null) setRule({
+                            value
+                        });
+                    };
+                    return /*#__PURE__*/ _jsxs("div", {
+                        className: "xp-targeting-row",
+                        children: [
+                            /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.attribute,
+                                reason: reason,
+                                value: rule.attribute,
+                                options: [
+                                    ...keys,
+                                    ...!attribute ? [
+                                        rule.attribute
+                                    ] : []
+                                ].map((key)=>({
+                                        value: key,
+                                        label: humaniseAttribute(key)
+                                    })),
+                                onCommit: (value)=>{
+                                    const key = String(value);
+                                    const type = surface.attributeKeys[key].type;
+                                    setRule({
+                                        attribute: key,
+                                        op: 'eq',
+                                        value: type === 'boolean' ? false : type === 'number' ? 0 : ''
+                                    });
+                                }
+                            }),
+                            /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.comparison,
+                                reason: reason,
+                                value: rule.op,
+                                options: opsFor(attribute?.type).map((op)=>({
+                                        value: op,
+                                        label: attribute?.type === 'number' ? NUMBER_COMPARISONS[op] : opLabel(attribute.type, op)
+                                    })),
+                                onCommit: (value)=>{
+                                    const op = value;
+                                    setRule({
+                                        op,
+                                        value: coerceValue(attribute.type, op, test.doc.targeting?.[index]?.value) ?? ''
+                                    });
+                                }
+                            }),
+                            input.kind === 'multiselect' ? /*#__PURE__*/ _jsx(CheckboxList, {
+                                label: C.value,
+                                reason: reason,
+                                value: Array.isArray(rule.value) ? rule.value.map(String) : [],
+                                options: input.options ?? [],
+                                onToggle: (value, checked)=>{
+                                    const current = test.doc.targeting?.[index]?.value;
+                                    const values = Array.isArray(current) ? current.map(String) : [];
+                                    changeValue(checked ? [
+                                        ...new Set([
+                                            ...values,
+                                            value
+                                        ])
+                                    ] : values.filter((saved)=>saved !== value));
+                                }
+                            }) : input.kind === 'select' ? /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.value,
+                                reason: reason,
+                                value: String(rule.value),
+                                options: input.options ?? [],
+                                onCommit: changeValue
+                            }) : input.kind === 'boolean' ? /*#__PURE__*/ _jsx(SelectEdit, {
+                                label: C.value,
+                                reason: reason,
+                                value: String(rule.value),
+                                options: [
+                                    {
+                                        value: 'true',
+                                        label: C.yes
+                                    },
+                                    {
+                                        value: 'false',
+                                        label: C.no
+                                    }
+                                ],
+                                onCommit: changeValue
+                            }) : /*#__PURE__*/ _jsx(TextEdit, {
+                                label: C.value,
+                                reason: reason,
+                                value: Array.isArray(rule.value) ? rule.value.join(', ') : String(rule.value),
+                                type: input.kind === 'number' ? 'number' : 'text',
+                                onCommit: changeValue
+                            }),
+                            hint ? /*#__PURE__*/ _jsx("p", {
+                                children: hint
+                            }) : null,
+                            /*#__PURE__*/ _jsx(FieldErrors, {
+                                test: test,
+                                path: `targeting.${index}`
+                            }),
+                            !reason ? /*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                onClick: ()=>update((current)=>current.filter((_, i)=>i !== index)),
+                                children: C.removeRule
+                            }) : null
+                        ]
+                    }, index);
+                }),
+                !reason ? /*#__PURE__*/ _jsx("button", {
+                    type: "button",
+                    disabled: !keys.length,
+                    onClick: ()=>{
+                        const attribute = keys[0];
+                        const type = surface.attributeKeys[attribute].type;
+                        update((current)=>[
+                                ...current,
+                                {
+                                    attribute,
+                                    op: 'eq',
+                                    value: type === 'boolean' ? false : type === 'number' ? 0 : ''
+                                }
+                            ]);
+                    },
+                    children: C.addRule
+                }) : null,
+                /*#__PURE__*/ _jsx(FieldErrors, {
+                    test: test,
+                    path: "targeting"
+                })
+            ]
+        })
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { SectionProps } from '../contracts.js';
+export declare function TestHeader({ test, surface, view }: SectionProps & {
+    view?: 'setup' | 'results';
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,69 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatAdminURL } from 'payload/shared';
+import { SURFACE_COPY } from '../../copy/surface.js';
+import { readinessParts } from '../readiness/parts.js';
+import { statusPill } from '../../status.model.js';
+import { TEST_PAGE as C } from '../../copy/testPage.js';
+import { FieldErrors, reasonFor, save, TextEdit } from './fields.js';
+export function TestHeader({ test, surface, view = 'setup' }) {
+    const doc = test.doc;
+    if (!doc) return null;
+    const pill = statusPill({
+        status: doc.status,
+        arms: doc.arms,
+        decision: doc.decision
+    });
+    return /*#__PURE__*/ _jsxs("header", {
+        className: "xp-test-header",
+        children: [
+            /*#__PURE__*/ _jsx(TextEdit, {
+                label: C.name,
+                value: doc.name,
+                reason: reasonFor(test, 'name'),
+                onCommit: (value)=>save(test, 'name', ()=>({
+                            name: value
+                        }))
+            }),
+            /*#__PURE__*/ _jsx(FieldErrors, {
+                test: test,
+                path: "name"
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "xp-header-meta",
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "xp-kind-chip",
+                        children: C.kinds[doc.kind]
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: `xp-status-pill xp-status-pill--${pill.tone}`,
+                        title: pill.tooltip,
+                        children: pill.label
+                    }),
+                    /*#__PURE__*/ _jsx(readinessParts.SaveStatus, {
+                        test: test
+                    }),
+                    view === 'results' ? /*#__PURE__*/ _jsx("a", {
+                        href: formatAdminURL({
+                            adminRoute: surface.adminRoute,
+                            path: `/experiments/${encodeURIComponent(String(doc.id))}`
+                        }),
+                        children: SURFACE_COPY.backToSetup
+                    }) : surface.canReadResults && [
+                        'running',
+                        'stopped',
+                        'decided'
+                    ].includes(doc.status) ? /*#__PURE__*/ _jsx("a", {
+                        href: `${surface.adminRoute}/experiments/${encodeURIComponent(String(doc.id))}/results`,
+                        children: C.results
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsx(readinessParts.Banner, {
+                test: test,
+                surface: surface
+            })
+        ]
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { DocId } from '../../../types/contracts.js';
+import type { SurfaceProps } from '../contracts.js';
+import './testPage.css';
+export declare function TestPage({ id, surface }: {
+    id: DocId;
+    surface: SurfaceProps;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,84 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTestDocument } from '../useTestDocument.js';
+import { TEST_PAGE as C } from '../../copy/testPage.js';
+import { pageBlockParts } from '../pageBlock/parts.js';
+import { settingParts } from '../setting/parts.js';
+import { pageParts } from './pageParts.js';
+import { TestHeader } from './TestHeader.js';
+import { Section } from './Section.js';
+import { Hypothesis } from './fields.js';
+import { VersionsSection } from './VersionsSection.js';
+import { GoalSection } from './GoalSection.js';
+import { TargetingSection } from './TargetingSection.js';
+import { LengthSection } from './LengthSection.js';
+import { AdvancedSection } from './AdvancedSection.js';
+import './testPage.css';
+export function TestPage({ id, surface }) {
+    const test = useTestDocument(id, {
+        apiRoute: surface.apiRoute
+    });
+    if (test.loadState !== 'ready' || !test.doc) return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-test-page",
+        role: test.loadState === 'error' ? 'alert' : 'status',
+        children: [
+            /*#__PURE__*/ _jsx("p", {
+                children: test.loadState === 'forbidden' ? C.forbidden : test.loadState === 'missing' ? C.missing : test.loadState === 'error' ? C.error : C.loading
+            }),
+            test.loadState === 'error' ? /*#__PURE__*/ _jsx("button", {
+                type: "button",
+                onClick: ()=>void test.reload(),
+                children: C.retry
+            }) : null
+        ]
+    });
+    const parts = test.doc.kind === 'block' ? pageBlockParts : test.doc.kind === 'page' ? pageParts : settingParts;
+    const props = {
+        test,
+        surface
+    };
+    return /*#__PURE__*/ _jsxs("main", {
+        className: "xp-test-page",
+        children: [
+            /*#__PURE__*/ _jsx(TestHeader, {
+                ...props
+            }),
+            test.errors._section ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: test.errors._section
+            }) : null,
+            test.preflightError ? /*#__PURE__*/ _jsx("p", {
+                role: "alert",
+                children: test.preflightError
+            }) : null,
+            /*#__PURE__*/ _jsxs(Section, {
+                test: test,
+                sectionId: "what",
+                children: [
+                    /*#__PURE__*/ _jsx(parts.Binding, {
+                        ...props
+                    }),
+                    /*#__PURE__*/ _jsx(Hypothesis, {
+                        ...props
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(VersionsSection, {
+                ...props,
+                parts: parts
+            }),
+            /*#__PURE__*/ _jsx(GoalSection, {
+                ...props
+            }),
+            /*#__PURE__*/ _jsx(TargetingSection, {
+                ...props
+            }),
+            /*#__PURE__*/ _jsx(LengthSection, {
+                ...props
+            }),
+            /*#__PURE__*/ _jsx(AdvancedSection, {
+                ...props
+            })
+        ]
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { KindParts, SectionProps } from '../contracts.js';
+export declare function VersionsSection({ test, surface, parts }: SectionProps & {
+    parts: KindParts;
+}): import("react").JSX.Element;