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

package/dist/admin/blocks/formApi.js

@@ -0,0 +1,153 @@
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks } from '../../blocks/model.js';
+import { BLOCK_COPY } from '../copy/blocks.js';
+/** The only form-state failure with block-specific editor copy. */ export class BlockChangedError extends Error {
+    constructor(){
+        super(BLOCK_COPY.blockChanged);
+    }
+}
+export const wrapMode = 'form-api';
+/** Client twin: unnamed layout containers do not contribute to a data path. */ export function findClientBlocksField(fields, name) {
+    for (const field of fields){
+        if (field.type === 'blocks' && field.name === name) return field;
+        if (field.type === 'row' || field.type === 'collapsible') {
+            const found = findClientBlocksField(field.fields, name);
+            if (found) return found;
+        }
+        if (field.type === 'tabs') for (const tab of field.tabs){
+            if ('name' in tab && tab.name) continue;
+            const found = findClientBlocksField(tab.fields, name);
+            if (found) return found;
+        }
+    }
+}
+/** Only schema structure is needed by the pure helpers, never server validators.
+ * Resolve references at every depth, including inside the Experiment slots field.
+ */ export function adaptClientBlocksField(field, config) {
+    function block(block) {
+        return {
+            ...block,
+            fields: block.fields.map(adapt)
+        };
+    }
+    function adapt(field) {
+        if (field.type === 'blocks') return {
+            ...field,
+            blocks: [
+                ...field.blocks.map(block),
+                ...(field.blockReferences ?? []).flatMap((reference)=>{
+                    const resolved = typeof reference === 'string' ? config.blocks?.find((item)=>item.slug === reference) : reference;
+                    return resolved ? [
+                        block(resolved)
+                    ] : [];
+                })
+            ],
+            blockReferences: []
+        };
+        if ('fields' in field) return {
+            ...field,
+            fields: field.fields.map(adapt)
+        };
+        if (field.type === 'tabs') return {
+            ...field,
+            tabs: field.tabs.map((tab)=>({
+                    ...tab,
+                    fields: tab.fields.map(adapt)
+                }))
+        };
+        return field;
+    }
+    return adapt(field);
+}
+export function experimentBlockSlug(field) {
+    return field.blocks.find((block)=>block.fields.some((field)=>'name' in field && field.name === 'xpBlockStatus'))?.slug ?? EXPERIMENT_BLOCK_SLUG;
+}
+export function rowLocation(path) {
+    const match = /^([^.]+)\.(\d+)(?:\.|$)/.exec(path);
+    return match ? {
+        field: match[1],
+        index: Number(match[2])
+    } : undefined;
+}
+export function dataAt(data, path) {
+    return path.split('.').reduce((value, key)=>value && typeof value === 'object' ? value[key] : undefined, data);
+}
+/** Payload 3.90.2 and 4 beta.6 use the same row APIs. Sync replaces the whole
+ * wrapper so add/drop/reorder and the server-rendered component slots stay together.
+ * N=0 needs UPDATE: removeFieldRow alone serializes the empty field as number 0.
+ */ export async function replaceBlockRow(args) {
+    const { form, getFormState, collectionSlug, id, field, index, rows } = args;
+    const data = form.getData(), before = hostBlocks(data[field]);
+    if (args.expectedBlock && JSON.stringify(before[index]) !== JSON.stringify(args.expectedBlock)) throw new BlockChangedError();
+    const original = JSON.stringify(data[field]);
+    const next = [
+        ...before.slice(0, index),
+        ...rows,
+        ...before.slice(index + 1)
+    ];
+    const result = await getFormState({
+        collectionSlug,
+        id,
+        schemaPath: collectionSlug,
+        data: {
+            ...data,
+            [field]: next
+        },
+        docPermissions: args.docPermissions,
+        docPreferences: args.docPreferences ?? {
+            fields: {}
+        },
+        operation: id == null ? 'create' : 'update',
+        renderAllFields: true,
+        skipValidation: true
+    });
+    if (JSON.stringify(form.getDataByPath(field)) !== original) throw new BlockChangedError();
+    if (!result.state) throw new Error('Missing server form state');
+    const state = result.state;
+    function subFieldState(rowIndex) {
+        const prefix = `${field}.${rowIndex}.`;
+        return Object.fromEntries(Object.entries(state).filter(([path])=>path.startsWith(prefix)).map(([path, value])=>[
+                path.slice(prefix.length),
+                value
+            ]));
+    }
+    if (!rows.length) {
+        form.removeFieldRow({
+            path: field,
+            rowIndex: index
+        });
+        if (next.length === 0) form.dispatchFields({
+            type: 'UPDATE',
+            path: field,
+            value: [],
+            disableFormData: false
+        });
+        return;
+    }
+    form.replaceFieldRow({
+        path: field,
+        rowIndex: index,
+        schemaPath: `${collectionSlug}.${field}`,
+        blockType: rows[0].blockType,
+        subFieldState: subFieldState(index)
+    });
+    for(let offset = 1; offset < rows.length; offset++)form.addFieldRow({
+        path: field,
+        rowIndex: index + offset,
+        schemaPath: `${collectionSlug}.${field}`,
+        blockType: rows[offset].blockType,
+        subFieldState: subFieldState(index + offset)
+    });
+    // REPLACE_ROW invents a metadata id even when the data id is unchanged.
+    // Keep server row metadata (including custom labels) and the wrapper React key:
+    // otherwise a sync remounts the status field and loses its save notice.
+    const oldRows = form.getFields()[field]?.rows ?? [];
+    const serverRows = state[field]?.rows;
+    if (serverRows) form.dispatchFields({
+        type: 'UPDATE',
+        path: field,
+        rows: serverRows.map((row)=>({
+                ...oldRows.find((old)=>old.id === row.id),
+                ...row
+            }))
+    });
+}

package/dist/admin/blocks/inject.d.ts

@@ -0,0 +1,7 @@
+import type { Field } from 'payload';
+/** Copy the coordinates supplied by CORE-L2, including every containing array. */
+export declare function injectTestBlock(fields: Field[], registration: {
+    field: string;
+    blockSlug?: string;
+    appliesTo?: (doc: Record<string, unknown>) => boolean;
+}): Field[];

package/dist/admin/blocks/inject.js

@@ -0,0 +1,41 @@
+import { findRegisteredBlocksField } from '../../blocks/formState.js';
+import { XP_TEST_BLOCK } from '../paths.js';
+/** Copy the coordinates supplied by CORE-L2, including every containing array. */ export function injectTestBlock(fields, registration) {
+    const found = findRegisteredBlocksField(fields, registration.field);
+    if (!found) return fields;
+    const ui = {
+        name: 'xpTestBlock',
+        type: 'ui',
+        admin: {
+            condition: (data)=>{
+                try {
+                    return registration.appliesTo ? registration.appliesTo(data) === true : true;
+                } catch  {
+                    return false;
+                }
+            },
+            components: {
+                Field: {
+                    path: XP_TEST_BLOCK,
+                    clientProps: {
+                        blocksField: registration.field,
+                        blockSlug: registration.blockSlug
+                    }
+                }
+            }
+        }
+    };
+    function insert(value, path) {
+        const [key, ...rest] = path;
+        if (key === undefined) return value;
+        const copy = Array.isArray(value) ? [
+            ...value
+        ] : {
+            ...value
+        };
+        if (!rest.length) copy.splice(Number(key) + 1, 0, ui);
+        else copy[key] = insert(value[key], rest);
+        return copy;
+    }
+    return insert(fields, found.path);
+}

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

@@ -0,0 +1,17 @@
+import type { PlacementStatusResult } from '../../types/endpoints.js';
+import type { RowsField } from './formApi.js';
+export type BlockStatus = PlacementStatusResult['slugs'][string];
+export type LiveBlockStatus = Extract<BlockStatus, {
+    status: string;
+}>;
+export declare function liveStatus(status: BlockStatus | null): status is LiveBlockStatus;
+export declare function slotLabel(slot: string, status: BlockStatus | null): string;
+export declare function statusSentence(status: BlockStatus): string;
+export declare function isOrphan(status: BlockStatus): boolean;
+export declare function labelText(value: unknown): string | undefined;
+export declare function blockChoices(value: unknown, field: RowsField, blockSlug: string): {
+    block: import("../../blocks/model.js").HostBlock;
+    index: number;
+    label: string;
+    option: string;
+}[];

package/dist/admin/blocks/model.js

@@ -0,0 +1,45 @@
+import { hostBlocks } from '../../blocks/model.js';
+import { BLOCK_COPY, blockDecidedStatus, blockDraftStatus, blockFinishedStatus, blockPosition } from '../copy/blocks.js';
+export function liveStatus(status) {
+    return !!status && 'status' in status;
+}
+export function slotLabel(slot, status) {
+    return (liveStatus(status) ? status.arms.find((arm)=>arm.key !== 'holdout' && (arm.slot ?? arm.key) === slot)?.label : undefined) || BLOCK_COPY.slotLabels[slot] || slot;
+}
+export function statusSentence(status) {
+    if (!liveStatus(status)) return BLOCK_COPY.deleted;
+    const winner = status.arms.find((arm)=>arm.key === status.winnerArm);
+    const winnerLabel = winner?.label || BLOCK_COPY.slotLabels[status.winnerArm ?? 'control'] || status.winnerArm || BLOCK_COPY.slotLabels.control;
+    switch(status.status){
+        case 'draft':
+            return blockDraftStatus(status.name);
+        case 'running':
+            return BLOCK_COPY.running;
+        case 'stopped':
+            return BLOCK_COPY.stopped;
+        case 'decided':
+            return blockDecidedStatus(winnerLabel, status.rollout);
+        case 'archived':
+            return status.winnerArm ? blockFinishedStatus(winnerLabel) : BLOCK_COPY.discarded;
+    }
+}
+export function isOrphan(status) {
+    return !liveStatus(status) || status.status === 'archived' && !status.winnerArm;
+}
+export function labelText(value) {
+    return typeof value === 'string' ? value : value && typeof value === 'object' ? Object.values(value).find((item)=>typeof item === 'string') : undefined;
+}
+export function blockChoices(value, field, blockSlug) {
+    return hostBlocks(value).flatMap((block, index)=>{
+        if (block.blockType === blockSlug) return [];
+        const label = labelText(field.blocks.find((config)=>config.slug === block.blockType)?.labels?.singular) || block.blockType;
+        return [
+            {
+                block,
+                index,
+                label,
+                option: blockPosition(label, index + 1)
+            }
+        ];
+    });
+}

package/dist/admin/blocks/statusCache.d.ts

@@ -0,0 +1,7 @@
+import type { BlockStatus } from './model.js';
+export declare const validBlockSlug: (slug: unknown) => slug is string;
+/** Only status fields own reads. StrictMode replays the same mount token; a
+ * different owner after the last cleanup starts fresh, even in the same commit.
+ * Deferred eviction removes every entry with no live owner after that commit.
+ */
+export declare function useBlockStatus(api: string, slug: unknown, owner?: boolean): BlockStatus | null;

package/dist/admin/blocks/statusCache.js

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef, useSyncExternalStore } from 'react';
+import { createApi } from '../api.js';
+const cache = new Map();
+// Subscribers do not create status entries: a label alone owns no cached data.
+const listeners = new Map();
+const keyOf = (api, slug)=>JSON.stringify([
+        api,
+        slug
+    ]);
+const publish = (key)=>listeners.get(key)?.callbacks.forEach((listener)=>listener());
+export const validBlockSlug = (slug)=>typeof slug === 'string' && slug.length > 0 && slug.length <= 64;
+/** Only status fields own reads. StrictMode replays the same mount token; a
+ * different owner after the last cleanup starts fresh, even in the same commit.
+ * Deferred eviction removes every entry with no live owner after that commit.
+ */ export function useBlockStatus(api, slug, owner = false) {
+    const key = validBlockSlug(slug) ? keyOf(api, slug) : undefined;
+    const token = useRef({});
+    const subscribe = useCallback((listener)=>{
+        if (!key) return ()=>{};
+        let current = listeners.get(key);
+        if (!current) {
+            current = {
+                callbacks: new Set()
+            };
+            listeners.set(key, current);
+        }
+        current.callbacks.add(listener);
+        return ()=>{
+            current.callbacks = new Set([
+                ...current.callbacks
+            ].filter((item)=>item !== listener));
+            if (!current.callbacks.size) listeners.delete(key);
+        };
+    }, [
+        key
+    ]);
+    const status = useSyncExternalStore(subscribe, ()=>{
+        const current = key ? cache.get(key) : undefined;
+        // A new owner must not sync with the previous mount's snapshot before its
+        // effect registers ownership (or starts the fresh read).
+        return current && (!owner || current.mounts.has(token.current)) ? current.value : null;
+    }, ()=>null);
+    useEffect(()=>{
+        if (!key || !owner || !validBlockSlug(slug)) return;
+        let current = cache.get(key);
+        if (!current || !current.owners && !current.mounts.has(token.current)) {
+            current = {
+                value: null,
+                owners: 0,
+                mounts: new WeakSet()
+            };
+            cache.set(key, current);
+        }
+        const owned = current;
+        owned.owners++;
+        owned.mounts.add(token.current);
+        publish(key);
+        if (!owned.pending) owned.pending = createApi(api).placementStatus({
+            slugs: [
+                slug
+            ]
+        }).then((result)=>{
+            if (cache.get(key) !== owned) return;
+            owned.value = result.ok ? result.data?.slugs[slug] ?? null : null;
+            publish(key);
+        });
+        return ()=>{
+            owned.owners--;
+            queueMicrotask(()=>{
+                if (!owned.owners && cache.get(key) === owned) {
+                    cache.delete(key);
+                    publish(key);
+                }
+            });
+        };
+    }, [
+        api,
+        key,
+        slug,
+        owner
+    ]);
+    return status;
+}

package/dist/admin/blocks/useBlockForm.d.ts

@@ -0,0 +1,17 @@
+import { useConfig, useDocumentInfo, useForm } from '@payloadcms/ui';
+import { adaptClientBlocksField, rowLocation } from './formApi.js';
+import type { ClientCollectionConfig } from 'payload';
+import type { ExperimentBlock, HostBlock } from '../../blocks/model.js';
+/** Declared so the d.ts build can name Payload UI's form types through public exports. */
+export type BlockFormApi = {
+    form: ReturnType<typeof useForm>;
+    document: ReturnType<typeof useDocumentInfo>;
+    config: ReturnType<typeof useConfig>['config'];
+    collection: ClientCollectionConfig | undefined;
+    field: ReturnType<typeof adaptClientBlocksField> | undefined;
+    block: ExperimentBlock | undefined;
+    manager: boolean;
+    replace: (rows: HostBlock[]) => Promise<void>;
+    location: ReturnType<typeof rowLocation>;
+};
+export declare function useBlockForm(path: string): BlockFormApi;

package/dist/admin/blocks/useBlockForm.js

@@ -0,0 +1,46 @@
+import { useMemo } from 'react';
+import { useAuth, useConfig, useDocumentInfo, useForm, useFormFields, useServerFunctions } from '@payloadcms/ui';
+import { adaptClientBlocksField, findClientBlocksField, replaceBlockRow, rowLocation } from './formApi.js';
+export function useBlockForm(path) {
+    const form = useForm(), document = useDocumentInfo(), { config, getEntityConfig } = useConfig();
+    const { getFormState } = useServerFunctions(), { permissions } = useAuth();
+    // useForm's getters are stable; subscribe so changed slug/row paths are read again.
+    useFormFields(([fields])=>fields);
+    const location = rowLocation(path);
+    const collection = document.collectionSlug ? getEntityConfig({
+        collectionSlug: document.collectionSlug
+    }) : undefined;
+    const clientField = location && collection ? findClientBlocksField(collection.fields, location.field) : undefined;
+    const field = useMemo(()=>clientField ? adaptClientBlocksField(clientField, config) : undefined, [
+        clientField,
+        config
+    ]);
+    const block = location ? form.getDataByPath(`${location.field}.${location.index}`) : undefined;
+    const testPermissions = permissions?.collections?.['xp-experiments'];
+    const manager = testPermissions?.update === true;
+    async function replace(rows) {
+        if (!location || !document.collectionSlug) return;
+        await replaceBlockRow({
+            form,
+            getFormState,
+            collectionSlug: document.collectionSlug,
+            id: document.id,
+            ...location,
+            rows,
+            expectedBlock: block,
+            docPermissions: document.docPermissions,
+            docPreferences: await document.getDocPreferences?.()
+        });
+    }
+    return {
+        form,
+        document,
+        config,
+        collection,
+        field,
+        block,
+        manager,
+        replace,
+        location
+    };
+}

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

@@ -1,3 +1,4 @@
+import type { AddMetricWarning } from '../../types/endpoints.js';
 export declare const ACTIONS_COPY: {
     readonly start: "Start";
     readonly restart: "Start a new round";
@@ -70,3 +71,4 @@ export declare const CONTENT_ENTRY_REFUSALS: {
     };
     readonly fallback: "This page can't be changed right now. Reload to see its current state.";
 };
+export declare function addMetricWarningCopy(warning: AddMetricWarning): string;

package/dist/admin/copy/actions.js

@@ -1,3 +1,4 @@
+import { asymmetricGoalsCopy, placementUncheckedCopy } from './readiness.js';
 export const ACTIONS_COPY = {
     start: 'Start',
     restart: 'Start a new round',
@@ -70,3 +71,11 @@ export const CONTENT_ENTRY_REFUSALS = {
     },
     fallback: ACTIONS_COPY.contentEntryFallback
 };
+export function addMetricWarningCopy(warning) {
+    if (warning.code === 'goal-added-mid-test') return "Clicks before this goal was added aren't counted (the same for every version).";
+    if (warning.code === 'placement-unchecked') {
+        const path = warning.detail?.path;
+        return placementUncheckedCopy(typeof path === 'string' ? path : 'This page');
+    }
+    return asymmetricGoalsCopy(warning.detail);
+}

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

@@ -1,6 +1,5 @@
-import type { ArmIssueCode } from '../../types/endpoints.js';
 export { ARM_LABELS as GROUP_LABELS } from '../../labels/arms.js';
-export declare const ISSUE_COPY: Record<ArmIssueCode, string>;
+export { ISSUE_COPY, issueMessage } from '../../arms/copy.js';
 export declare const ARMS_COPY: {
     readonly holdout: "The holdout sees the Original and is measured but not compared during the test. After you decide, it keeps seeing the Original so the winner can be compared with it.";
     readonly pageRequired: "Enter a page path for this group.";
@@ -12,7 +11,3 @@ export declare const ARMS_COPY: {
     readonly paramOption: "Choose an available option for {label}.";
     readonly paramCheckbox: "Choose yes or no for {label}.";
 };
-export declare function issueMessage(issue: {
-    code: string;
-    message: string;
-}, total: number): string;

package/dist/admin/copy/arms.js

@@ -1,16 +1,5 @@
 export { ARM_LABELS as GROUP_LABELS } from '../../labels/arms.js';
-export const ISSUE_COPY = {
-    'weights-total': 'Weights must add up to 100%. They add up to {total}% now.',
-    'control-count': 'Include exactly one Original.',
-    'control-first': 'Put the Original first.',
-    'holdout-last': 'Put the holdout last.',
-    'holdout-count': 'Include only one holdout.',
-    'variant-count': 'Include up to three variants.',
-    'duplicate-key': 'Each group must have a different standard name.',
-    'duplicate-slot': 'Each group must have a different content slot.',
-    'slot-required': 'Choose the matching content slot for this group.',
-    'invalid-key': 'Use the standard group names: Original, Variant A–C, Holdout.'
-};
+export { ISSUE_COPY, issueMessage } from '../../arms/copy.js';
 export const ARMS_COPY = {
     holdout: 'The holdout sees the Original and is measured but not compared during the test. After you decide, it keeps seeing the Original so the winner can be compared with it.',
     pageRequired: 'Enter a page path for this group.',
@@ -22,7 +11,3 @@ export const ARMS_COPY = {
     paramOption: 'Choose an available option for {label}.',
     paramCheckbox: 'Choose yes or no for {label}.'
 };
-export function issueMessage(issue, total) {
-    const copy = Object.hasOwn(ISSUE_COPY, issue.code) ? ISSUE_COPY[issue.code] : issue.message;
-    return copy.replace('{total}', String(total));
-}

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

@@ -0,0 +1,27 @@
+export declare const BLOCK_COPY: {
+    testBlock: string;
+    pick: string;
+    empty: string;
+    blockChanged: string;
+    replace: string;
+    cancel: string;
+    retry: string;
+    saveFirst: string;
+    setup: string;
+    copy: string;
+    confirmCopy: string;
+    unwrap: string;
+    deleted: string;
+    discarded: string;
+    running: string;
+    stopped: string;
+    slotLabels: Record<string, string>;
+    wrapRefusals: Record<string, string>;
+};
+export declare const blockPosition: (label: string, position: number) => string;
+export declare const blockTestName: (title: string, label: string) => string;
+export declare const blockDraftStatus: (name: string) => string;
+export declare const blockDecidedStatus: (winner: string, rollout: boolean) => string;
+export declare const blockFinishedStatus: (winner: string) => string;
+export declare const blockSaveNotice: (drafts: boolean) => "Save a draft of this page to add the test." | "Save this page to add the test.";
+export declare const blockSyncNotice: (drafts: boolean) => "Versions were updated to match the test. Save draft to keep them." | "Versions were updated to match the test. Save to keep them.";

package/dist/admin/copy/blocks.js

@@ -0,0 +1,38 @@
+export const BLOCK_COPY = {
+    testBlock: 'Test a block on this page',
+    pick: 'Choose a block',
+    empty: 'There are no blocks on this page to test yet. Add one, save, then come back.',
+    blockChanged: 'This block changed while you were working. Nothing was replaced. Try again.',
+    replace: 'Replace',
+    cancel: 'Cancel',
+    retry: 'Try again',
+    saveFirst: 'Save your changes, then try again.',
+    setup: 'Set up the test',
+    copy: 'Copy the Original into this version',
+    confirmCopy: 'Replace this version’s content with a copy of the Original? Edits you made to this version will be lost.',
+    unwrap: 'Unwrap',
+    deleted: "This block's test was deleted; the page shows the Original.",
+    discarded: 'This test has ended; the page shows the Original.',
+    running: "Running: visitors see different versions. Edit a version's tab to change it; the change is noted on the results.",
+    stopped: 'Stopped: visitors see the Original.',
+    slotLabels: {
+        control: 'Original',
+        variantA: 'Variant A',
+        variantB: 'Variant B',
+        variantC: 'Variant C'
+    },
+    wrapRefusals: {
+        'wrap-target-missing': 'Reload the page and try again.',
+        'locked-placement': 'Another editor has this page open. Try again when it is unlocked.',
+        'invalid-status': 'This action is not available in the current status.',
+        'unknown-collection': "That page type isn't set up for tests.",
+        'invalid-body': 'Choose a block test.'
+    }
+};
+export const blockPosition = (label, position)=>`${label} (block ${position})`;
+export const blockTestName = (title, label)=>`${title}: ${label}`;
+export const blockDraftStatus = (name)=>`This block is being tested in the draft test ${name}. Visitors see the Original until it starts.`;
+export const blockDecidedStatus = (winner, rollout)=>`Decided: visitors see ${winner}${rollout ? '; a holdout still sees the Original' : ''}.`;
+export const blockFinishedStatus = (winner)=>`Finished: visitors see ${winner}. Use "Make it the content" on the test to replace this block.`;
+export const blockSaveNotice = (drafts)=>drafts ? 'Save a draft of this page to add the test.' : 'Save this page to add the test.';
+export const blockSyncNotice = (drafts)=>drafts ? 'Versions were updated to match the test. Save draft to keep them.' : 'Versions were updated to match the test. Save to keep them.';

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

@@ -1,4 +1,6 @@
 export declare const GOALS_COPY: {
+    readonly slugRule: "Use 1–64 lowercase letters, numbers, underscores or hyphens, starting with a letter or number.";
+    readonly duplicateSlug: "Another goal already uses this short name. Change it under Advanced.";
     readonly title: "Goals";
     readonly goal: "Goal";
     readonly newGoal: "New goal";

package/dist/admin/copy/goals.js

@@ -1,4 +1,7 @@
+import { CLICK_GOAL_COPY } from '../../goals/picker/copy.js';
 export const GOALS_COPY = {
+    slugRule: CLICK_GOAL_COPY.slugRule,
+    duplicateSlug: CLICK_GOAL_COPY.duplicateSlug,
     title: 'Goals',
     goal: 'Goal',
     newGoal: 'New goal',
@@ -38,7 +41,7 @@ export const GOALS_COPY = {
     remove: 'Delete goal',
     thresholdError: 'Enter a percentage of zero or more, or leave blank for 5%.',
     deleting: 'Deleting…',
-    saveError: "Couldn't save the goal. Try again.",
+    saveError: CLICK_GOAL_COPY.saveError,
     deleteError: "Couldn't delete the goal. Try again.",
     breadcrumb: 'Breadcrumb',
     missing: 'This goal no longer exists.',

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

@@ -2,6 +2,16 @@ export declare const NEW_TEST_COPY: {
     readonly question: "What do you want to test?";
     readonly block: "A block on a page";
     readonly setting: "A setting";
+    readonly page: "A whole page";
+    readonly pageMeaning: "Show different versions of a whole page at the same address, and see which one works better.";
+    readonly collection: "Collection";
+    readonly original: "Original";
+    readonly originalHelp: "Choose the page visitors see today.";
+    readonly review: "Review";
+    readonly backToTest: "Back to the test";
+    readonly finishSetup: "Finish setup";
+    readonly start: "Start";
+    readonly blocksHandoff: "Pick the block to test with 'Test a block on this page'.";
     readonly blockMeaning: "Compare different versions of content on a page.";
     readonly settingMeaning: "Compare different choices for a setting on your site.";
     readonly unavailable: "A developer needs to set up pages or settings before you can create a test.";

package/dist/admin/copy/newTest.js

@@ -2,6 +2,16 @@ export const NEW_TEST_COPY = {
     question: 'What do you want to test?',
     block: 'A block on a page',
     setting: 'A setting',
+    page: 'A whole page',
+    pageMeaning: 'Show different versions of a whole page at the same address, and see which one works better.',
+    collection: 'Collection',
+    original: 'Original',
+    originalHelp: 'Choose the page visitors see today.',
+    review: 'Review',
+    backToTest: 'Back to the test',
+    finishSetup: 'Finish setup',
+    start: 'Start',
+    blocksHandoff: "Pick the block to test with 'Test a block on this page'.",
     blockMeaning: 'Compare different versions of content on a page.',
     settingMeaning: 'Compare different choices for a setting on your site.',
     unavailable: 'A developer needs to set up pages or settings before you can create a test.',

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

@@ -0,0 +1,26 @@
+export declare const PAGE_COPY: {
+    readonly search: "Search pages by title";
+    readonly more: "More";
+    readonly loading: "Loading pages…";
+    readonly empty: "There are no pages here yet.";
+    readonly error: "Couldn't load pages. Try again.";
+    readonly retry: "Try again";
+    readonly draft: "Draft";
+    readonly noPath: "This page has no address yet.";
+    readonly choose: "Choose a page";
+    readonly change: "Change";
+    readonly close: "Close";
+    readonly where: "Where it shows";
+    readonly open: "Open";
+    readonly preview: "Preview";
+    readonly contentChecksOff: "Content checks are off for this page type.";
+    readonly duplicateStep: "Choose Duplicate from the document's actions. Keep the Original's title on the copy, unless the title is what you're testing.";
+    readonly ownAddress: "Give the copy its own address and save it as a draft. Publish it when it's ready; the test can't start until it is.";
+    readonly thenChoose: "Then choose the page you made.";
+    readonly noPage: "No page chosen yet.";
+};
+export declare const usedPageCopy: (label: string) => string;
+export declare const usedAddressCopy: (label: string, path: string, collection: string) => string;
+export declare const openOriginalCopy: (collection: string) => string;
+export declare const openCollectionCopy: (collection: string) => string;
+export declare const pageStepCopy: (label: string) => string;