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

package/dist/admin/useApi.js

@@ -1,10 +1,8 @@
 'use client';
 import { useMemo } from 'react';
-import { useConfig } from '@payloadcms/ui';
 import { createApi } from './api.js';
-export function useApi() {
-    const { config } = useConfig();
-    return useMemo(()=>createApi(config.routes.api), [
-        config.routes.api
+export function useApi(apiRoute) {
+    return useMemo(()=>createApi(apiRoute), [
+        apiRoute
     ]);
 }

package/dist/admin/useLayerUsage.js

@@ -1,4 +1,5 @@
 'use client';
+import { fetchAllDocs } from '../lib/fetchAllDocs.js';
 import { useConfig } from '@payloadcms/ui';
 import { useEffect, useState } from 'react';
 import { layerUsage } from './layerUsage.model.js';
@@ -13,33 +14,23 @@ export function useLayerExperiments(layerId) {
         if (id == null) return;
         const controller = new AbortController();
         async function load() {
-            const docs = [];
-            let page = 1;
-            while(!controller.signal.aborted){
-                const query = new URLSearchParams({
-                    depth: '0',
-                    limit: '100',
-                    page: String(page),
-                    'where[layer][equals]': id,
-                    'where[status][in]': 'running,decided'
-                });
-                const response = await fetch(`${api}/xp-experiments?${query}`, {
-                    credentials: 'include',
-                    signal: controller.signal
-                });
-                if (!response.ok) {
-                    if (!controller.signal.aborted) setState(null);
-                    return;
-                }
-                const data = await response.json();
-                docs.push(...data.docs);
-                if (!data.hasNextPage) break;
-                page++;
+            const query = new URLSearchParams({
+                depth: '0',
+                'where[layer][equals]': id,
+                'where[status][in]': 'running,decided'
+            });
+            const response = await fetchAllDocs(`${api}/xp-experiments?${query}`, {
+                credentials: 'include',
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                if (!controller.signal.aborted) setState(null);
+                return;
             }
             if (!controller.signal.aborted) setState({
                 api,
                 id: id,
-                usage: layerUsage(docs)
+                usage: layerUsage(response.docs)
             });
         }
         void load().catch(()=>{

package/dist/admin/views/ExperimentsRootView.js

@@ -1,10 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { accentStyles } from '../../ui/accent.js';
-import { formatAdminURL } from 'payload/shared';
+import { flattenTopLevelFields, formatAdminURL } from 'payload/shared';
 import { notFound, redirect } from 'next/navigation.js';
 import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
 import { serializeAttributeKeys, serializeFlagPoints, serializeMetricSources } from '../../collections/serialize.js';
-import { puckCollections } from '../../options.js';
+import { serializePageCollections } from '../pageCollections.js';
+import { collectionLabel as resolveLabel } from '../../collections/labels.js';
+import { documentEditor, puckCollections } from '../../options.js';
 import { xpOptionsFromReq } from '../../options/fromReq.js';
 import { XP_TESTS_SURFACE } from '../paths.js';
 import { SURFACE_COPY } from '../copy/surface.js';
@@ -26,6 +28,9 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
     } else if (tail.length === 1) {
         route = 'test';
         id = tail[0];
+    } else if (tail.length === 2 && tail[0] === 'by-slug') {
+        route = 'test';
+        id = tail[1];
     } else if (tail.length === 2 && tail[1] === 'results') {
         route = 'results';
         id = tail[0];
@@ -71,6 +76,22 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
             children: SURFACE_COPY.noAccess
         });
     }
+    if (canManage && id && tail[0] === 'by-slug') {
+        const result = await req.payload.find({
+            collection: 'xp-experiments',
+            req,
+            overrideAccess: false,
+            depth: 0,
+            limit: 1,
+            where: {
+                slug: {
+                    equals: id
+                }
+            }
+        });
+        if (!result.docs[0]) return notFound();
+        id = String(result.docs[0].id);
+    }
     const flagPoints = serializeFlagPoints(options);
     // xp-state is manager-readable only. Results-only readers do not edit settings.
     if (canManage && flagPoints.length) {
@@ -83,20 +104,22 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
         const defaults = state.flagDefaults;
         for (const point of flagPoints)point.effectiveDefaults = defaults?.[point.id]?.params ?? point.defaultParams;
     }
-    const registrations = puckCollections(options);
-    const pages = route === 'new' && canManage && options.puck?.enabled && registrations.length ? (await Promise.all(registrations.map(async ({ slug: collection })=>{
+    const registrations = [
+        ...new Set([
+            ...options.puck?.enabled ? puckCollections(options) : [],
+            ...options.blocks?.collections ?? []
+        ].map((entry)=>entry.slug))
+    ];
+    const pages = route === 'new' && canManage && registrations.length ? (await Promise.all(registrations.map(async (collection)=>{
         try {
             const config = req.payload.config.collections.find((item)=>item.slug === collection);
             const useAsTitle = config?.admin.useAsTitle ?? 'id';
-            const label = config?.labels.plural;
-            // Keep /rsc dependency-safe: translations is not a declared runtime dependency,
-            // so a per-language label picks the request language, then English, then any string.
-            const byLanguage = label && typeof label === 'object' ? label : {};
-            const collectionLabel = typeof label === 'string' ? label : [
-                byLanguage[req.i18n?.language ?? 'en'],
-                byLanguage.en,
-                ...Object.values(byLanguage)
-            ].find((value)=>typeof value === 'string') ?? collection;
+            const collectionLabel = resolveLabel(config?.labels.plural, collection, req);
+            // appliesTo may inspect any stored field; ordinary Puck lists keep their title-only projection.
+            const predicateFields = options.blocks?.collections.some((entry)=>entry.slug === collection) ? Object.fromEntries(flattenTopLevelFields(config?.fields ?? []).map((field)=>[
+                    field.name,
+                    true
+                ])) : {};
             const result = await req.payload.find({
                 collection,
                 req,
@@ -106,28 +129,35 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
                 sort: '-updatedAt',
                 draft: true,
                 select: {
-                    [useAsTitle]: true
+                    [useAsTitle]: true,
+                    ...predicateFields
                 }
             });
+            // The new-test list uses the latest draft's editing intent, as the "Test a block" field condition does (§4.1).
             return result.docs.map((doc)=>{
+                const editor = documentEditor(options, collection, doc);
+                if (editor !== 'puck' && editor !== 'blocks') return null;
                 const id = doc.id;
                 const customUrl = options.admin?.editorUrl?.({
                     collection,
                     id,
-                    draft: true
+                    draft: true,
+                    editor,
+                    doc
                 });
                 const title = doc[useAsTitle];
                 return {
                     collection,
                     collectionLabel,
                     id,
+                    editor,
                     title: typeof title === 'string' || typeof title === 'number' ? String(title) : String(id),
                     editorUrl: typeof customUrl === 'string' ? customUrl : formatAdminURL({
                         adminRoute,
                         path: `/collections/${collection}/${encodeURIComponent(String(id))}`
                     })
                 };
-            });
+            }).filter((page)=>page !== null);
         } catch  {
             return [];
         }
@@ -151,6 +181,18 @@ export async function ExperimentsRootView({ initPageResult, params, searchParams
         ...pages === undefined ? {} : {
             pages
         },
+        pageCollections: serializePageCollections(options.pages?.collections ?? [], req),
+        collectionTitles: Object.fromEntries(req.payload.config.collections.flatMap((collection)=>{
+            const title = collection.admin.useAsTitle;
+            return title && title !== 'id' ? [
+                [
+                    collection.slug,
+                    title
+                ]
+            ] : [];
+        })),
+        userId: req.user.id,
+        userCollection: req.payload.config.admin.user,
         attributeKeys: serializeAttributeKeys(options),
         metricSources: serializeMetricSources(options),
         ...descriptions ? {

package/dist/admin/views/TestsNavLinkServer.d.ts

@@ -0,0 +1,2 @@
+import type { ServerProps } from 'payload';
+export declare function TestsNavLinkServer({ payload, user, permissions }: Pick<ServerProps, 'payload' | 'user' | 'permissions'>): Promise<string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;

package/dist/admin/views/TestsNavLinkServer.js

@@ -0,0 +1,43 @@
+import { RenderServerComponent } from '@payloadcms/ui/elements/RenderServerComponent';
+import { SURFACE_COPY } from '../copy/surface.js';
+import { XP_TESTS_NAV_CLIENT } from '../paths.js';
+export async function TestsNavLinkServer({ payload, user, permissions }) {
+    const testPermissions = permissions?.collections?.['xp-experiments'];
+    if (!user?.collection || testPermissions?.update !== true) return null;
+    const result = await payload.find({
+        collection: 'payload-preferences',
+        where: {
+            and: [
+                {
+                    key: {
+                        equals: 'nav'
+                    }
+                },
+                {
+                    'user.relationTo': {
+                        equals: user.collection
+                    }
+                },
+                {
+                    'user.value': {
+                        equals: user.id
+                    }
+                }
+            ]
+        },
+        limit: 1,
+        pagination: false,
+        depth: 0,
+        user,
+        overrideAccess: false
+    });
+    const value = result.docs[0]?.value;
+    // Resolve the CSS-bearing client boundary through Payload's public import map.
+    return RenderServerComponent({
+        Component: XP_TESTS_NAV_CLIENT,
+        importMap: payload.importMap,
+        clientProps: {
+            isOpen: value?.groups?.[SURFACE_COPY.title]?.open ?? true
+        }
+    });
+}

package/dist/arms/copy.d.ts

@@ -0,0 +1,6 @@
+import type { ArmIssueCode } from '../types/endpoints.js';
+export declare const ISSUE_COPY: Record<ArmIssueCode, string>;
+export declare function issueMessage(issue: {
+    code: string;
+    message: string;
+}, total: number): string;

package/dist/arms/copy.js

@@ -0,0 +1,16 @@
+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 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/arms/model.d.ts

@@ -0,0 +1,23 @@
+import type { ArmIssue } from '../collections/experiments/armInvariants.js';
+import type { Arm, ArmKey, ExperimentKind } from '../types/contracts.js';
+export declare function defaultArms(kind?: ExperimentKind): Arm[];
+/** Keep content slots in step with the experiment kind, including an unset kind. */
+export declare function withSlotsFor(arms: Arm[], kind?: ExperimentKind): Arm[];
+export declare function totalWeight(arms: Arm[]): number;
+export declare function addVariant(arms: Arm[], kind?: ExperimentKind): Arm[];
+export declare function removeArm(arms: Arm[], key: ArmKey): Arm[];
+export declare function addHoldoutArm(arms: Arm[]): Arm[];
+export declare function removeHoldout(arms: Arm[]): Arm[];
+export declare function splitEvenly(arms: Arm[]): Arm[];
+export declare function setWeight(arms: Arm[], key: ArmKey, weight: number): Arm[];
+export declare function issuesByRow(arms: Arm[], kind?: ExperimentKind): {
+    rows: ArmIssue[][];
+    form: ArmIssue[];
+};
+export declare const ARM_FIELDS: readonly ["key", "label", "weight", "kind", "slot", "params", "pageTarget"];
+/** Payload arrays store each row's values at separate field paths. */
+export declare function readArms(fields: Record<string, {
+    value?: unknown;
+}>, path?: string): Arm[];
+/** Keep the edited share exact and distribute the remaining whole percentages proportionally. */
+export declare function balanceWeight(arms: Arm[], key: ArmKey, weight: number): Arm[];

package/dist/arms/model.js

@@ -0,0 +1,173 @@
+import { addHoldout, checkArms } from '../collections/experiments/armInvariants.js';
+import { ARM_LABELS as GROUP_LABELS } from '../labels/arms.js';
+const VARIANTS = [
+    'variantA',
+    'variantB',
+    'variantC'
+];
+export function defaultArms(kind) {
+    return withSlotsFor([
+        {
+            key: 'control',
+            kind: 'control',
+            label: GROUP_LABELS.control,
+            weight: 50
+        },
+        {
+            key: 'variantA',
+            kind: 'variant',
+            label: GROUP_LABELS.variantA,
+            weight: 50
+        }
+    ], kind);
+}
+/** Keep content slots in step with the experiment kind, including an unset kind. */ export function withSlotsFor(arms, kind) {
+    const next = arms.map((arm)=>{
+        if (kind === 'block' && arm.kind !== 'holdout') return arm.slot === arm.key ? arm : {
+            ...arm,
+            slot: arm.key
+        };
+        // Postgres returns null for unset columns; null counts as "no slot" so a loaded doc is not rewritten.
+        if (arm.slot == null) return arm;
+        const { slot: _slot, ...rest } = arm;
+        return rest;
+    });
+    return next.every((arm, index)=>arm === arms[index]) ? arms : next;
+}
+const finiteWeight = (weight)=>Number.isFinite(weight) ? weight : 0;
+export function totalWeight(arms) {
+    return arms.reduce((sum, arm)=>sum + finiteWeight(arm.weight), 0);
+}
+export function addVariant(arms, kind) {
+    if (!arms.some((arm)=>arm.kind === 'control')) return arms;
+    const key = VARIANTS.find((candidate)=>!arms.some((arm)=>arm.key === candidate));
+    if (!key || arms.filter((arm)=>arm.kind === 'variant').length >= 3) return arms;
+    const block = kind === 'block' || kind === undefined && arms.some((arm)=>arm.slot !== undefined);
+    const variant = {
+        key,
+        kind: 'variant',
+        label: GROUP_LABELS[key],
+        weight: 0,
+        ...block ? {
+            slot: key
+        } : {}
+    };
+    const index = arms.findIndex((arm)=>arm.kind === 'holdout');
+    const result = [
+        ...arms
+    ];
+    result.splice(index < 0 ? arms.length : index, 0, variant);
+    return result;
+}
+export function removeArm(arms, key) {
+    if (arms.some((arm)=>arm.key === key && arm.kind === 'control')) return arms;
+    if (key === 'holdout') return removeHoldout(arms);
+    return arms.filter((arm)=>arm.key !== key);
+}
+export function addHoldoutArm(arms) {
+    if (!arms.some((arm)=>arm.kind === 'control') || arms.some((arm)=>arm.kind === 'holdout' || arm.key === 'holdout')) return arms;
+    return addHoldout(arms.map((arm)=>Number.isFinite(arm.weight) ? arm : {
+            ...arm,
+            weight: 0
+        }));
+}
+// Largest remainder, with equal fractional remainders awarded to Original first.
+function distribute(arms, total, proportional) {
+    if (!arms.length) return arms;
+    const weightTotal = totalWeight(arms);
+    const useWeights = proportional && weightTotal > 0;
+    const denominator = useWeights ? weightTotal : arms.length;
+    const numerators = arms.map((arm)=>(useWeights ? finiteWeight(arm.weight) : 1) * total);
+    const weights = numerators.map((numerator)=>Math.floor(numerator / denominator));
+    const order = arms.map((_, i)=>i).sort((a, b)=>numerators[b] % denominator - numerators[a] % denominator || Number(arms[b].kind === 'control') - Number(arms[a].kind === 'control') || a - b);
+    const remainder = total - weights.reduce((sum, weight)=>sum + weight, 0);
+    for(let i = 0; i < remainder; i++)weights[order[i % order.length]]++;
+    return arms.map((arm, i)=>({
+            ...arm,
+            weight: weights[i]
+        }));
+}
+export function removeHoldout(arms) {
+    if (!arms.some((arm)=>arm.kind === 'holdout')) return arms;
+    return distribute(arms.filter((arm)=>arm.kind !== 'holdout'), totalWeight(arms), true);
+}
+export function splitEvenly(arms) {
+    const holdout = arms.find((arm)=>arm.kind === 'holdout');
+    const weight = finiteWeight(holdout?.weight ?? 0);
+    return [
+        ...distribute(arms.filter((arm)=>arm.kind !== 'holdout'), 100 - weight, false),
+        ...holdout ? [
+            {
+                ...holdout,
+                weight
+            }
+        ] : []
+    ];
+}
+export function setWeight(arms, key, weight) {
+    return arms.map((arm)=>arm.key === key ? {
+            ...arm,
+            weight
+        } : arm);
+}
+export function issuesByRow(arms, kind) {
+    const rows = arms.map(()=>[]);
+    const form = [];
+    for (const issue of checkArms(arms, kind)){
+        const index = issue.armIndex ?? arms.findIndex((arm)=>arm.key === issue.armKey);
+        if (index >= 0 && index < arms.length) rows[index].push(issue);
+        else form.push(issue);
+    }
+    return {
+        rows,
+        form
+    };
+}
+export const ARM_FIELDS = [
+    'key',
+    'label',
+    'weight',
+    'kind',
+    'slot',
+    'params',
+    'pageTarget'
+];
+/** Payload arrays store each row's values at separate field paths. */ export function readArms(fields, path = 'arms') {
+    const indices = new Set();
+    for (const name of Object.keys(fields)){
+        if (!name.startsWith(`${path}.`)) continue;
+        const [index, field] = name.slice(path.length + 1).split('.');
+        if (/^\d+$/.test(index) && field === 'key') indices.add(Number(index));
+    }
+    return [
+        ...indices
+    ].sort((a, b)=>a - b).map((index)=>Object.fromEntries(ARM_FIELDS.flatMap((field)=>{
+            const value = fields[`${path}.${index}.${field}`]?.value;
+            return value === undefined ? [] : [
+                [
+                    field,
+                    value
+                ]
+            ];
+        })));
+}
+/** Keep the edited share exact and distribute the remaining whole percentages proportionally. */ export function balanceWeight(arms, key, weight) {
+    if (!arms.some((arm)=>arm.key === key) || !Number.isInteger(weight) || weight < 0 || weight > 100) return arms;
+    const others = arms.filter((arm)=>arm.key !== key);
+    if (!others.length) return arms;
+    const total = others.reduce((sum, arm)=>sum + Math.max(0, Number.isFinite(arm.weight) ? arm.weight : 0), 0);
+    const denominator = total || others.length;
+    const raw = others.map((arm)=>(total ? Math.max(0, Number.isFinite(arm.weight) ? arm.weight : 0) : 1) * (100 - weight) / denominator);
+    const whole = raw.map(Math.floor);
+    const order = raw.map((_, i)=>i).sort((a, b)=>raw[b] - whole[b] - (raw[a] - whole[a]) || a - b);
+    const remainder = 100 - weight - whole.reduce((sum, value)=>sum + value, 0);
+    for(let i = 0; i < remainder; i++)whole[order[i]]++;
+    const shares = new Map(others.map((arm, i)=>[
+            arm.key,
+            whole[i]
+        ]));
+    return setWeight(arms, key, weight).map((arm)=>shares.has(arm.key) ? {
+            ...arm,
+            weight: shares.get(arm.key)
+        } : arm);
+}

package/dist/blocks/bindings.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedOptions } from '../types/contracts.js';
+/** Same document-kind rule as the scan; Payload blocks are top level, Puck is recursive. */
+export declare function placementSlugs(options: Pick<ResolvedOptions, 'blocks' | 'puck'>, collection: string, doc: Record<string, unknown> | undefined): string[];

package/dist/blocks/bindings.js

@@ -0,0 +1,34 @@
+import { documentEditor, puckCollections } from '../options.js';
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks, isObject } from './model.js';
+/** Same document-kind rule as the scan; Payload blocks are top level, Puck is recursive. */ export function placementSlugs(options, collection, doc) {
+    if (!doc) return [];
+    const editor = documentEditor(options, collection, doc);
+    if (editor === 'blocks') {
+        const registration = options.blocks?.collections.find((r)=>r.slug === collection);
+        if (!registration) return [];
+        return [
+            ...new Set(hostBlocks(doc[registration.field]).flatMap((block)=>block.blockType === (registration.blockSlug ?? EXPERIMENT_BLOCK_SLUG) && typeof block.experiment === 'string' ? [
+                    block.experiment
+                ] : []))
+        ];
+    }
+    if (editor !== 'puck') return [];
+    const registration = puckCollections(options).find((r)=>r.slug === collection);
+    const found = new Set();
+    function walk(v) {
+        if (Array.isArray(v)) {
+            v.forEach(walk);
+            return;
+        }
+        if (!isObject(v)) return;
+        if (v.type === 'ExperimentSlot' && isObject(v.props)) {
+            const ref = v.props.experiment, slug = typeof ref === 'string' ? ref : isObject(ref) ? ref.slug : undefined;
+            if (typeof slug === 'string') found.add(slug);
+        }
+        Object.values(v).forEach(walk);
+    }
+    if (registration) walk(doc[registration.field]);
+    return [
+        ...found
+    ];
+}

package/dist/blocks/createExperimentBlock.d.ts

@@ -0,0 +1,6 @@
+import type { Block } from 'payload';
+export declare function validateExperimentSlots(value: unknown): true | string;
+export declare function createExperimentBlock({ blocks, slug }: {
+    blocks: Block[];
+    slug?: string;
+}): Block;

package/dist/blocks/createExperimentBlock.js

@@ -0,0 +1,77 @@
+import { XP_BLOCK_STATUS, XP_BLOCK_ROW_LABEL, XP_COPY_ORIGINAL } from '../admin/paths.js';
+import { BLOCK_SLOTS, EXPERIMENT_BLOCK_SLUG } from './model.js';
+export function validateExperimentSlots(value) {
+    if (!Array.isArray(value)) return true;
+    const slots = value.map((row)=>row?.slot);
+    return new Set(slots).size === slots.length ? true : 'Each version appears once';
+}
+export function createExperimentBlock({ blocks, slug = EXPERIMENT_BLOCK_SLUG }) {
+    if (blocks.some((block)=>block.slug === slug)) throw new Error('Experiment blocks cannot be nested.');
+    return {
+        slug,
+        labels: {
+            singular: 'Experiment',
+            plural: 'Experiments'
+        },
+        fields: [
+            {
+                name: 'xpBlockStatus',
+                type: 'ui',
+                admin: {
+                    components: {
+                        Field: XP_BLOCK_STATUS
+                    }
+                }
+            },
+            {
+                name: 'experiment',
+                label: 'Test',
+                type: 'text',
+                required: true
+            },
+            {
+                name: 'slots',
+                label: 'Versions',
+                type: 'array',
+                validate: validateExperimentSlots,
+                admin: {
+                    components: {
+                        RowLabel: XP_BLOCK_ROW_LABEL
+                    }
+                },
+                fields: [
+                    {
+                        name: 'xpCopyOriginal',
+                        type: 'ui',
+                        admin: {
+                            components: {
+                                Field: XP_COPY_ORIGINAL
+                            }
+                        }
+                    },
+                    {
+                        name: 'slot',
+                        label: 'Version',
+                        type: 'select',
+                        required: true,
+                        options: BLOCK_SLOTS.map((value, index)=>({
+                                value,
+                                label: [
+                                    'Original',
+                                    'Variant A',
+                                    'Variant B',
+                                    'Variant C'
+                                ][index]
+                            }))
+                    },
+                    {
+                        name: 'blocks',
+                        label: 'Content',
+                        type: 'blocks',
+                        blocks
+                    }
+                ]
+            }
+        ]
+    };
+}

package/dist/blocks/formState.d.ts

@@ -0,0 +1,31 @@
+import type { Block, Field, SanitizedConfig } from 'payload';
+import { type ExperimentBlock, type HostBlock } from './model.js';
+type RowConfig = {
+    blocks?: Block[];
+    localization?: SanitizedConfig['localization'];
+};
+type RowsField = Extract<Field, {
+    type: 'array' | 'blocks';
+}>;
+/** Mirror Payload 3.90.2's collections/operations/utilities/copyDataWithFreshRowIDs.js:
+ * walk configured row/subfield containers only. Mint ids for array/blocks rows, leaving
+ * opaque values (including json, richText, relationships and uploads) unchanged.
+ * Global block definitions resolve blockReferences; inline slot blocks retain host configs.
+ */
+export declare function freshBlockIds<T>(value: T, field: RowsField, config?: RowConfig, mint?: () => string): T;
+export declare function wrapExperimentBlock(block: HostBlock, experiment: string, field: RowsField, config?: RowConfig, blockSlug?: string): ExperimentBlock;
+export declare function syncExperimentSlots(block: ExperimentBlock, arms: readonly {
+    key: string;
+    kind?: string;
+    slot?: string | null;
+}[], field: RowsField, config?: RowConfig): ExperimentBlock;
+export declare function copyOriginalIntoVersion(block: ExperimentBlock, slot: string, field: RowsField, config?: RowConfig): ExperimentBlock;
+export declare function unwrapExperimentBlock(block: HostBlock, field: RowsField, slot?: string, config?: RowConfig): HostBlock[];
+/** Config coordinates include unnamed layout containers. No field component is injected here. */
+export declare function findRegisteredBlocksField(fields: readonly Field[], name: string): {
+    field: Extract<Field, {
+        type: 'blocks';
+    }>;
+    path: Array<string | number>;
+} | undefined;
+export {};