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

package/dist/hooks/pageGuard.js

@@ -0,0 +1,139 @@
+import { previousPublishedContent } from '../db/appends.js';
+import { lockPagePaths } from '../db/locks.js';
+import { txExecutor } from '../db/executor.js';
+import { normalisePath } from '../runtime/normalisePath.js';
+import { XpNoTransactionError, XpRefusal } from '../errors.js';
+import { pageGuardCopy, READINESS_COPY } from '../admin/copy/readiness.js';
+// createLocalReq replaces context with a shallow copy on nested calls. Keep
+// the shared stack in that context so both the outer req and its proxies see it.
+const operations = (req)=>req.context.xpPageGuardOperations;
+export const pageGuardBeforeOperation = ({ args, operation })=>{
+    if (operation !== 'update' && operation !== 'restoreVersion') return;
+    const call = args;
+    let collections = operations(call.req);
+    if (!collections) call.req.context.xpPageGuardOperations = collections = new Map();
+    const slug = call.collection.config.slug;
+    const stack = collections.get(slug) ?? [];
+    stack.push({
+        draft: call.draft === true,
+        restore: operation === 'restoreVersion'
+    });
+    collections.set(slug, stack);
+};
+export const pageGuardAfterOperation = ({ req, collection, operation, result })=>{
+    // beforeOperation reports by-id updates as 'update'; afterOperation reports 'updateByID'.
+    if (operation === 'update' || operation === 'updateByID' || operation === 'restoreVersion') {
+        const collections = operations(req);
+        const stack = collections?.get(collection.slug);
+        stack?.pop();
+        if (!stack?.length) collections?.delete(collection.slug);
+    }
+    return result;
+};
+async function protect(req, path) {
+    // Serialise with Start (CORE-52 path locks, taken there after the experiment lock): a concurrent Start
+    // either commits first, so this check sees it, or waits and then sees this change. Raw SQL on the
+    // host's transaction; without one there is nothing to hold the lock for.
+    if (await req.transactionID != null) {
+        try {
+            await lockPagePaths(txExecutor(req), [
+                normalisePath(path)
+            ]);
+        } catch (error) {
+            // A request id without a database session (e.g. a transaction already killed) has no lock to take.
+            if (!(error instanceof XpNoTransactionError)) throw error;
+        }
+    }
+    // page guard: the hook must see test placements regardless of the editor's access
+    const tests = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: true,
+        depth: 0,
+        limit: 0,
+        where: {
+            and: [
+                {
+                    kind: {
+                        equals: 'page'
+                    }
+                },
+                {
+                    status: {
+                        in: [
+                            'running',
+                            'decided',
+                            'archived'
+                        ]
+                    }
+                }
+            ]
+        }
+    });
+    for (const test of tests.docs){
+        const decision = test.decision;
+        const archived = test.status === 'archived';
+        if (archived && (!decision?.winnerArm || decision.discardedAt || decision.pagesReleasedAt)) continue;
+        // page guard: the hook must see test placements regardless of the editor's access
+        const phases = await req.payload.find({
+            collection: 'xp-phases',
+            req,
+            overrideAccess: true,
+            depth: 0,
+            limit: 1,
+            sort: '-phase',
+            where: {
+                experiment: {
+                    equals: test.id
+                },
+                phaseKind: {
+                    equals: 'test'
+                }
+            }
+        });
+        const phase = phases.docs[0];
+        if (!phase) throw new XpRefusal('invalid-phase', READINESS_COPY.missingVersions, {
+            experimentId: test.id
+        }, 409);
+        const arms = phase.arms;
+        const protectedArms = archived ? arms.filter((arm)=>arm.kind === 'control' || arm.key === decision.winnerArm) : arms;
+        const matched = protectedArms.find((arm)=>arm.pageTarget !== undefined && normalisePath(arm.pageTarget) === normalisePath(path));
+        if (matched) {
+            const role = archived && matched.key !== decision.winnerArm ? 'original' : 'winner';
+            throw new XpRefusal('locked-placement', pageGuardCopy(String(test.name), test.status, role), {
+                experimentId: test.id
+            }, 409);
+        }
+    }
+}
+function registration(req, slug) {
+    return (req.payload.config.custom?.xp).pages?.collections.find((entry)=>entry.slug === slug);
+}
+export const pageGuardBeforeDelete = async ({ req, id, collection })=>{
+    const page = registration(req, collection.slug);
+    if (!page) return;
+    const published = await previousPublishedContent(req, collection.slug, id);
+    if (!published || published._status === 'draft') return;
+    const path = page.pathOf(published);
+    if (path !== null) await protect(req, path);
+};
+export const pageGuardBeforeChange = async ({ req, collection, originalDoc, operation, data })=>{
+    if (operation !== 'update') return data;
+    const page = registration(req, collection.slug);
+    if (!page) return data;
+    const drafts = Boolean(collection.versions && collection.versions.drafts);
+    // updateDocument computes isSavingDraft from draftArg and _status before
+    // beforeChange, and writes the main row only when !isSavingDraft.
+    const call = operations(req)?.get(collection.slug)?.at(-1);
+    if (drafts && call?.draft && (call.restore || data._status !== 'published')) return data;
+    const published = await previousPublishedContent(req, collection.slug, originalDoc.id);
+    if (!published || published._status === 'draft') return data;
+    const path = page.pathOf(published);
+    const unpublishing = drafts && data._status === 'draft';
+    const trashing = collection.trash && data.deletedAt != null && !originalDoc.deletedAt;
+    if (path !== null && (trashing || unpublishing || page.pathOf({
+        ...originalDoc,
+        ...data
+    }) !== path)) await protect(req, path);
+    return data;
+};

package/dist/lib/fetchAllDocs.d.ts

@@ -0,0 +1,16 @@
+export type DocsResult<T> = {
+    ok: true;
+    docs: T[];
+} | {
+    ok: false;
+    status: number;
+    body: unknown;
+    reason?: 'page-limit-exceeded';
+};
+/** A successful REST response did not contain a readable document list. */
+export declare class DocsResponseError extends Error {
+}
+/** Read every Payload REST page with the caller's credentials and cancellation. Transport,
+ * invalid successful responses and aborts throw; HTTP refusals retain their status/body. Keeps the first document per id; refuses
+ * incomplete lists after 1000 pages with page-limit-exceeded. */
+export declare function fetchAllDocs<T>(url: string, options?: Pick<RequestInit, 'credentials' | 'signal'>): Promise<DocsResult<T>>;

package/dist/lib/fetchAllDocs.js

@@ -0,0 +1,56 @@
+/** A successful REST response did not contain a readable document list. */ export class DocsResponseError extends Error {
+}
+/** Read every Payload REST page with the caller's credentials and cancellation. Transport,
+ * invalid successful responses and aborts throw; HTTP refusals retain their status/body. Keeps the first document per id; refuses
+ * incomplete lists after 1000 pages with page-limit-exceeded. */ export async function fetchAllDocs(url, options = {}) {
+    const [path, query] = url.split('?');
+    const params = new URLSearchParams(query);
+    params.set('limit', '100');
+    const docs = [];
+    const seen = new Set();
+    for(let page = 1; page <= 1000; page++){
+        options.signal?.throwIfAborted();
+        params.set('page', String(page));
+        const response = await fetch(`${path}?${params}`, options);
+        const body = await response.json().catch(()=>{
+            if (response.ok) throw new DocsResponseError();
+            return undefined;
+        });
+        options.signal?.throwIfAborted();
+        if (!response.ok) return {
+            ok: false,
+            status: response.status,
+            body
+        };
+        const data = body;
+        if (!Array.isArray(data?.docs)) throw new DocsResponseError();
+        for (const doc of data.docs){
+            const id = doc && typeof doc === 'object' && 'id' in doc ? doc.id : undefined;
+            if (typeof id === 'string' || typeof id === 'number') {
+                if (seen.has(id)) continue;
+                seen.add(id);
+            }
+            docs.push(doc);
+        }
+        if (data.docs.length === 0) return {
+            ok: true,
+            docs
+        };
+        if (typeof data.totalPages === 'number' && page >= data.totalPages) return {
+            ok: true,
+            docs
+        };
+        if (data.hasNextPage === false || data.hasNextPage !== true && !(typeof data.totalPages === 'number' && page < data.totalPages)) {
+            return {
+                ok: true,
+                docs
+            };
+        }
+    }
+    return {
+        ok: false,
+        status: 0,
+        body: undefined,
+        reason: 'page-limit-exceeded'
+    };
+}

package/dist/log.js

@@ -1,4 +1,4 @@
-import { XpNoTransactionError, XpNotImplemented, XpRefusal } from './errors.js';
+import { ANALYSIS_ERROR_MESSAGES, XpAnalysisError, XpNoTransactionError, XpNotImplemented, XpRefusal } from './errors.js';
 import { ResultsBudgetError } from './db/pgExecutor.js';
 /** Deliberately construct a plain object: host serializers must never see the error. */ export function safeError(err) {
     try {
@@ -10,7 +10,8 @@ import { ResultsBudgetError } from './db/pgExecutor.js';
             name: typeof name === 'string' ? name : 'Error'
         };
         const code = 'code' in err ? err.code : undefined;
-        if (typeof code === 'string' && (/^[0-9A-Z]{5}$/.test(code) || err instanceof XpRefusal)) result.code = code;
+        const analysisCode = err instanceof XpAnalysisError && typeof code === 'string' && Object.hasOwn(ANALYSIS_ERROR_MESSAGES, code) ? code : undefined;
+        if (typeof code === 'string' && (/^[0-9A-Z]{5}$/.test(code) || err instanceof XpRefusal || analysisCode)) result.code = code;
         const message = err.message;
         const stack = err.stack;
         // Remove the entire V8 header first: message lines can impersonate frames.
@@ -22,7 +23,9 @@ import { ResultsBudgetError } from './db/pgExecutor.js';
         }
         // XpRefusal includes stored slugs; XpLockedFieldError includes request keys
         // and stored status. Neither class's message is safe to send to host logs.
-        if (err instanceof XpNoTransactionError || err instanceof XpNotImplemented || err instanceof ResultsBudgetError) {
+        // An analysis error's logged text always comes from the fixed table by code, never from err.message.
+        if (analysisCode) result.message = ANALYSIS_ERROR_MESSAGES[analysisCode];
+        else if (err instanceof XpNoTransactionError || err instanceof XpNotImplemented || err instanceof ResultsBudgetError) {
             if (typeof message === 'string') result.message = message;
         }
         return result;

package/dist/manifest/compile.d.ts

@@ -35,6 +35,7 @@ export interface ManifestInputExperiment {
         winnerArm?: string | null;
         discardedAt?: string | null;
         holdoutReleasedAt?: string | null;
+        pagesReleasedAt?: string | null;
     } | null;
     currentPhase: ManifestPhase | null;
     lastTestPhase?: ManifestPhase | null;
@@ -50,6 +51,10 @@ export declare function loadManifestInputs(req: PayloadRequest, { excludeIds, pr
     pruneFlagDefaultIds?: DocId[];
 }): Promise<ManifestInputs>;
 /** Pure compiler. Assignment config comes exclusively from the frozen phase. */
+/**
+ * Pure manifest builder (exported from `/rsc` for host tests). Pass the same `attributeKeys` as the plugin options,
+ * or legacy untyped targeting rules are dropped. Its input shape may change in a pre-1.0 minor.
+ */
 export declare function compileManifest(inputs: ManifestInputs, revision: number, { attributeKeys, onInvalid }?: ManifestCompileOptions): Manifest;
 /** Take the state lock before reading inputs. Under READ COMMITTED, a builder
  * waiting for another transition then sees that transition's committed changes,

package/dist/manifest/compile.js

@@ -107,7 +107,10 @@ export async function loadManifestInputs(req, { excludeIds = [], pruneFlagDefaul
     });
     inputs.flagDefaults = defaults;
 }
-/** Pure compiler. Assignment config comes exclusively from the frozen phase. */ export function compileManifest(inputs, revision, { attributeKeys, onInvalid } = {}) {
+/** Pure compiler. Assignment config comes exclusively from the frozen phase. */ /**
+ * Pure manifest builder (exported from `/rsc` for host tests). Pass the same `attributeKeys` as the plugin options,
+ * or legacy untyped targeting rules are dropped. Its input shape may change in a pre-1.0 minor.
+ */ export function compileManifest(inputs, revision, { attributeKeys, onInvalid } = {}) {
     const excluded = new Set(inputs.excludeIds?.map(String));
     const prunedDefaults = new Set(inputs.pruneFlagDefaultIds?.map(String));
     const manifest = {
@@ -126,6 +129,7 @@ export async function loadManifestInputs(req, { excludeIds = [], pruneFlagDefaul
         const { decision, currentPhase: phase } = experiment;
         if (experiment.status === 'archived') {
             if (!decision?.winnerArm || decision.discardedAt) continue;
+            if (experiment.kind === 'page' && decision.pagesReleasedAt) continue;
             const testPhase = experiment.lastTestPhase ?? (phase?.phaseKind === 'test' ? phase : null);
             if (!testPhase) throw new XpRefusal('invalid-status', `Missing last test phase for experiment ${experiment.slug}`, undefined, 409);
             const winner = testPhase.arms.find((arm)=>arm.key === decision.winnerArm);

package/dist/options.js

@@ -1,3 +1,4 @@
+import { validateAccent } from './ui/accent.js';
 import { DEFAULT_MAX_BODY_BYTES } from './constants.js';
 const normalisedCollections = new WeakMap();
 /** Resolve once per registration list; every consumer shares the same field defaults. */ export function puckCollections(options) {
@@ -54,6 +55,21 @@ export function resolveOptions(input) {
             }
         }
     }
+    if (input.pages !== undefined) {
+        if (!input.pages || !Array.isArray(input.pages.collections) || input.pages.collections.length === 0) throw new Error('Experiments pages.collections must be a non-empty array');
+        const slugs = new Set();
+        for (const entry of input.pages.collections){
+            if (!entry || typeof entry.slug !== 'string' || !entry.slug.trim() || slugs.has(entry.slug) || typeof entry.pathOf !== 'function' || typeof entry.findByPath !== 'function') {
+                throw new Error('Experiments pages.collections requires unique slugs, pathOf and findByPath functions');
+            }
+            slugs.add(entry.slug);
+        }
+    }
+    if (input.theme !== undefined) {
+        if (!input.theme || typeof input.theme !== 'object' || Array.isArray(input.theme)) throw new Error('Experiments theme must be an object');
+        for (const key of Object.keys(input.theme))if (key !== 'accent') throw new Error(`Unknown experiments theme option: ${key}`);
+        validateAccent(input.theme.accent);
+    }
     const ids = new Set();
     for (const point of input.flagPoints ?? []){
         if (typeof point.id !== 'string' || !point.id || ids.has(point.id)) throw new Error('Experiments flag point ids must be unique nonempty strings');

package/dist/plugin.js

@@ -1,6 +1,7 @@
 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 { createOnInit } from './onInit.js';
 import { puckCollections, resolveOptions } from './options.js';
 import * as paths from './admin/paths.js';
@@ -11,6 +12,9 @@ export function createExperimentsPlugin(input) {
         for (const { slug } of registrations){
             if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments puck collection: ${slug}`);
         }
+        for (const { slug } of options.pages?.collections ?? []){
+            if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments page 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);
@@ -26,6 +30,10 @@ export function createExperimentsPlugin(input) {
                     xpTestsSurface: {
                         path: paths.XP_TESTS_SURFACE,
                         type: 'component'
+                    },
+                    xpTestsNav: {
+                        path: paths.XP_TESTS_NAV_CLIENT,
+                        type: 'component'
                     }
                 },
                 components: {
@@ -50,15 +58,35 @@ export function createExperimentsPlugin(input) {
             collections: [
                 ...(config.collections ?? []).map((collection)=>{
                     const puck = options.puck?.enabled && registrations.some((entry)=>entry.slug === collection.slug);
-                    if (!puck) return collection;
+                    const page = options.pages?.collections.some((entry)=>entry.slug === collection.slug);
+                    if (!puck && !page) return collection;
                     return {
                         ...collection,
                         hooks: {
                             ...collection.hooks,
                             beforeChange: [
                                 ...collection.hooks?.beforeChange ?? [],
-                                contentChangesBeforeHook
+                                ...page ? [
+                                    pageGuardBeforeChange
+                                ] : [],
+                                ...puck ? [
+                                    contentChangesBeforeHook
+                                ] : []
                             ],
+                            ...page ? {
+                                beforeOperation: [
+                                    ...collection.hooks?.beforeOperation ?? [],
+                                    pageGuardBeforeOperation
+                                ],
+                                beforeDelete: [
+                                    ...collection.hooks?.beforeDelete ?? [],
+                                    pageGuardBeforeDelete
+                                ],
+                                afterOperation: [
+                                    pageGuardAfterOperation,
+                                    ...collection.hooks?.afterOperation ?? []
+                                ]
+                            } : {},
                             ...puck ? {
                                 afterChange: [
                                     ...collection.hooks?.afterChange ?? [],

package/dist/puck/ExperimentPicker.js

@@ -1,6 +1,8 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
+import { useEffect, useId, useState } from 'react';
+import { fetchAllDocs } from '../lib/fetchAllDocs.js';
+import { usePuckRoutes } from './hostContext.js';
 import { pickerCopy } from './copy.js';
 function isExperimentOption(value) {
     if (!value || typeof value !== 'object') return false;
@@ -8,14 +10,17 @@ function isExperimentOption(value) {
     return (typeof doc.id === 'string' || typeof doc.id === 'number') && typeof doc.slug === 'string' && typeof doc.name === 'string' && typeof doc.status === 'string' && Object.hasOwn(pickerCopy.statuses, doc.status);
 }
 export function ExperimentPicker({ value, onChange }) {
+    const { api } = usePuckRoutes();
+    const id = useId();
     const [experiments, setExperiments] = useState([]);
+    const [search, setSearch] = useState('');
     const [state, setState] = useState('loading');
     useEffect(()=>{
         let active = true;
         const controller = new AbortController();
         async function load() {
             try {
-                const response = await fetch('/api/xp-experiments?where[kind][equals]=block&depth=0&limit=100&sort=-updatedAt', {
+                const response = await fetchAllDocs(`${api}/xp-experiments?where[kind][equals]=block&depth=0&sort=id`, {
                     credentials: 'include',
                     signal: controller.signal
                 });
@@ -24,13 +29,7 @@ export function ExperimentPicker({ value, onChange }) {
                     setState(response.status === 403 ? 'forbidden' : 'error');
                     return;
                 }
-                const data = await response.json();
-                if (!active) return;
-                if (!data || typeof data !== 'object' || !('docs' in data) || !Array.isArray(data.docs)) {
-                    setState('error');
-                    return;
-                }
-                setExperiments(data.docs.filter(isExperimentOption));
+                setExperiments(response.docs.filter(isExperimentOption).sort((a, b)=>(Date.parse(b.updatedAt ?? '') || 0) - (Date.parse(a.updatedAt ?? '') || 0)));
                 setState('ready');
             } catch  {
                 if (active) setState('error');
@@ -41,12 +40,38 @@ export function ExperimentPicker({ value, onChange }) {
             active = false;
             controller.abort();
         };
-    }, []);
+    }, [
+        api
+    ]);
     const selected = value ? String(value.id) : '';
+    const query = search.trim().toLocaleLowerCase('en-US');
+    const visible = experiments.filter((doc)=>String(doc.id) === selected || doc.name.toLocaleLowerCase('en-US').includes(query) || doc.slug.toLocaleLowerCase('en-US').includes(query));
     return /*#__PURE__*/ _jsxs("div", {
+        className: "xp-ui-field",
         children: [
+            experiments.length > 8 ? /*#__PURE__*/ _jsxs("div", {
+                className: "xp-ui-field",
+                children: [
+                    /*#__PURE__*/ _jsx("label", {
+                        htmlFor: `${id}-search`,
+                        children: pickerCopy.search
+                    }),
+                    /*#__PURE__*/ _jsx("input", {
+                        id: `${id}-search`,
+                        type: "search",
+                        className: "xp-ui-input",
+                        value: search,
+                        onChange: (event)=>setSearch(event.currentTarget.value)
+                    })
+                ]
+            }) : null,
+            /*#__PURE__*/ _jsx("label", {
+                htmlFor: id,
+                children: pickerCopy.label
+            }),
             /*#__PURE__*/ _jsxs("select", {
-                "aria-label": pickerCopy.label,
+                id: id,
+                className: "xp-ui-input xp-ui-select",
                 value: selected,
                 disabled: state === 'loading',
                 onChange: (event)=>{
@@ -65,7 +90,7 @@ export function ExperimentPicker({ value, onChange }) {
                         value: selected,
                         children: value.slug
                     }) : null,
-                    experiments.map((doc)=>/*#__PURE__*/ _jsxs("option", {
+                    visible.map((doc)=>/*#__PURE__*/ _jsxs("option", {
                             value: String(doc.id),
                             children: [
                                 doc.name,
@@ -75,13 +100,19 @@ export function ExperimentPicker({ value, onChange }) {
                         }, doc.id))
                 ]
             }),
-            state === 'loading' ? /*#__PURE__*/ _jsx("p", {
+            state === 'loading' ? /*#__PURE__*/ _jsx("div", {
+                className: "xp-ui-banner",
                 role: "status",
-                children: pickerCopy.loading
+                children: /*#__PURE__*/ _jsx("p", {
+                    children: pickerCopy.loading
+                })
             }) : null,
-            state === 'error' || state === 'forbidden' ? /*#__PURE__*/ _jsx("p", {
+            state === 'error' || state === 'forbidden' ? /*#__PURE__*/ _jsx("div", {
+                className: "xp-ui-banner xp-ui-banner--error",
                 role: "alert",
-                children: pickerCopy[state]
+                children: /*#__PURE__*/ _jsx("p", {
+                    children: pickerCopy[state]
+                })
             }) : null
         ]
     });

package/dist/puck/ExperimentSlot.d.ts

@@ -1,3 +1,53 @@
 import type { ComponentConfig } from '@puckeditor/core';
 import type { ExperimentSlotProps } from '../types/puck.js';
-export declare const ExperimentSlot: ComponentConfig<ExperimentSlotProps>;
+import { type PuckRoutes } from './routes.js';
+export declare function createExperimentSlot({ routes: inputRoutes }?: {
+    routes?: PuckRoutes;
+}): ComponentConfig<ExperimentSlotProps>;
+export declare const ExperimentSlot: {
+    render: import("@puckeditor/core").PuckComponent<ExperimentSlotProps>;
+    label?: string;
+    defaultProps?: ExperimentSlotProps | undefined;
+    fields?: import("@puckeditor/core").Fields<ExperimentSlotProps, {}> | undefined;
+    renderFields?: ((props: {
+        fields: Partial<Record<keyof ExperimentSlotProps, import("react").ReactNode>>;
+    }) => import("react").ReactElement) | undefined;
+    permissions?: Partial<import("@puckeditor/core").Permissions>;
+    inline?: boolean;
+    resolveFields?: ((data: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type">, params: {
+        changed: Partial<Record<keyof ExperimentSlotProps, boolean> & {
+            id: string;
+        }>;
+        fields: import("@puckeditor/core").Fields<ExperimentSlotProps, {}>;
+        lastFields: import("@puckeditor/core").Fields<ExperimentSlotProps, {}>;
+        lastData: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type"> | null;
+        metadata: import("@puckeditor/core").ComponentMetadata;
+        appState: import("@puckeditor/core").AppState;
+        parent: import("@puckeditor/core").ComponentData | null;
+    }) => import("@puckeditor/core").Fields<ExperimentSlotProps, {}> | Promise<import("@puckeditor/core").Fields<ExperimentSlotProps, {}>>) | undefined;
+    resolveData?: ((data: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type">, params: {
+        changed: Partial<Record<keyof ExperimentSlotProps, boolean> & {
+            id: string;
+        }>;
+        lastData: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type"> | null;
+        metadata: import("@puckeditor/core").ComponentMetadata;
+        trigger: import("@puckeditor/core").ResolveDataTrigger;
+        parent: import("@puckeditor/core").ComponentData | null;
+        root: import("@puckeditor/core").RootData;
+    }) => (Omit<Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type">, "props"> & {
+        props?: Partial<ExperimentSlotProps> | undefined;
+    }) | Promise<Omit<Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type">, "props"> & {
+        props?: Partial<ExperimentSlotProps> | undefined;
+    }>) | undefined;
+    resolvePermissions?: ((data: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type">, params: {
+        changed: Partial<Record<keyof ExperimentSlotProps, boolean> & {
+            id: string;
+        }>;
+        lastPermissions: Partial<import("@puckeditor/core").Permissions>;
+        permissions: Partial<import("@puckeditor/core").Permissions>;
+        appState: import("@puckeditor/core").AppState;
+        lastData: Omit<import("@puckeditor/core").ComponentData<ExperimentSlotProps, string, Record<string, import("@puckeditor/core").DefaultComponentProps>>, "type"> | null;
+        parent: import("@puckeditor/core").ComponentData | null;
+    }) => Promise<Partial<import("@puckeditor/core").Permissions>> | Partial<import("@puckeditor/core").Permissions>) | undefined;
+    metadata?: import("@puckeditor/core").ComponentMetadata;
+} & import("@puckeditor/core").ComponentConfigExtensions;

package/dist/puck/ExperimentSlot.js

@@ -1,16 +1,27 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { ViewportExposure } from '../client/ViewportExposure.js';
 import { experimentSlotDefaultProps, experimentSlotFields, experimentSlotLabel } from './slotConfig.js';
+import { createExperimentSlotField } from './experimentSlotField.js';
+import { resolvePuckRoutes } from './routes.js';
 import { slotToRender } from './slot.model.js';
-export const ExperimentSlot = {
-    label: experimentSlotLabel,
-    fields: experimentSlotFields,
-    defaultProps: experimentSlotDefaultProps,
-    render: (props)=>{
-        const Slot = props[slotToRender(props)];
-        return /*#__PURE__*/ _jsx(ViewportExposure, {
-            expose: props.xpExpose,
-            children: /*#__PURE__*/ _jsx(Slot, {})
-        });
-    }
-};
+export function createExperimentSlot({ routes: inputRoutes } = {}) {
+    const routes = resolvePuckRoutes(inputRoutes);
+    return {
+        label: experimentSlotLabel,
+        fields: {
+            ...experimentSlotFields,
+            experiment: createExperimentSlotField({
+                routes
+            })
+        },
+        defaultProps: experimentSlotDefaultProps,
+        render: (props)=>{
+            const Slot = props[slotToRender(props)];
+            return /*#__PURE__*/ _jsx(ViewportExposure, {
+                expose: props.xpExpose,
+                children: /*#__PURE__*/ _jsx(Slot, {})
+            });
+        }
+    };
+}
+export const ExperimentSlot = createExperimentSlot();

package/dist/puck/copy.d.ts

@@ -5,11 +5,12 @@ export declare const slotLabels: {
     readonly variantC: "Variant C";
 };
 export declare const pickerCopy: {
-    readonly label: "Experiment";
-    readonly none: "No experiment";
-    readonly loading: "Loading experiments…";
-    readonly error: "Couldn't load experiments.";
-    readonly forbidden: "You can't see experiments. Ask an admin.";
+    readonly label: "Test";
+    readonly none: "No test";
+    readonly search: "Search tests";
+    readonly loading: "Loading tests…";
+    readonly error: "Couldn't load tests.";
+    readonly forbidden: "You can't see tests. Ask an admin.";
     readonly statuses: {
         readonly draft: "Draft";
         readonly running: "Running";

package/dist/puck/copy.js

@@ -6,11 +6,12 @@ export const slotLabels = {
     variantC: ARM_LABELS.variantC
 };
 export const pickerCopy = {
-    label: 'Experiment',
-    none: 'No experiment',
-    loading: 'Loading experiments…',
-    error: "Couldn't load experiments.",
-    forbidden: "You can't see experiments. Ask an admin.",
+    label: 'Test',
+    none: 'No test',
+    search: 'Search tests',
+    loading: 'Loading tests…',
+    error: "Couldn't load tests.",
+    forbidden: "You can't see tests. Ask an admin.",
     statuses: {
         draft: 'Draft',
         running: 'Running',