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

package/dist/admin/placements/usePlacementLabels.js

@@ -0,0 +1,102 @@
+'use client';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { createApi } from '../api.js';
+import { placementDetail, placementDetailKey, preflightPlacementLabel, resolvedPlacementLabel } from './placementLabels.js';
+export { placementDetailKey } from './placementLabels.js';
+/** The view owns a cache, including misses, so repeated warnings never repeat reads. */ export function usePlacementLabels({ details, preflight, apiRoute, adminRoute, canManage, collectionTitles }) {
+    const titlesSignature = JSON.stringify(collectionTitles);
+    const cache = useMemo(()=>new Map(), [
+        apiRoute,
+        adminRoute,
+        titlesSignature
+    ]);
+    const mounted = useRef(true);
+    useEffect(()=>{
+        mounted.current = true;
+        return ()=>{
+            mounted.current = false;
+        };
+    }, []);
+    const [, refresh] = useState(0);
+    const signature = JSON.stringify(details.map(placementDetail));
+    useEffect(()=>{
+        if (!canManage || preflight) return;
+        const pending = [
+            ...new Map(JSON.parse(signature).map((detail)=>[
+                    placementDetailKey(detail),
+                    detail
+                ])).values()
+        ].filter((detail)=>!cache.has(placementDetailKey(detail)));
+        const blocks = new Map();
+        const jobs = [];
+        const save = (value, label)=>{
+            cache.set(placementDetailKey(value), label);
+        };
+        for (const value of pending){
+            const detail = placementDetail(value);
+            // Reserve immediately: repeated renders do not issue duplicate requests.
+            save(value, resolvedPlacementLabel(value, undefined, adminRoute));
+            if (!detail.collection) continue;
+            if (detail.id != null) {
+                blocks.set(detail.collection, [
+                    ...blocks.get(detail.collection) ?? [],
+                    value
+                ]);
+                continue;
+            }
+            if (!detail.path) continue;
+            jobs.push(createApi(apiRoute).pages({
+                collection: detail.collection,
+                path: detail.path
+            }).then((result)=>{
+                if (result.ok) save(value, resolvedPlacementLabel(value, result.data?.docs[0], adminRoute));
+            }));
+        }
+        for (const [collection, values] of blocks)jobs.push((async ()=>{
+            try {
+                const ids = [
+                    ...new Set(values.map((value)=>String(placementDetail(value).id)))
+                ];
+                const query = new URLSearchParams({
+                    'where[id][in]': ids.join(','),
+                    depth: '0',
+                    limit: String(ids.length)
+                });
+                const response = await fetch(`${apiRoute.replace(/\/$/, '')}/${encodeURIComponent(collection)}?${query}`, {
+                    credentials: 'include'
+                });
+                if (!response.ok) return;
+                const data = await response.json();
+                const titleField = collectionTitles?.[collection];
+                for (const value of values){
+                    const doc = data.docs?.find((doc)=>String(doc.id) === String(placementDetail(value).id));
+                    if (doc) save(value, resolvedPlacementLabel(value, {
+                        id: placementDetail(value).id,
+                        title: titleField && typeof doc[titleField] === 'string' ? doc[titleField] : undefined
+                    }, adminRoute));
+                }
+            } catch  {}
+        })());
+        void Promise.all(jobs).then(()=>{
+            if (mounted.current && jobs.length) refresh((value)=>value + 1);
+        });
+    }, [
+        signature,
+        preflight,
+        apiRoute,
+        adminRoute,
+        canManage,
+        collectionTitles,
+        cache
+    ]);
+    return new Map(details.map((detail)=>{
+        const label = preflight ? preflightPlacementLabel(detail, preflight, adminRoute) : cache.get(placementDetailKey(detail)) ?? resolvedPlacementLabel(detail, undefined, adminRoute);
+        // Results-only readers may not be able to open the collection, so they get the name without a link.
+        return [
+            placementDetailKey(detail),
+            canManage ? label : {
+                title: label.title
+            }
+        ];
+    }));
+}

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

@@ -6,4 +6,6 @@ type PreviewPage = Placement & {
 };
 /** Preview URLs identify pages; counts use the most placements in any one version. */
 export declare function previewPages(placements: readonly Placement[], flagPoint?: string): PreviewPage[];
+/** Pages that offer something to do: a preview or an editor link. The section is hidden when none do. */
+export declare function actionablePreviewPages(placements: readonly Placement[], flagPoint?: string): PreviewPage[];
 export {};

package/dist/admin/previewLinks.model.js

@@ -30,3 +30,6 @@
         ...pages.values()
     ].map(({ page })=>page);
 }
+/** Pages that offer something to do: a preview or an editor link. The section is hidden when none do. */ export function actionablePreviewPages(placements, flagPoint) {
+    return previewPages(placements, flagPoint).filter((page)=>page.url || page.editorUrl);
+}

package/dist/admin/results/DataQualityPanel.js

@@ -41,7 +41,10 @@ export function DataQualityPanel({ items, problem = false }) {
                             }) : null,
                             /*#__PURE__*/ _jsx("p", {
                                 className: "xp-quality-next",
-                                children: item.nextStep
+                                children: item.href ? /*#__PURE__*/ _jsx("a", {
+                                    href: item.href,
+                                    children: item.nextStep
+                                }) : item.nextStep
                             })
                         ]
                     }, item.id)) : /*#__PURE__*/ _jsx("p", {

package/dist/admin/results/legacy.d.ts

@@ -0,0 +1,16 @@
+import type { PhaseSummary } from '../../types/endpoints.js';
+import type { ResultsContext } from './results.model.js';
+import type { LegacySnapshot } from './snapshot.js';
+/** Stands in for CORE-15a winnerArm, borrowing the live decision only for the newest rollout. */
+export declare function legacyRolloutLine(snapshot: LegacySnapshot, phase: PhaseSummary, phases: PhaseSummary[], decision?: {
+    winnerArm?: string;
+}): string;
+/** Stands in for CORE-15a minExposuresPerArm; absent historical minima keep the old dash. */
+export declare function legacyMinimum(snapshot: LegacySnapshot, ctx: ResultsContext): number | undefined;
+/** Stands in for CORE-15a minExposuresPerArm by deriving the old notice from the frozen verdict. */
+export declare function legacyTooFew(snapshot: LegacySnapshot): boolean;
+/** Stands in for CORE-15a winnerArm in rollout recommendations using the old recommended arm and label. */
+export declare function legacyRecommendationWinner(snapshot: LegacySnapshot, phase?: PhaseSummary): {
+    key: string | null;
+    label: string;
+};

package/dist/admin/results/legacy.js

@@ -0,0 +1,27 @@
+import { RESULTS_COPY, shippingTitle } from '../copy/results.js';
+import { armLabel } from '../labels.js';
+/** Stands in for CORE-15a winnerArm, borrowing the live decision only for the newest rollout. */ export function legacyRolloutLine(snapshot, phase, phases, decision) {
+    const newestRollout = phases.filter((phase)=>phase.phaseKind === 'rollout').reduce((latest, phase)=>latest === null || phase.phase > latest ? phase.phase : latest, null);
+    const winner = snapshot.winnerArm ?? (snapshot.phase === newestRollout ? decision?.winnerArm : undefined);
+    return shippingTitle(winner ? phase.arms.find((arm)=>arm.key === winner)?.label ?? armLabel(winner) : RESULTS_COPY.shippedGroup);
+}
+/** Stands in for CORE-15a minExposuresPerArm; absent historical minima keep the old dash. */ export function legacyMinimum(snapshot, ctx) {
+    return snapshot.minExposuresPerArm ?? ctx.minExposuresPerArm;
+}
+/** Stands in for CORE-15a minExposuresPerArm by deriving the old notice from the frozen verdict. */ export function legacyTooFew(snapshot) {
+    return snapshot.verdict.code === 'collecting' || snapshot.verdict.code === 'rollout-collecting';
+}
+/** Stands in for CORE-15a winnerArm in rollout recommendations using the old recommended arm and label. */ export function legacyRecommendationWinner(snapshot, phase) {
+    const key = snapshot.winnerArm ?? snapshot.verdict.recommendedArm;
+    const stored = phase?.arms.find((arm)=>arm.key === key)?.label.trim();
+    return {
+        key,
+        label: stored || (key && [
+            'control',
+            'variantA',
+            'variantB',
+            'variantC',
+            'holdout'
+        ].includes(key) ? armLabel(key) : RESULTS_COPY.shippedGroup)
+    };
+}

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

@@ -1,13 +1,14 @@
 import type { DocId, Status } from '../../types/contracts.js';
 import type { PhaseSummary, ResultsResponse } from '../../types/endpoints.js';
 import type { Snapshot } from '../../types/snapshot.js';
+import { type DisplaySnapshot } from './snapshot.js';
+import type { PlacementLabel } from '../placements/placementLabels.model.js';
 type Metric = Snapshot['metrics'][number];
 type Arm = Metric['perArm'][number];
 type Decision = {
     phase: number;
     winnerArm?: string;
 };
-type DisplaySnapshot = Snapshot;
 export declare function defaultRound({ phases, decision, status }: Pick<ResultsResponse, 'phases'> & {
     decision?: Decision | null;
     status: Status;
@@ -26,8 +27,8 @@ export type VerdictCardModel = {
     guardrailLine?: string;
 };
 export declare function verdictCard({ snapshot, decisionSnapshot, isDecidedTestRound, winnerLabel }: {
-    snapshot: Snapshot;
-    decisionSnapshot?: Snapshot;
+    snapshot: DisplaySnapshot;
+    decisionSnapshot?: DisplaySnapshot;
     isDecidedTestRound: boolean;
     winnerLabel: string;
 }): VerdictCardModel;
@@ -73,11 +74,11 @@ export interface ArmRow {
     comparison?: ComparisonModel;
 }
 export declare function armRows({ snapshot, phase, metricId }: {
-    snapshot: Snapshot;
+    snapshot: DisplaySnapshot;
     phase: PhaseSummary;
     metricId: DocId;
 }): ArmRow[];
-export declare function guardrailChips(snapshot: Snapshot): {
+export declare function guardrailChips(snapshot: DisplaySnapshot): {
     name: string;
     status: "OK" | "Watch" | "Failing" | "Too little data";
 }[];
@@ -88,6 +89,7 @@ interface RoundLineInput {
 }
 export declare function powerLine({ snapshot, phaseKind, status }: RoundLineInput): string | null;
 export interface ResultsContext {
+    placementLabels?: Map<string, PlacementLabel>;
     status?: string;
     phase?: PhaseSummary;
     minExposuresPerArm?: number;
@@ -102,8 +104,9 @@ export interface DataQualityItem {
     message: string;
     detail?: string;
     nextStep: string;
+    href?: string;
     shares?: string[];
 }
 export declare function dataQuality(snapshot: DisplaySnapshot, ctx?: ResultsContext): DataQualityItem[];
-export declare function verdictLabel(snapshot: Snapshot): string;
+export declare function verdictLabel(snapshot: DisplaySnapshot): string;
 export {};

package/dist/admin/results/results.model.js

@@ -1,7 +1,10 @@
-import { READINESS_COPY, versionPageUnavailableCopy, versionPageUncheckedCopy } from '../copy/readiness.js';
+import { READINESS_COPY, placementUncheckedCopy, versionPageUnavailableCopy, versionPageUncheckedCopy } from '../copy/readiness.js';
 import { armLabel, phaseKindLabel, verdictCodeLabel } from '../labels.js';
 import { RESULTS_COPY, cappedCount, collectingCopy, conflictCopy, decidedTitle, exclusionCopy, ignoredCopy, metricUnavailable, moreDays, roundLabel, shareCopy, shippingTitle, srmP, uncappedTotal } from '../copy/results.js';
 import { formatCI, formatCount, formatMetric, formatPercent, formatProbability } from './format.js';
+import { legacyMinimum, legacyRolloutLine, legacyTooFew } from './legacy.js';
+import { isLegacySnapshot } from './snapshot.js';
+import { placementDetailKey } from '../placements/placementLabels.model.js';
 export function defaultRound({ phases, decision, status }) {
     if ((status === 'decided' || status === 'archived') && decision) return decision.phase;
     return phases.reduce((latest, phase)=>latest === null || phase.phase > latest ? phase.phase : latest, null);
@@ -29,9 +32,10 @@ export function verdictCard({ snapshot, decisionSnapshot, isDecidedTestRound, wi
 }
 export function rolloutLine(snapshot, phase, phases, decision) {
     if (snapshot.phaseKind !== 'rollout') return null;
-    const newestRollout = phases.filter((phase)=>phase.phaseKind === 'rollout').reduce((latest, phase)=>latest === null || phase.phase > latest ? phase.phase : latest, null);
-    const winner = snapshot.winnerArm ?? (snapshot.phase === newestRollout ? decision?.winnerArm : undefined);
-    return shippingTitle(winner ? phase.arms.find((arm)=>arm.key === winner)?.label ?? armLabel(winner) : RESULTS_COPY.shippedGroup);
+    return isLegacySnapshot(snapshot) ? legacyRolloutLine(snapshot, phase, phases, decision) : currentRolloutLine(snapshot, phase);
+}
+function currentRolloutLine(snapshot, phase) {
+    return snapshot.winnerArm === null ? null : shippingTitle(phase.arms.find((arm)=>arm.key === snapshot.winnerArm)?.label ?? armLabel(snapshot.winnerArm));
 }
 export function cappedCell({ metric, arm, caps }) {
     const cap = caps?.[metric.metricId];
@@ -125,14 +129,23 @@ function smallest(values) {
     if (phaseKind !== 'rollout' || snapshot.verdict.code !== 'rollout-collecting') return null;
     const keys = comparedKeys(snapshot, ctx.phase);
     const primary = snapshot.metrics.find((metric)=>metric.role === 'primary');
-    return collectingCopy(formatCount(smallest(keys.map((key)=>snapshot.exposures.perArm[key]))), formatCount(snapshot.minExposuresPerArm ?? ctx.minExposuresPerArm), formatCount(smallest(keys.map((key)=>primary?.perArm.find((arm)=>arm.arm === key)?.converters))), formatCount(primary ? snapshot.params.minSampleSizes[primary.metricId] : undefined));
+    return collectingCopy(formatCount(smallest(keys.map((key)=>snapshot.exposures.perArm[key]))), formatCount(isLegacySnapshot(snapshot) ? legacyMinimum(snapshot, ctx) : snapshot.minExposuresPerArm), formatCount(smallest(keys.map((key)=>primary?.perArm.find((arm)=>arm.arm === key)?.converters))), formatCount(primary ? snapshot.params.minSampleSizes[primary.metricId] : undefined));
 }
 export function dataQuality(snapshot, ctx = {}) {
     const items = (snapshot.health ?? []).map((item)=>({
-            id: `${item.code}:${item.path}`,
-            message: READINESS_COPY.needsAttention,
-            nextStep: item.code === 'version-page-unavailable' ? versionPageUnavailableCopy(item.path, ctx.status) : versionPageUncheckedCopy(item.path, ctx.status)
+            id: item.code === 'placement-unchecked' ? `${item.code}:${JSON.stringify(item.detail)}` : `${item.code}:${'path' in item ? item.path : item.metricId}`,
+            message: item.code === 'placement-unchecked' ? placementUncheckedCopy(ctx.placementLabels?.get(placementDetailKey(item.detail))?.title ?? item.detail.path ?? 'This page') : item.code === 'goal-in-some-versions' ? `${item.name} now appears in some versions but not all, so this result is no longer a fair comparison. Add it to every version, or remove it.` : READINESS_COPY.needsAttention,
+            ...item.code === 'placement-unchecked' ? {
+                href: ctx.placementLabels?.get(placementDetailKey(item.detail))?.href
+            } : {},
+            nextStep: item.code === 'placement-unchecked' ? `Open ${ctx.placementLabels?.get(placementDetailKey(item.detail))?.title ?? item.detail.path ?? 'the page'}` : item.code === 'goal-in-some-versions' ? 'Edit the versions' : item.code === 'version-page-unavailable' ? versionPageUnavailableCopy(item.path, ctx.status) : versionPageUncheckedCopy(item.path, ctx.status)
         }));
+    // Test snapshots store null by design; only rollout snapshots record the shipped winner.
+    if (!isLegacySnapshot(snapshot) && snapshot.phaseKind === 'rollout' && snapshot.winnerArm === null) items.push({
+        id: 'missing-winner',
+        message: RESULTS_COPY.missingWinner,
+        nextStep: RESULTS_COPY.missingWinnerNext
+    });
     const srmTotal = Object.keys(snapshot.srm.expected).reduce((total, key)=>total + (snapshot.exposures.perArm[key] ?? 0), 0);
     if (snapshot.srm.flagged) items.push({
         id: 'srm',
@@ -159,7 +172,7 @@ export function dataQuality(snapshot, ctx = {}) {
         detail: conflictCopy(formatPercent(exposures.identityConflictShare)),
         nextStep: RESULTS_COPY.identityNext
     });
-    if (snapshot.verdict.code === 'collecting' || snapshot.verdict.code === 'rollout-collecting') items.push({
+    if (isLegacySnapshot(snapshot) ? legacyTooFew(snapshot) : snapshot.verdict.code === 'collecting' || snapshot.verdict.code === 'rollout-collecting') items.push({
         id: 'too-few',
         message: RESULTS_COPY.tooFew,
         nextStep: RESULTS_COPY.tooFewNext

package/dist/admin/results/snapshot.d.ts

@@ -0,0 +1,14 @@
+import type { Snapshot } from '../../types/snapshot.js';
+type Core15aFields = Pick<Snapshot, 'winnerArm' | 'minExposuresPerArm'>;
+/** Immutable history written before CORE-15a, with at least one added field absent. */
+export type LegacySnapshot = Omit<Snapshot, keyof Core15aFields> & ({
+    winnerArm?: undefined;
+    minExposuresPerArm?: number;
+} | {
+    winnerArm?: string | null;
+    minExposuresPerArm?: undefined;
+});
+export type DisplaySnapshot = Snapshot | LegacySnapshot;
+/** A stored null winner is current data; only missing CORE-15a fields mark history. */
+export declare function isLegacySnapshot(snapshot: DisplaySnapshot): snapshot is LegacySnapshot;
+export {};

package/dist/admin/results/snapshot.js

@@ -0,0 +1,3 @@
+/** A stored null winner is current data; only missing CORE-15a fields mark history. */ export function isLegacySnapshot(snapshot) {
+    return snapshot.winnerArm === undefined || snapshot.minExposuresPerArm === undefined;
+}

package/dist/admin/surface/TestsHome.js

@@ -1,14 +1,15 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from 'react';
-import { Link } from '@payloadcms/ui';
 import { formatAdminURL } from 'payload/shared';
+import { fetchAllDocs } from '../../lib/fetchAllDocs.js';
 import { createApi } from '../api.js';
 import { noMatchesLine, SURFACE_COPY } from '../copy/surface.js';
 import { Banner, EmptyState, StatusChip } from '../../ui/Feedback.js';
 import { Button } from '../../ui/Button.js';
 import { SearchInput } from '../../ui/Inputs.js';
 import { SurfaceShell } from './SurfaceShell.js';
+import { sanitizeReadinessDetail } from '../../sanitizeReadinessDetail.js';
 import { groupTests, homeCard } from './home.model.js';
 const HOME_FIELDS = [
     'name',
@@ -19,7 +20,8 @@ const HOME_FIELDS = [
     'decidedAt',
     'decision',
     'unitType',
-    'flagPoint'
+    'flagPoint',
+    'updatedAt'
 ];
 // Typecheck fails if HomeTest gains a field the list request does not select (Payload always returns id).
 const homeFieldsComplete = true;
@@ -42,20 +44,48 @@ export function TestsHome({ adminRoute, apiRoute, canManage = false, crumbs, fla
         });
         async function load() {
             try {
-                const response = await fetch(`${apiRoute.replace(/\/$/, '')}/xp-experiments?depth=0&sort=-updatedAt&limit=200&${HOME_SELECT}`, {
+                const response = await fetchAllDocs(`${apiRoute.replace(/\/$/, '')}/xp-experiments?depth=0&sort=id&${HOME_SELECT}`, {
                     credentials: 'include',
                     signal: controller.signal
                 });
                 if (!response.ok) throw new Error('list');
-                const { docs, totalDocs } = await response.json();
+                const docs = response.docs.sort((a, b)=>(Date.parse(b.updatedAt ?? '') || 0) - (Date.parse(a.updatedAt ?? '') || 0));
                 if (!active) return;
                 const summary = await api.summary(docs.map((doc)=>doc.id));
+                const summaries = summary.ok ? summary.data ?? {} : {};
+                const ids = [
+                    ...new Set(docs.flatMap((doc)=>{
+                        const item = summaries[doc.id];
+                        if (!canManage || ![
+                            'draft',
+                            'stopped'
+                        ].includes(doc.status) || item?.ready === true || item?.next?.code !== 'goal-in-some-versions') return [];
+                        const detail = sanitizeReadinessDetail(item.next.code, item.next.detail);
+                        return detail?.map((row)=>String(row.metricId)) ?? [];
+                    }))
+                ];
+                const goalNames = {};
+                if (ids.length) {
+                    try {
+                        const query = new URLSearchParams({
+                            'where[id][in]': ids.join(','),
+                            depth: '0',
+                            limit: String(ids.length)
+                        });
+                        const response = await fetch(`${apiRoute.replace(/\/$/, '')}/xp-metrics?${query}`, {
+                            credentials: 'include',
+                            signal: controller.signal
+                        });
+                        const body = response.ok ? await response.json() : undefined;
+                        for (const goal of body?.docs ?? [])if (typeof goal.name === 'string' && goal.name.trim() && ids.includes(String(goal.id))) goalNames[String(goal.id)] = goal.name;
+                    } catch  {}
+                }
                 if (active) setState({
                     loading: false,
                     error: false,
                     tests: docs,
-                    limited: totalDocs > docs.length,
-                    summaries: summary.ok ? summary.data ?? {} : {},
+                    goalNames,
+                    summaries,
                     summaryError: !summary.ok
                 });
             } catch  {
@@ -73,7 +103,8 @@ export function TestsHome({ adminRoute, apiRoute, canManage = false, crumbs, fla
     }, [
         api,
         apiRoute,
-        attempt
+        attempt,
+        canManage
     ]);
     const retry = /*#__PURE__*/ _jsx(Button, {
         size: "sm",
@@ -152,20 +183,17 @@ export function TestsHome({ adminRoute, apiRoute, canManage = false, crumbs, fla
                 }) : /*#__PURE__*/ _jsx(TestGroups, {
                     tests: state.tests,
                     summaries: state.summaries,
+                    goalNames: state.goalNames,
                     adminRoute: adminRoute,
                     flagPoints: flagPoints,
                     search: search,
                     clear: ()=>setSearch('')
-                }),
-                state.limited ? /*#__PURE__*/ _jsx("p", {
-                    className: "xp-tests-limited",
-                    children: SURFACE_COPY.limitedList
-                }) : null
+                })
             ]
         })
     });
 }
-function TestGroups({ tests, summaries, adminRoute, flagPoints, search, clear }) {
+function TestGroups({ tests, summaries, goalNames, adminRoute, flagPoints, search, clear }) {
     const groups = groupTests(tests, summaries, search);
     if (!groups.some((group)=>group.tests.length)) return /*#__PURE__*/ _jsxs("div", {
         className: "xp-tests-no-matches",
@@ -187,7 +215,7 @@ function TestGroups({ tests, summaries, adminRoute, flagPoints, search, clear })
             const rows = /*#__PURE__*/ _jsx("div", {
                 className: "xp-tests-list",
                 children: group.tests.map((test)=>{
-                    const card = homeCard(test, summaries[test.id], adminRoute, flagPoints);
+                    const card = homeCard(test, summaries[test.id], adminRoute, flagPoints, goalNames);
                     return /*#__PURE__*/ _jsxs("article", {
                         className: "xp-tests-row",
                         children: [
@@ -197,7 +225,7 @@ function TestGroups({ tests, summaries, adminRoute, flagPoints, search, clear })
                                     /*#__PURE__*/ _jsxs("div", {
                                         className: "xp-tests-row-name",
                                         children: [
-                                            /*#__PURE__*/ _jsx(Link, {
+                                            /*#__PURE__*/ _jsx("a", {
                                                 href: card.href,
                                                 children: test.name
                                             }),

package/dist/admin/surface/TestsSurface.js

@@ -28,7 +28,11 @@ function SurfacePage(props) {
         flagPoints: props.flagPoints,
         attributeKeys: props.attributeKeys,
         metricSources: props.metricSources,
-        descriptions: props.admin?.descriptions
+        admin: props.admin,
+        pageCollections: props.pageCollections,
+        collectionTitles: props.collectionTitles,
+        userId: props.userId,
+        userCollection: props.userCollection
     };
     const crumbs = [
         {

package/dist/admin/surface/contracts.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentType } from 'react';
+import type { TestsSurfaceProps } from '../../types/surface.js';
 import type { SerializedAttributeKeys, SerializedFlagPoint, SerializedMetricSource } from '../../types/admin.js';
 import type { useTestDocument } from './useTestDocument.js';
 /** Sections of the test page, in readiness order (surface spec §6.2, §8). */
@@ -10,17 +11,17 @@ export type TestDocApi = ReturnType<typeof useTestDocument>;
 export interface SurfaceProps {
     adminRoute: string;
     apiRoute: string;
+    collectionTitles?: Record<string, string>;
+    userId?: string | number;
+    userCollection?: string;
     canManage: boolean;
     canReadResults: boolean;
     isAdmin: boolean;
     flagPoints: SerializedFlagPoint[];
     attributeKeys: SerializedAttributeKeys;
     metricSources: SerializedMetricSource[];
-    descriptions?: {
-        block?: string;
-        document?: string;
-        setting?: string;
-    };
+    pageCollections?: TestsSurfaceProps['pageCollections'];
+    admin?: TestsSurfaceProps['admin'];
 }
 export interface SectionProps {
     test: TestDocApi;