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

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

@@ -0,0 +1,34 @@
+import type { Arm } from '../../types/contracts.js';
+import type { ArmSlot } from '../../types/puck.js';
+import type { EditorExperiment } from './editor.model.js';
+export declare function useArmWrites(url: string, publish: (doc: EditorExperiment) => void, isCurrent: () => boolean, onWrite: () => void): {
+    write: (transform: (arms: Arm[]) => Arm[]) => Promise<Arm[] | undefined>;
+    busy: boolean;
+    error: string | null;
+};
+export type ArmWrites = ReturnType<typeof useArmWrites>;
+export declare function AddVariant({ experiment, writes, onSelect }: {
+    experiment: EditorExperiment;
+    writes: ArmWrites;
+    onSelect: (slot: ArmSlot) => void;
+}): import("react").JSX.Element | null;
+export declare function VersionActions({ arm, writes, editable, open, onOpenChange, canCopy, onCopy, onRequestRemove }: {
+    arm: EditorExperiment['arms'][number];
+    writes: ArmWrites;
+    editable: boolean;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    canCopy: boolean;
+    onCopy: (slot: ArmSlot) => void;
+    onRequestRemove: () => void;
+}): import("react").JSX.Element;
+export declare function RemoveVersion({ arm, writes, onRemove, onClose }: {
+    arm: EditorExperiment['arms'][number];
+    writes: ArmWrites;
+    onRemove: (slot: ArmSlot) => void;
+    onClose: () => void;
+}): import("react").JSX.Element;
+export declare function VersionWeights({ experiment, writes }: {
+    experiment: EditorExperiment;
+    writes: ArmWrites;
+}): import("react").JSX.Element;

package/dist/puck/editor/VersionBuilder.js

@@ -0,0 +1,317 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from 'react';
+import { addVariant, removeArm, balanceWeight, splitEvenly, totalWeight, withSlotsFor } from '../../arms/model.js';
+import { checkArms } from '../../collections/experiments/armInvariants.js';
+import { issueMessage } from '../../arms/copy.js';
+import { Button } from '../../ui/Button.js';
+import { Dialog } from '../../ui/Dialog.js';
+import { NumberInput, TextInput } from '../../ui/Inputs.js';
+import { ArmWriteError, writeArms } from './armWrites.js';
+import { editorCopy as C } from './copy.js';
+export function useArmWrites(url, publish, isCurrent, onWrite) {
+    const guard = useRef(false);
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    async function write(transform) {
+        if (guard.current) return;
+        guard.current = true;
+        onWrite();
+        setBusy(true);
+        setError(null);
+        try {
+            return await writeArms(url, transform, publish);
+        } catch (error) {
+            if (isCurrent()) setError(error instanceof ArmWriteError ? error.message : C.writeNetwork);
+        } finally{
+            guard.current = false;
+            setBusy(false);
+        }
+    }
+    return {
+        write,
+        busy,
+        error
+    };
+}
+export function AddVariant({ experiment, writes, onSelect }) {
+    if (experiment.arms.filter((arm)=>arm.kind === 'variant').length >= 3) return null;
+    return /*#__PURE__*/ _jsx(Button, {
+        disabled: writes.busy,
+        onClick: async ()=>{
+            let added;
+            const saved = await writes.write((arms)=>{
+                const next = addVariant(arms, 'block');
+                added = next.find((arm)=>!arms.some((existing)=>existing.key === arm.key))?.key;
+                return next;
+            });
+            if (saved && added) onSelect(added);
+        },
+        children: C.add
+    });
+}
+export function VersionActions({ arm, writes, editable, open, onOpenChange, canCopy, onCopy, onRequestRemove }) {
+    const id = useId();
+    const [name, setName] = useState(null);
+    const [invalid, setInvalid] = useState(false);
+    const trigger = useRef(null);
+    const focusTrigger = ()=>trigger.current?.querySelector('button')?.focus();
+    const restoreFocus = useRef(false);
+    useEffect(()=>{
+        if (restoreFocus.current && !writes.busy) {
+            restoreFocus.current = false;
+            focusTrigger();
+        }
+    }, [
+        writes.busy,
+        name
+    ]);
+    useEffect(()=>{
+        if (!open) return;
+        const node = trigger.current;
+        const doc = node?.ownerDocument;
+        const outside = (event)=>{
+            if (node && !event.composedPath().includes(node)) onOpenChange(false);
+        };
+        // Focus leaving the canvas iframe (Puck's own panels) or the window fires window blur, not a document pointerdown.
+        const leave = ()=>onOpenChange(false);
+        const view = doc?.defaultView;
+        doc?.addEventListener('pointerdown', outside);
+        view?.addEventListener('blur', leave);
+        return ()=>{
+            doc?.removeEventListener('pointerdown', outside);
+            view?.removeEventListener('blur', leave);
+        };
+    }, [
+        open,
+        onOpenChange
+    ]);
+    const closeMenu = ()=>{
+        onOpenChange(false);
+        focusTrigger();
+    };
+    const slot = arm.key;
+    async function rename() {
+        if (!name?.trim()) {
+            setInvalid(true);
+            return;
+        }
+        const label = name.trim();
+        const saved = await writes.write((arms)=>arms.map((current)=>current.key === arm.key ? {
+                    ...current,
+                    label
+                } : current));
+        if (saved) {
+            restoreFocus.current = true;
+            setName(null);
+        }
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        ref: trigger,
+        className: "xp-slot-version-actions",
+        onBlur: (event)=>{
+            // Safari/Firefox may blur a keyboard-focused trigger without focusing the clicked item.
+            // Outside pointerdown handles real outside clicks, including non-focusable targets.
+            if (event.relatedTarget !== null && !event.currentTarget.contains(event.relatedTarget)) onOpenChange(false);
+        },
+        onKeyDown: (event)=>{
+            if (event.key === 'Escape' && !writes.busy) {
+                event.preventDefault();
+                closeMenu();
+                setName(null);
+            }
+        },
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "xp-slot-version-anchor",
+                children: [
+                    editable || arm.kind !== 'control' ? /*#__PURE__*/ _jsx(Button, {
+                        size: "sm",
+                        variant: "quiet",
+                        "aria-label": C.menu(arm.label),
+                        "aria-expanded": open,
+                        "aria-controls": `${id}-menu`,
+                        disabled: writes.busy,
+                        onClick: ()=>onOpenChange(!open),
+                        children: "⋯"
+                    }) : null,
+                    open ? /*#__PURE__*/ _jsxs("div", {
+                        id: `${id}-menu`,
+                        className: "xp-slot-version-menu",
+                        role: "group",
+                        tabIndex: -1,
+                        "aria-label": C.menu(arm.label),
+                        children: [
+                            editable ? /*#__PURE__*/ _jsx(Button, {
+                                variant: "quiet",
+                                size: "sm",
+                                onClick: ()=>{
+                                    setName(arm.label);
+                                    setInvalid(false);
+                                    closeMenu();
+                                },
+                                children: C.rename
+                            }) : null,
+                            arm.kind !== 'control' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(Button, {
+                                        variant: "quiet",
+                                        size: "sm",
+                                        disabled: !canCopy,
+                                        onClick: ()=>{
+                                            closeMenu();
+                                            onCopy(slot);
+                                        },
+                                        children: C.copy
+                                    }),
+                                    editable ? /*#__PURE__*/ _jsx(Button, {
+                                        variant: "quiet",
+                                        size: "sm",
+                                        onClick: ()=>{
+                                            closeMenu();
+                                            onRequestRemove();
+                                        },
+                                        children: C.remove
+                                    }) : null
+                                ]
+                            }) : null
+                        ]
+                    }) : null
+                ]
+            }),
+            name !== null ? /*#__PURE__*/ _jsx("div", {
+                className: "xp-slot-version-rename",
+                children: /*#__PURE__*/ _jsx(TextInput, {
+                    id: `${id}-name`,
+                    label: C.renameLabel,
+                    autoFocus: true,
+                    value: name,
+                    disabled: writes.busy,
+                    error: invalid ? C.emptyLabel : undefined,
+                    onChange: (event)=>{
+                        setName(event.target.value);
+                        setInvalid(false);
+                    },
+                    onKeyDown: (event)=>{
+                        if (event.key === 'Enter') {
+                            event.preventDefault();
+                            void rename();
+                        }
+                    }
+                })
+            }) : null
+        ]
+    });
+}
+export function RemoveVersion({ arm, writes, onRemove, onClose }) {
+    const slot = arm.key;
+    const [tried, setTried] = useState(false);
+    return /*#__PURE__*/ _jsx(Dialog, {
+        open: true,
+        title: C.removeTitle(arm.label),
+        initialFocus: "cancel",
+        dismissible: !writes.busy,
+        onClose: ()=>onClose(),
+        children: /*#__PURE__*/ _jsxs("div", {
+            className: "xp-slot-drawer",
+            children: [
+                /*#__PURE__*/ _jsx("p", {
+                    children: C.removeHelp
+                }),
+                tried && writes.error ? /*#__PURE__*/ _jsx("p", {
+                    role: "alert",
+                    className: "xp-ui-error",
+                    children: writes.error
+                }) : null,
+                /*#__PURE__*/ _jsxs("div", {
+                    className: "xp-ui-button-group",
+                    children: [
+                        /*#__PURE__*/ _jsx(Button, {
+                            "data-dialog-cancel": true,
+                            disabled: writes.busy,
+                            onClick: ()=>onClose(),
+                            children: C.cancel
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            variant: "danger",
+                            busy: writes.busy,
+                            onClick: async ()=>{
+                                setTried(true);
+                                const saved = await writes.write((arms)=>splitEvenly(removeArm(arms, arm.key)));
+                                if (saved) {
+                                    onRemove(slot);
+                                    onClose();
+                                }
+                            },
+                            children: C.remove
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+export function VersionWeights({ experiment, writes }) {
+    const id = useId();
+    const split = useRef(null);
+    const [edits, setEdits] = useState({});
+    const invalidKeys = new Set(Object.entries(edits).filter(([, raw])=>raw.trim() === '' || !Number.isInteger(Number(raw)) || Number(raw) < 0 || Number(raw) > 100).map(([key])=>key));
+    const apply = (arms)=>arms.reduce((next, arm)=>edits[arm.key] === undefined ? next : (()=>{
+                const value = edits[arm.key].trim() === '' ? NaN : Number(edits[arm.key]);
+                return invalidKeys.has(arm.key) ? next : balanceWeight(next, arm.key, value);
+            })(), arms);
+    const live = withSlotsFor(apply(experiment.arms), 'block');
+    const issues = checkArms(live, 'block');
+    async function commit() {
+        if (!Object.keys(edits).length || invalidKeys.size || issues.length) return;
+        const saved = await writes.write(apply);
+        if (saved) setEdits({});
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-slot-weights",
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: "xp-slot-weight-inputs",
+                children: experiment.arms.map((arm)=>/*#__PURE__*/ _jsx(NumberInput, {
+                        id: `${id}-${arm.key}`,
+                        label: C.weight(arm.label),
+                        min: 0,
+                        max: 100,
+                        step: 1,
+                        value: edits[arm.key] ?? live.find((current)=>current.key === arm.key)?.weight ?? '',
+                        disabled: writes.busy,
+                        error: invalidKeys.has(arm.key) ? C.invalidShare : undefined,
+                        onChange: (event)=>setEdits({
+                                [arm.key]: event.target.value
+                            }),
+                        onBlur: (event)=>{
+                            if (!split.current?.contains(event.relatedTarget)) void commit();
+                        },
+                        onKeyDown: (event)=>{
+                            if (event.key === 'Enter') {
+                                event.preventDefault();
+                                void commit();
+                            }
+                        }
+                    }, arm.key))
+            }),
+            Object.keys(edits).length && !invalidKeys.size ? issues.map((issue, i)=>/*#__PURE__*/ _jsx("p", {
+                    role: "alert",
+                    className: "xp-ui-error",
+                    children: issueMessage(issue, totalWeight(live))
+                }, i)) : null,
+            /*#__PURE__*/ _jsx("div", {
+                ref: split,
+                children: /*#__PURE__*/ _jsx(Button, {
+                    variant: "quiet",
+                    size: "sm",
+                    disabled: writes.busy,
+                    onClick: async ()=>{
+                        if (await writes.write(splitEvenly)) setEdits({});
+                    },
+                    children: C.split
+                })
+            })
+        ]
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { Arm } from '../../types/contracts.js';
+import type { EditorExperiment } from './editor.model.js';
+export declare class ArmWriteError extends Error {
+}
+export declare function readExperiment(url: string, signal?: AbortSignal): Promise<EditorExperiment>;
+/** Each intent is applied to a fresh document, guarded by the collection's compare-and-set header. */
+export declare function writeArms(url: string, transform: (arms: Arm[]) => Arm[], publish: (doc: EditorExperiment) => void): Promise<Arm[]>;

package/dist/puck/editor/armWrites.js

@@ -0,0 +1,71 @@
+import { checkArms } from '../../collections/experiments/armInvariants.js';
+import { issueMessage } from '../../arms/copy.js';
+import { totalWeight, withSlotsFor } from '../../arms/model.js';
+import { XP_IF_UPDATED_AT_HEADER } from '../../constants.js';
+import { editorCopy, writeRefusal } from './copy.js';
+export class ArmWriteError extends Error {
+}
+export async function readExperiment(url, signal) {
+    const response = await fetch(url, {
+        credentials: 'include',
+        cache: 'no-store',
+        ...signal ? {
+            signal
+        } : {}
+    });
+    if (!response.ok) throw new ArmWriteError(writeRefusal(undefined, response.status));
+    const doc = await response.json().catch(()=>undefined);
+    if (!doc || typeof doc !== 'object') throw new ArmWriteError(editorCopy.writeUnreadable);
+    const value = doc;
+    if (typeof value.name !== 'string' || typeof value.status !== 'string' || typeof value.updatedAt !== 'string' || !value.updatedAt || !Array.isArray(value.arms) || !value.arms.length || value.arms.some((arm)=>!arm || typeof arm !== 'object' || !Object.hasOwn(editorCopy.labels, arm.key) && arm.key !== 'holdout' || ![
+            'control',
+            'variant',
+            'holdout'
+        ].includes(arm.kind) || typeof arm.label !== 'string' || typeof arm.weight !== 'number' || !Number.isFinite(arm.weight))) throw new ArmWriteError(editorCopy.writeUnreadable);
+    if (![
+        'draft',
+        'stopped',
+        'running',
+        'decided',
+        'archived'
+    ].includes(value.status)) throw new ArmWriteError(editorCopy.lockedGeneric);
+    return value;
+}
+/** Each intent is applied to a fresh document, guarded by the collection's compare-and-set header. */ export async function writeArms(url, transform, publish) {
+    const fresh = await readExperiment(`${url}?depth=0`);
+    publish(fresh);
+    if (fresh.status !== 'draft' && fresh.status !== 'stopped') throw new ArmWriteError(editorCopy.locked[fresh.status]);
+    if (!fresh.updatedAt || !Array.isArray(fresh.arms)) throw new ArmWriteError(editorCopy.writeUnreadable);
+    const arms = withSlotsFor(transform(fresh.arms), 'block');
+    const issue = checkArms(arms, 'block')[0];
+    if (issue) throw new ArmWriteError(issueMessage(issue, totalWeight(arms)));
+    if (arms.some((arm)=>!arm.label.trim())) throw new ArmWriteError(editorCopy.emptyLabel);
+    const response = await fetch(url, {
+        method: 'PATCH',
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+            [XP_IF_UPDATED_AT_HEADER]: fresh.updatedAt
+        },
+        body: JSON.stringify({
+            arms
+        })
+    });
+    const body = await response.json().catch(()=>undefined);
+    if (!response.ok) {
+        const codes = Array.isArray(body?.errors) ? body.errors : [];
+        const stale = response.status === 409 && codes.some((error)=>error?.code === 'stale-edit');
+        if (stale) {
+            try {
+                publish(await readExperiment(`${url}?depth=0`));
+            } catch  {}
+        }
+        throw new ArmWriteError(stale ? editorCopy.staleEdit : writeRefusal(codes[0]?.code, response.status));
+    }
+    // A successful PATCH is applied even when its response body is unavailable.
+    publish(body?.doc ?? {
+        ...fresh,
+        arms
+    });
+    return arms;
+}

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

@@ -0,0 +1,14 @@
+import type { DocId } from '../../types/contracts.js';
+import type { EditorExperiment } from './editor.model.js';
+type Arms = {
+    arms: string[];
+};
+/** Only the first mounted block discards a document left by an earlier editor. */
+export declare function acquireArms(testId: DocId): () => void;
+/** Share the request, but abort it only after its last mounted consumer leaves. */
+export declare function loadArms(testId: DocId, load: (signal: AbortSignal) => Promise<EditorExperiment>, signal: AbortSignal): Promise<EditorExperiment>;
+export declare function subscribe(listener: () => void): () => void;
+/** The editor's document fetch is the only producer; undefined means unknown. */
+export declare function setArms(testId: DocId, arms: string[] | undefined): void;
+export declare function useArms(testId: DocId | undefined): Arms | undefined;
+export {};

package/dist/puck/editor/armsCache.js

@@ -0,0 +1,78 @@
+'use client';
+import { useSyncExternalStore } from 'react';
+const cache = new Map();
+const listeners = new Set();
+const pending = new Map();
+const mounted = new Map();
+/** Only the first mounted block discards a document left by an earlier editor. */ export function acquireArms(testId) {
+    const key = String(testId);
+    const count = mounted.get(key) ?? 0;
+    mounted.set(key, count + 1);
+    if (count === 0 && !pending.has(key)) setArms(testId, undefined);
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        const count = (mounted.get(key) ?? 1) - 1;
+        if (count === 0) mounted.delete(key);
+        else mounted.set(key, count);
+    };
+}
+/** Share the request, but abort it only after its last mounted consumer leaves. */ export function loadArms(testId, load, signal) {
+    const key = String(testId);
+    let request = pending.get(key);
+    if (!request) {
+        const controller = new AbortController();
+        request = {
+            controller,
+            consumers: [],
+            promise: undefined
+        };
+        const entry = request;
+        entry.promise = load(controller.signal).then((doc)=>{
+            if (!controller.signal.aborted) setArms(testId, doc.arms.map((arm)=>arm.key));
+            return doc;
+        }, (error)=>{
+            if (!controller.signal.aborted) setArms(testId, undefined);
+            throw error;
+        }).finally(()=>{
+            if (pending.get(key) === entry) pending.delete(key);
+        });
+        pending.set(key, entry);
+    }
+    const entry = request;
+    if (!entry.consumers.includes(signal)) entry.consumers.push(signal);
+    const release = ()=>{
+        entry.consumers = entry.consumers.filter((consumer)=>consumer !== signal);
+        if (!entry.consumers.length) {
+            entry.controller.abort();
+            if (pending.get(key) === entry) pending.delete(key);
+        }
+    };
+    signal.addEventListener('abort', release, {
+        once: true
+    });
+    return entry.promise.finally(()=>{
+        signal.removeEventListener('abort', release);
+        entry.consumers = entry.consumers.filter((consumer)=>consumer !== signal);
+    });
+}
+export function subscribe(listener) {
+    listeners.add(listener);
+    return ()=>{
+        listeners.delete(listener);
+    };
+}
+/** The editor's document fetch is the only producer; undefined means unknown. */ export function setArms(testId, arms) {
+    if (arms) cache.set(String(testId), {
+        arms: [
+            ...arms
+        ]
+    });
+    else cache.delete(String(testId));
+    for (const listener of listeners)listener();
+}
+const unknown = ()=>undefined;
+export function useArms(testId) {
+    return useSyncExternalStore(subscribe, ()=>testId === undefined ? undefined : cache.get(String(testId)), unknown);
+}

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

@@ -4,13 +4,15 @@ export declare const editorCopy: {
         readonly variantA: "Variant A";
         readonly variantB: "Variant B";
         readonly variantC: "Variant C";
+        readonly holdout: "Holdout";
     };
+    readonly notSetUp: "Not set up";
     readonly unbound: "Choose or create a test to show different versions.";
     readonly draft: "This block shows the Original to everyone until the test starts.";
     readonly running: "Changing this content mid-test mixes two versions in one result";
     readonly decided: (winner: string) => string;
     readonly archived: "This test is archived; the winning content is shown to everyone.";
-    readonly copy: "Copy Original to this version";
+    readonly copy: "Copy Original here";
     readonly dropZone: (slot: "control" | "variantA" | "variantB" | "variantC") => string;
     readonly replaceConfirm: (label: string) => string;
     readonly replace: "Replace";
@@ -24,5 +26,35 @@ export declare const editorCopy: {
     readonly createError: "Couldn't create the test. Try again.";
     readonly loading: "Loading test…";
     readonly loadError: "Couldn't load this test. Try selecting it again.";
+    readonly orphan: (label: string) => string;
     readonly tabs: "Test versions";
+    readonly add: "Add variant";
+    readonly menu: (label: string) => string;
+    readonly rename: "Rename";
+    readonly renameLabel: "Version name";
+    readonly emptyLabel: "Enter a name for this version.";
+    readonly remove: "Remove";
+    readonly removeTitle: (label: string) => string;
+    readonly removeHelp: "This removes the version from the test and clears its content from this page.";
+    readonly removed: "Save the page to finish removing this version's content.";
+    readonly removeUncleared: "The version was removed from the test, but its content couldn't be cleared here. Delete it from the outline, then save the page.";
+    readonly lockedGeneric: "This test's versions can't change. View the test page for details.";
+    readonly holdoutPeople: (label: string, count: string) => string;
+    readonly weight: (label: string) => string;
+    readonly invalidShare: "Use a whole number from 0 to 100.";
+    readonly split: "Split evenly";
+    readonly locked: {
+        readonly running: "This test is running, so its versions can't change. Stop it on the test page to edit them.";
+        readonly decided: "This test has a decision, so its versions can't change. View the results on the test page.";
+        readonly archived: "This test is archived, so its versions can't change. View the results on the test page.";
+    };
+    readonly staleEdit: "Someone else changed this test. Reload to see their changes.";
+    readonly writeError: "Couldn't complete this change. Try again.";
+    readonly writeNetwork: "Couldn't reach the server. Check your connection and try again.";
+    readonly writeUnreadable: "Couldn't read the server's response. Reload and try again.";
+    readonly collecting: "Collecting";
+    readonly resultsUnavailable: "Results aren't available here.";
+    readonly refresh: "Refresh";
+    readonly people: (label: string, count: string) => string;
 };
+export declare function writeRefusal(code: string | undefined, status: number): string;

package/dist/puck/editor/copy.js

@@ -1,16 +1,13 @@
+import { ARM_LABELS } from '../../labels/arms.js';
 export const editorCopy = {
-    labels: {
-        control: 'Original',
-        variantA: 'Variant A',
-        variantB: 'Variant B',
-        variantC: 'Variant C'
-    },
+    labels: ARM_LABELS,
+    notSetUp: 'Not set up',
     unbound: 'Choose or create a test to show different versions.',
     draft: 'This block shows the Original to everyone until the test starts.',
     running: 'Changing this content mid-test mixes two versions in one result',
     decided: (winner)=>`Decided: ${winner}. Use 'Make it the content' on the test to finish.`,
     archived: 'This test is archived; the winning content is shown to everyone.',
-    copy: 'Copy Original to this version',
+    copy: 'Copy Original here',
     dropZone: (slot)=>slot === 'control' ? 'Drop the original content here' : `Drop ${editorCopy.labels[slot]} content here`,
     replaceConfirm: (label)=>`${label} already has content. Replace it with a copy of the Original?`,
     replace: 'Replace',
@@ -24,5 +21,45 @@ export const editorCopy = {
     createError: "Couldn't create the test. Try again.",
     loading: 'Loading test…',
     loadError: "Couldn't load this test. Try selecting it again.",
-    tabs: 'Test versions'
+    orphan: (label)=>`${label} has content but isn't part of this test. Move or delete it; visitors never see it.`,
+    tabs: 'Test versions',
+    add: 'Add variant',
+    menu: (label)=>`Options for ${label}`,
+    rename: 'Rename',
+    renameLabel: 'Version name',
+    emptyLabel: 'Enter a name for this version.',
+    remove: 'Remove',
+    removeTitle: (label)=>`Remove ${label}?`,
+    removeHelp: 'This removes the version from the test and clears its content from this page.',
+    removed: "Save the page to finish removing this version's content.",
+    removeUncleared: "The version was removed from the test, but its content couldn't be cleared here. Delete it from the outline, then save the page.",
+    lockedGeneric: "This test's versions can't change. View the test page for details.",
+    holdoutPeople: (label, count)=>`${label}: ${count} people (not compared)`,
+    weight: (label)=>`${label} traffic (%)`,
+    invalidShare: 'Use a whole number from 0 to 100.',
+    split: 'Split evenly',
+    locked: {
+        running: "This test is running, so its versions can't change. Stop it on the test page to edit them.",
+        decided: "This test has a decision, so its versions can't change. View the results on the test page.",
+        archived: "This test is archived, so its versions can't change. View the results on the test page."
+    },
+    staleEdit: 'Someone else changed this test. Reload to see their changes.',
+    writeError: "Couldn't complete this change. Try again.",
+    writeNetwork: "Couldn't reach the server. Check your connection and try again.",
+    writeUnreadable: "Couldn't read the server's response. Reload and try again.",
+    collecting: 'Collecting',
+    resultsUnavailable: "Results aren't available here.",
+    refresh: 'Refresh',
+    people: (label, count)=>`${label}: ${count} people`
 };
+// Minimal editor-side equivalent of admin/copy/common.ts: the editor graph cannot import admin.
+// Never accept server text as a fallback.
+export function writeRefusal(code, status) {
+    if (code === 'stale-edit') return editorCopy.staleEdit;
+    if (code === 'unauthenticated' || status === 401) return 'Your session has expired. Sign in again.';
+    if (code === 'not-found' || status === 404) return 'This test no longer exists.';
+    if (code === 'commit-unverified') return 'The change may not have been saved. Reload and try again.';
+    if (code === 'not-implemented' || status === 501) return "This isn't available yet.";
+    if (code === 'forbidden' || status === 403) return "You don't have permission to do this.";
+    return editorCopy.writeError;
+}

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

@@ -4,4 +4,4 @@ import { newTestBody } from './editor.model.js';
 export declare class CreateRefused extends Error {
 }
 /** Shared lookup, complete draft creation and one retry for a racing slug collision. */
-export declare function createTest(apiRoute: string, input: Omit<Parameters<typeof newTestBody>[0], 'slug'>): Promise<ExperimentRef>;
+export declare function createTest(api: string, input: Omit<Parameters<typeof newTestBody>[0], 'slug'>): Promise<ExperimentRef>;