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

package/dist/plugin.js

@@ -1,9 +1,10 @@
 import { buildCollections } from './collections/index.js';
 import { buildEndpoints } from './endpoints/index.js';
 import { contentChangesBeforeHook, contentChangesHook } from './hooks/contentChanges.js';
-import { pageGuardAfterOperation, pageGuardBeforeChange, pageGuardBeforeDelete, pageGuardBeforeOperation } from './hooks/pageGuard.js';
+import { pageGuardAfterChange, pageGuardAfterOperation, pageGuardBeforeChange, pageGuardBeforeDelete, pageGuardBeforeOperation } from './hooks/pageGuard.js';
 import { createOnInit } from './onInit.js';
 import { puckCollections, resolveOptions } from './options.js';
+import { injectTestBlock } from './admin/blocks/inject.js';
 import * as paths from './admin/paths.js';
 export function createExperimentsPlugin(input) {
     const options = resolveOptions(input);
@@ -15,6 +16,9 @@ export function createExperimentsPlugin(input) {
         for (const { slug } of options.pages?.collections ?? []){
             if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments page collection: ${slug}`);
         }
+        for (const { slug } of options.blocks?.collections ?? []){
+            if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments blocks collection: ${slug}`);
+        }
         // The frozen factories consume registration/access metadata, never TUser callbacks.
         // Erase the user subtype only at this non-generic factory boundary.
         const { collections, globals } = buildCollections(options);
@@ -59,40 +63,49 @@ export function createExperimentsPlugin(input) {
                 ...(config.collections ?? []).map((collection)=>{
                     const puck = options.puck?.enabled && registrations.some((entry)=>entry.slug === collection.slug);
                     const page = options.pages?.collections.some((entry)=>entry.slug === collection.slug);
-                    if (!puck && !page) return collection;
+                    const blocks = options.blocks?.collections.find((entry)=>entry.slug === collection.slug);
+                    if (!puck && !page && !blocks) return collection;
                     return {
                         ...collection,
+                        fields: [
+                            ...page ? [
+                                {
+                                    name: 'xpPlacementStatus',
+                                    type: 'ui',
+                                    admin: {
+                                        position: 'sidebar',
+                                        components: {
+                                            Field: paths.XP_PLACEMENT_STATUS
+                                        }
+                                    }
+                                }
+                            ] : [],
+                            ...blocks ? injectTestBlock(collection.fields, blocks) : collection.fields
+                        ],
                         hooks: {
                             ...collection.hooks,
                             beforeChange: [
                                 ...collection.hooks?.beforeChange ?? [],
-                                ...page ? [
-                                    pageGuardBeforeChange
-                                ] : [],
-                                ...puck ? [
-                                    contentChangesBeforeHook
-                                ] : []
+                                pageGuardBeforeChange,
+                                contentChangesBeforeHook
+                            ],
+                            beforeOperation: [
+                                ...collection.hooks?.beforeOperation ?? [],
+                                pageGuardBeforeOperation
+                            ],
+                            beforeDelete: [
+                                ...collection.hooks?.beforeDelete ?? [],
+                                pageGuardBeforeDelete
+                            ],
+                            afterOperation: [
+                                pageGuardAfterOperation,
+                                ...collection.hooks?.afterOperation ?? []
                             ],
-                            ...page ? {
-                                beforeOperation: [
-                                    ...collection.hooks?.beforeOperation ?? [],
-                                    pageGuardBeforeOperation
-                                ],
-                                beforeDelete: [
-                                    ...collection.hooks?.beforeDelete ?? [],
-                                    pageGuardBeforeDelete
-                                ],
-                                afterOperation: [
-                                    pageGuardAfterOperation,
-                                    ...collection.hooks?.afterOperation ?? []
-                                ]
-                            } : {},
-                            ...puck ? {
-                                afterChange: [
-                                    ...collection.hooks?.afterChange ?? [],
-                                    contentChangesHook
-                                ]
-                            } : {}
+                            afterChange: [
+                                ...collection.hooks?.afterChange ?? [],
+                                pageGuardAfterChange,
+                                contentChangesHook
+                            ]
                         }
                     };
                 }),

package/dist/puck/copy.d.ts

@@ -1,3 +1,4 @@
+export declare const categoryTitle = "A/B tests";
 export declare const slotLabels: {
     readonly control: "Original";
     readonly variantA: "Variant A";

package/dist/puck/copy.js

@@ -1,4 +1,5 @@
 import { ARM_LABELS } from '../labels/arms.js';
+export const categoryTitle = 'A/B tests';
 export const slotLabels = {
     control: ARM_LABELS.control,
     variantA: ARM_LABELS.variantA,

package/dist/puck/editor/editor.chrome.css

@@ -119,3 +119,4 @@
 .xp-slot-readout { display: grid; gap: var(--xp-space-2); }
 .xp-slot-readout > .xp-ui-button { justify-self: start; }
 .xp-slot-editor .xp-ui-tablist { flex: 1 1 auto; min-width: 0; flex-wrap: wrap; }
+.xp-slot-root.xp-puck-field { display: grid; gap: var(--xp-space-3); min-width: 0; }

package/dist/puck/editor/editor.css

@@ -384,3 +384,4 @@
 .xp-slot-readout { display: grid; gap: var(--xp-space-2); }
 .xp-slot-readout > .xp-ui-button { justify-self: start; }
 .xp-slot-editor .xp-ui-tablist { flex: 1 1 auto; min-width: 0; flex-wrap: wrap; }
+.xp-slot-root.xp-puck-field { display: grid; gap: var(--xp-space-3); min-width: 0; }

package/dist/puck/editor/editor.model.d.ts

@@ -17,10 +17,11 @@ export declare function bannerFor(status?: Status | null, winner?: string): stri
 export declare function slugify(name: string): string;
 /** Complete draft defaults, shared by the page hand-off and setting creation. */
 export declare function newTestBody(input: {
-    kind: 'block' | 'flag';
+    kind: 'block' | 'flag' | 'page';
     name: string;
     slug: string;
     unitType: UnitType;
+    pageCollection?: string;
     flagPoint?: string;
     layer?: DocId;
     hypothesis?: string;
@@ -28,9 +29,10 @@ export declare function newTestBody(input: {
     hypothesis?: string | undefined;
     layer?: DocId | undefined;
     flagPoint?: string | undefined;
+    pageCollection?: string | undefined;
     name: string;
     slug: string;
-    kind: "block" | "flag";
+    kind: "block" | "page" | "flag";
     unitType: UnitType;
     exposurePolicy: string;
     arms: Arm[];

package/dist/puck/editor/editor.model.js

@@ -32,7 +32,7 @@ export function slugify(name) {
     return name.normalize('NFKD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64).replace(/-+$/g, '');
 }
 /** Complete draft defaults, shared by the page hand-off and setting creation. */ export function newTestBody(input) {
-    const { kind, name, slug, unitType, flagPoint, layer, hypothesis } = input;
+    const { kind, name, slug, unitType, flagPoint, layer, hypothesis, pageCollection } = input;
     const arms = [
         {
             key: 'control',
@@ -57,13 +57,16 @@ export function slugify(name) {
         name,
         slug,
         kind,
-        unitType,
-        exposurePolicy: kind === 'block' ? 'render' : 'manual',
+        unitType: kind === 'page' ? 'visitor' : unitType,
+        exposurePolicy: kind === 'block' ? 'render' : kind === 'page' ? 'pageview' : 'manual',
         arms,
         allocation: 100,
         analysis: {
             plannedDurationDays: 28
         },
+        ...pageCollection === undefined ? {} : {
+            pageCollection
+        },
         ...flagPoint === undefined ? {} : {
             flagPoint
         },

package/dist/puck/editor/integration.d.ts

@@ -0,0 +1,10 @@
+import { type ExperimentsPuckIntegration } from '../../types/puck.js';
+import type { PuckRoutes } from '../routes.js';
+/**
+ * Call once at module scope in a 'use client' module. A new object per render
+ * rebuilds Puck's config and plugin list.
+ */
+export declare function experimentsPuckEditor({ routes, accent }?: {
+    routes?: PuckRoutes;
+    accent?: string;
+}): ExperimentsPuckIntegration;

package/dist/puck/editor/integration.js

@@ -0,0 +1,30 @@
+'use client';
+import { EXPERIMENT_SLOT_TYPE } from '../../types/puck.js';
+import { categoryTitle } from '../copy.js';
+import { createExperimentSlotEditor } from './ExperimentSlotEditor.js';
+import { experimentOutlinePlugin } from './experimentOutlinePlugin.js';
+/**
+ * Call once at module scope in a 'use client' module. A new object per render
+ * rebuilds Puck's config and plugin list.
+ */ export function experimentsPuckEditor({ routes, accent } = {}) {
+    return {
+        name: 'experiments',
+        components: {
+            [EXPERIMENT_SLOT_TYPE]: createExperimentSlotEditor({
+                routes,
+                accent
+            })
+        },
+        categories: {
+            experiments: {
+                title: categoryTitle,
+                components: [
+                    EXPERIMENT_SLOT_TYPE
+                ]
+            }
+        },
+        plugins: [
+            experimentOutlinePlugin()
+        ]
+    };
+}

package/dist/puck/editor/xpGoalPuckEditorField.d.ts

@@ -0,0 +1,7 @@
+import type { CustomField } from '@puckeditor/core';
+import { type PuckRoutes } from '../routes.js';
+import './editor.css';
+/** Editor config only. The render config keeps xpGoalPuckField() from /puck. */
+export declare function xpGoalPuckEditorField(options?: {
+    routes?: PuckRoutes;
+}): CustomField<string>;

package/dist/puck/editor/xpGoalPuckEditorField.js

@@ -0,0 +1,134 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId } from 'react';
+import { useClickGoalPicker } from '../../goals/picker/useClickGoalPicker.js';
+import { CLICK_GOAL_COPY as C } from '../../goals/picker/copy.js';
+import { TextInput, Select } from '../../ui/Inputs.js';
+import { Button } from '../../ui/Button.js';
+import { resolvePuckRoutes } from '../routes.js';
+import './editor.css';
+function XpGoalPuckEditor({ value, onChange, api, readOnly }) {
+    const picker = useClickGoalPicker(api, {
+        onSelect: onChange
+    });
+    const id = useId();
+    const stopEnter = (event)=>{
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-slot-root xp-puck-field",
+        children: [
+            /*#__PURE__*/ _jsx(TextInput, {
+                id: `${id}-value`,
+                label: C.label,
+                value: value ?? '',
+                readOnly: readOnly,
+                onChange: (event)=>onChange(event.currentTarget.value)
+            }),
+            picker.canManage && !readOnly ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsxs(Select, {
+                        id: `${id}-picker`,
+                        label: C.choose,
+                        value: picker.goals.some((goal)=>goal.slug === value) ? value : '',
+                        onChange: (event)=>{
+                            if (event.currentTarget.value) onChange(event.currentTarget.value);
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx("option", {
+                                value: "",
+                                children: C.choose
+                            }),
+                            picker.goals.map((goal)=>/*#__PURE__*/ _jsx("option", {
+                                    value: goal.slug,
+                                    children: goal.name
+                                }, goal.id))
+                        ]
+                    }),
+                    picker.undefinedKey(value ?? '') ? /*#__PURE__*/ _jsx("p", {
+                        className: "xp-ui-help",
+                        role: "status",
+                        children: C.undefinedKey
+                    }) : null,
+                    !picker.panel.open ? /*#__PURE__*/ _jsx(Button, {
+                        type: "button",
+                        onClick: picker.open,
+                        children: C.newGoal
+                    }) : /*#__PURE__*/ _jsxs("section", {
+                        "aria-labelledby": `${id}-title`,
+                        children: [
+                            /*#__PURE__*/ _jsx("h3", {
+                                id: `${id}-title`,
+                                children: C.title
+                            }),
+                            /*#__PURE__*/ _jsx(TextInput, {
+                                id: `${id}-name`,
+                                label: C.name,
+                                value: picker.panel.name,
+                                disabled: picker.panel.pending,
+                                onKeyDown: stopEnter,
+                                onChange: (event)=>picker.setName(event.currentTarget.value)
+                            }),
+                            /*#__PURE__*/ _jsxs("details", {
+                                open: picker.panel.advanced,
+                                onToggle: (event)=>picker.setAdvanced(event.currentTarget.open),
+                                children: [
+                                    /*#__PURE__*/ _jsx("summary", {
+                                        children: C.advanced
+                                    }),
+                                    /*#__PURE__*/ _jsx(TextInput, {
+                                        id: `${id}-slug`,
+                                        label: C.slug,
+                                        value: picker.panel.slug,
+                                        disabled: picker.panel.pending,
+                                        onKeyDown: stopEnter,
+                                        error: picker.panel.errors.slug,
+                                        onChange: (event)=>picker.setSlug(event.currentTarget.value)
+                                    })
+                                ]
+                            }),
+                            picker.panel.errors.general ? /*#__PURE__*/ _jsx("p", {
+                                className: "xp-ui-error",
+                                role: "alert",
+                                children: picker.panel.errors.general
+                            }) : null,
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "xp-ui-button-group",
+                                children: [
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        type: "button",
+                                        disabled: picker.panel.pending || !picker.panel.name.trim(),
+                                        onClick: ()=>void picker.create(),
+                                        children: C.createGoal
+                                    }),
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        type: "button",
+                                        disabled: picker.panel.pending,
+                                        onClick: picker.cancel,
+                                        children: C.cancel
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            }) : null
+        ]
+    });
+}
+/** Editor config only. The render config keeps xpGoalPuckField() from /puck. */ export function xpGoalPuckEditorField(options) {
+    const routes = resolvePuckRoutes(options?.routes);
+    return {
+        type: 'custom',
+        label: C.label,
+        render: ({ value, onChange, readOnly })=>/*#__PURE__*/ _jsx(XpGoalPuckEditor, {
+                value: value,
+                onChange: onChange,
+                api: routes.api,
+                readOnly: readOnly
+            })
+    };
+}

package/dist/puck/integration.d.ts

@@ -0,0 +1,6 @@
+import { type ExperimentsPuckIntegration } from '../types/puck.js';
+import type { PuckRoutes } from './routes.js';
+/** Bundle the test block and its sidebar category for a host render config. */
+export declare function experimentsPuck({ routes }?: {
+    routes?: PuckRoutes;
+}): ExperimentsPuckIntegration;

package/dist/puck/integration.js

@@ -0,0 +1,21 @@
+import { EXPERIMENT_SLOT_TYPE } from '../types/puck.js';
+import { createExperimentSlot } from './ExperimentSlot.js';
+import { categoryTitle } from './copy.js';
+/** Bundle the test block and its sidebar category for a host render config. */ export function experimentsPuck({ routes } = {}) {
+    return {
+        name: 'experiments',
+        components: {
+            [EXPERIMENT_SLOT_TYPE]: createExperimentSlot({
+                routes
+            })
+        },
+        categories: {
+            experiments: {
+                title: categoryTitle,
+                components: [
+                    EXPERIMENT_SLOT_TYPE
+                ]
+            }
+        }
+    };
+}

package/dist/puck/xpGoalField.d.ts

@@ -0,0 +1,3 @@
+import type { TextField } from '@puckeditor/core';
+/** Prop config only. Components render xpGoal as data-xp-goal. */
+export declare function xpGoalPuckField(): TextField;

package/dist/puck/xpGoalField.js

@@ -0,0 +1,6 @@
+/** Prop config only. Components render xpGoal as data-xp-goal. */ export function xpGoalPuckField() {
+    return {
+        type: 'text',
+        label: 'Click goal'
+    };
+}

package/dist/results/health.d.ts

@@ -0,0 +1,4 @@
+import type { Snapshot, SnapshotHealth } from '../types/snapshot.js';
+/** Refresh page health while retaining health produced by other checks. */
+export declare function mergePageHealth(previous: readonly SnapshotHealth[], pages: readonly SnapshotHealth[]): SnapshotHealth[];
+export declare function canonicalHealth(snapshot: Pick<Snapshot, 'health' | 'goalFairnessNotice'>, ignoreUncheckedPlacements?: boolean): string;

package/dist/results/health.js

@@ -0,0 +1,27 @@
+const healthKey = (row)=>JSON.stringify(row.code === 'placement-unchecked' ? [
+        row.code,
+        row.detail.collection ?? '',
+        row.detail.id ?? '',
+        row.detail.path ?? ''
+    ] : [
+        row.code,
+        'path' in row ? row.path : '',
+        'metricId' in row ? row.metricId : ''
+    ]);
+/** Refresh page health while retaining health produced by other checks. */ export function mergePageHealth(previous, pages) {
+    return [
+        ...new Map([
+            ...previous.filter((row)=>row.code === 'goal-in-some-versions' || row.code === 'placement-unchecked'),
+            ...pages
+        ].map((row)=>[
+                healthKey(row),
+                row
+            ])).values()
+    ];
+}
+export function canonicalHealth(snapshot, ignoreUncheckedPlacements = false) {
+    return JSON.stringify([
+        snapshot.goalFairnessNotice ?? '',
+        ...(snapshot.health ?? []).filter((row)=>!ignoreUncheckedPlacements || row.code !== 'placement-unchecked').map(healthKey).sort()
+    ]);
+}

package/dist/results/snapshot.js

@@ -7,6 +7,7 @@ const count = (value)=>number(value) && Number.isInteger(value) && value >= 0;
 const string = (value)=>typeof value === 'string';
 const boolean = (value)=>typeof value === 'boolean';
 const nullable = (check)=>(value)=>value === null || check(value);
+const union = (...checks)=>(value)=>checks.some((check)=>check(value));
 const list = (check)=>(value)=>Array.isArray(value) && value.every(check);
 const oneOf = (...values)=>(value)=>values.includes(value);
 const isObject = (value)=>value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -140,10 +141,22 @@ const shape = object({
         by: nullable(id)
     }))
 }, {
-    health: list(object({
+    goalFairnessNotice: string,
+    health: list(union(object({
         code: oneOf('version-page-unavailable', 'version-page-unchecked'),
         path: string
-    }))
+    }), object({
+        code: oneOf('goal-in-some-versions'),
+        metricId: id,
+        name: string
+    }), object({
+        code: oneOf('placement-unchecked'),
+        detail: object({}, {
+            collection: string,
+            id,
+            path: string
+        })
+    })))
 });
 /** Validate the frozen JSON shape and headline/rollout invariants before storage.
  * This also accepts the shared CORE-13/admin fixtures without any I/O.

package/dist/sanitizeReadinessDetail.js

@@ -16,6 +16,47 @@ const failure = (value)=>value === 'placements-failed' || value === 'forbidden'
  * counts and layer capacity, which are not identifiers).
  */ export function sanitizeReadinessDetail(code, detail) {
     switch(code){
+        case 'goal-in-some-versions':
+            {
+                const rows = Array.isArray(detail) ? detail : [
+                    detail
+                ];
+                return rows.filter(object).filter((row)=>key(row.metricId) || typeof row.metricId === 'number' && Number.isSafeInteger(row.metricId)).map((row)=>({
+                        metricId: row.metricId
+                    }));
+            }
+        case 'placement-unchecked':
+            return object(detail) ? Object.fromEntries(Object.entries(detail).filter(([k, v])=>k === 'path' ? path(v) : [
+                    'collection',
+                    'id'
+                ].includes(k) && (key(v) || typeof v === 'number' && Number.isSafeInteger(v)))) : undefined;
+        case 'placement-unpublished':
+        case 'duplicate-version-row':
+        case 'interacting-tests':
+            return Array.isArray(detail) ? detail.filter(object).map((row)=>Object.fromEntries(Object.entries(row).filter(([k, v])=>[
+                        'collection',
+                        'id',
+                        'experimentId',
+                        'slug'
+                    ].includes(k) ? key(v) || typeof v === 'number' && Number.isSafeInteger(v) : k === 'path' ? path(v) : k === 'status' ? [
+                        'running',
+                        'decided'
+                    ].includes(String(v)) : k === 'version' && typeof v === 'boolean'))) : undefined;
+        case 'version-same-address':
+            return object(detail) && arm(detail.arm) && arm(detail.otherArm) && path(detail.path) ? {
+                arm: detail.arm,
+                otherArm: detail.otherArm,
+                path: detail.path
+            } : undefined;
+        case 'version-identical':
+            return object(detail) && arm(detail.arm) && key(detail.collection) && (key(detail.id) || typeof detail.id === 'number' && Number.isSafeInteger(detail.id)) ? {
+                arm: detail.arm,
+                collection: detail.collection,
+                id: detail.id,
+                ...path(detail.path) ? {
+                    path: detail.path
+                } : {}
+            } : undefined;
         case 'block-path-rule':
             return object(detail) && Array.isArray(detail.rules) && detail.rules.length && detail.rules.every((index)=>Number.isSafeInteger(index) && index >= 0) ? {
                 rules: detail.rules

package/dist/server/pageKindSeoContract.d.ts

@@ -0,0 +1,27 @@
+import type { Manifest } from '../types/manifest.js';
+export interface PageKindSeoContractOptions {
+    secret: string;
+    original: string;
+    versions: string[];
+    state: 'running' | 'decided' | 'archived';
+    winner?: string;
+}
+export interface PageKindSeoContractRow {
+    requestPath: string;
+    servedPath: string;
+    headers: {
+        'x-xp-request': string;
+    };
+    expect: {
+        robots?: {
+            index: false;
+        };
+        canonical?: string;
+        inSitemap: boolean;
+    };
+}
+/** Host-test fixture: use this manifest in the runtime that serves the signed row headers. */
+export declare function pageKindSeoContract({ secret, original, versions, state, winner }: PageKindSeoContractOptions): {
+    manifest: Manifest;
+    rows: PageKindSeoContractRow[];
+};

package/dist/server/pageKindSeoContract.js

@@ -0,0 +1,80 @@
+import { sign } from '../runtime/signing.js';
+import { normalisePath } from '../runtime/normalisePath.js';
+/** Host-test fixture: use this manifest in the runtime that serves the signed row headers. */ export function pageKindSeoContract({ secret, original, versions, state, winner }) {
+    const paths = [
+        original,
+        ...versions
+    ];
+    if (!secret || paths.some((path)=>!path.startsWith('/') || /[\\\r\n#|]/.test(path)) || new Set(paths.map(normalisePath)).size !== paths.length || !versions.length || versions.length > 3 || state !== 'running' && (!winner || !paths.includes(winner))) throw new Error('Invalid page SEO contract');
+    const manifest = {
+        v: 1,
+        revision: 1,
+        experiments: [],
+        flagDefaults: {},
+        archivedWinners: {},
+        archivedPages: {}
+    };
+    if (state === 'archived') {
+        for (const path of paths)if (path !== winner) manifest.archivedPages[path] = {
+            slug: 'page-seo-contract',
+            winnerPath: winner
+        };
+    } else {
+        manifest.experiments.push({
+            id: 'page-seo-contract',
+            slug: 'page-seo-contract',
+            kind: 'page',
+            unitType: 'visitor',
+            status: state,
+            phase: 1,
+            phaseKind: 'test',
+            seed: 'page-seo-contract|',
+            coverage: 1,
+            targeting: [],
+            exposurePolicy: 'pageview',
+            deferrable: false,
+            arms: paths.map((path, index)=>({
+                    key: index === 0 ? 'control' : `variant${String.fromCharCode(64 + index)}`,
+                    kind: index === 0 ? 'control' : 'variant',
+                    weight: index === paths.length - 1 ? 100 - Math.floor(100 / paths.length) * index : Math.floor(100 / paths.length),
+                    pageTarget: path
+                })),
+            ...winner ? {
+                winnerArm: paths.indexOf(winner) === 0 ? 'control' : `variant${String.fromCharCode(64 + paths.indexOf(winner))}`
+            } : {}
+        });
+    }
+    const rows = [];
+    for (const requestPath of paths){
+        const servedPaths = state === 'running' ? paths : [
+            winner
+        ];
+        for (const servedPath of servedPaths){
+            const canonical = state === 'archived' ? requestPath === winner ? undefined : winner : original;
+            rows.push({
+                requestPath,
+                servedPath,
+                headers: {
+                    'x-xp-request': `GET|${requestPath}|c1|${sign(`xp:request:GET|${requestPath}|c1`, [
+                        secret
+                    ])}`
+                },
+                expect: {
+                    ...state !== 'archived' && requestPath !== original ? {
+                        robots: {
+                            index: false
+                        }
+                    } : {},
+                    ...canonical ? {
+                        canonical
+                    } : {},
+                    inSitemap: state === 'archived' ? requestPath === winner : requestPath === original
+                }
+            });
+        }
+    }
+    return {
+        manifest,
+        rows
+    };
+}