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

package/dist/puck/editor/experimentOutlinePlugin.js

@@ -0,0 +1,89 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createUsePuck, walkTree } from '@puckeditor/core';
+import { useEffect, useMemo, useState } from 'react';
+import { EXPERIMENT_SLOT_TYPE } from '../../types/puck.js';
+import { useArms } from './armsCache.js';
+const usePuckSelector = createUsePuck();
+const slots = [
+    'control',
+    'variantA',
+    'variantB',
+    'variantC'
+];
+// Puck 0.24.0 dist/chunk-DQXMVPVM.mjs:8040 (item attribute), 8126–8135
+// (direct zone containers). Zones have no stable attribute; avoid the CSS-module hash.
+const zone = 'div[class*="Layer-zones"]';
+const chain = (count)=>Array(count).fill(zone).join(' ~ ');
+function SlotRules({ item: [id, testId, emptySlots] }) {
+    const known = useArms(testId ?? undefined);
+    const [mounted, setMounted] = useState(false);
+    useEffect(()=>{
+        setMounted(true);
+    }, []);
+    // CSS.escape is a browser API: SSR and the first hydration render emit no rules.
+    if (!mounted) return null;
+    const rules = slots.flatMap((slot, index)=>{
+        // Original always remains available. Unknown bound tests must reveal every zone.
+        if (slot === 'control' || testId !== null && (!known || known.arms.includes(slot))) return [];
+        if (!emptySlots[index]) return [];
+        // Exactly the nth zone sibling: the positive chain matches n onward and the
+        // negated chain excludes n+1 onward. Unlike nth-child, DropLine siblings do not count.
+        const selector = `li[data-puck-layer-tree-id="${CSS.escape(id)}"] > ${chain(index + 1)}:not(${chain(index + 2)})`;
+        return [
+            `${selector} { display: none; }`
+        ];
+    }).join('\n');
+    return /*#__PURE__*/ _jsx("style", {
+        "data-xp-outline": id,
+        children: rules
+    });
+}
+function ExperimentOutline({ children }) {
+    // Public selector API in Puck 0.24, rather than the deprecated usePuck hook.
+    const key = usePuckSelector((state)=>{
+        const { data } = state.appState;
+        const items = new Map();
+        const collect = (content)=>{
+            for (const item of content)if (item.type === EXPERIMENT_SLOT_TYPE) {
+                const testId = item.props.experiment?.id;
+                items.set(item.props.id, [
+                    item.props.id,
+                    testId === undefined ? null : String(testId),
+                    slots.map((slot)=>{
+                        const content = item.props[slot];
+                        return !Array.isArray(content) || content.length === 0;
+                    })
+                ]);
+            }
+        };
+        walkTree(data, state.config, (content)=>{
+            collect(content);
+        });
+        // walkTree visits slots inside legacy zones, but does not call back on the zone itself.
+        for (const content of Object.values(data.zones ?? {}))collect(content);
+        return JSON.stringify([
+            ...items.values()
+        ]);
+    });
+    // Only binding/emptiness changes rebuild the rules, not edits to other page fields.
+    const rules = useMemo(()=>JSON.parse(key).map((item)=>/*#__PURE__*/ _jsx(SlotRules, {
+                item: item
+            }, item[0])), [
+        key
+    ]);
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            children,
+            rules
+        ]
+    });
+}
+/** Add to Puck's plugins so its outline wrapper composes with the host's overrides. */ export function experimentOutlinePlugin() {
+    return {
+        name: 'experiment-outline',
+        overrides: {
+            outline: ExperimentOutline
+        }
+    };
+}

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

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

package/dist/puck/editor/integration.js

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

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

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

package/dist/puck/editor/xpGoalPuckEditorField.js

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

package/dist/puck/experimentSlotField.d.ts

@@ -1,5 +1,7 @@
 import type { CustomField } from '@puckeditor/core';
 import type { ExperimentRef } from '../types/puck.js';
+import { type PuckRoutes } from './routes.js';
 export declare function createExperimentSlotField(opts?: {
     label?: string;
+    routes?: PuckRoutes;
 }): CustomField<ExperimentRef | null>;

package/dist/puck/experimentSlotField.js

@@ -1,13 +1,21 @@
 import { createElement } from 'react';
 import { ExperimentPicker } from './ExperimentPicker.js';
+import { resolvePuckRoutes } from './routes.js';
+import { PuckHostProvider } from './hostContext.js';
 import { pickerCopy } from './copy.js';
 export function createExperimentSlotField(opts) {
+    const routes = resolvePuckRoutes(opts?.routes);
     return {
         type: 'custom',
         label: opts?.label ?? pickerCopy.label,
-        render: ({ value, onChange })=>createElement(ExperimentPicker, {
-                value,
-                onChange
+        render: ({ value, onChange })=>createElement(PuckHostProvider, {
+                routes,
+                children: createElement('div', {
+                    className: 'xp-puck-field'
+                }, createElement(ExperimentPicker, {
+                    value,
+                    onChange
+                }))
             })
     };
 }

package/dist/puck/hostContext.d.ts

@@ -0,0 +1,10 @@
+import { resolvePuckRoutes } from './routes.js';
+import type { ReactNode } from 'react';
+export declare const usePuckRoutes: () => {
+    admin: string;
+    api: string;
+};
+export declare function PuckHostProvider({ routes, children }: {
+    routes: ReturnType<typeof resolvePuckRoutes>;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/puck/hostContext.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { resolvePuckRoutes } from './routes.js';
+const PuckHostContext = /*#__PURE__*/ createContext(resolvePuckRoutes());
+export const usePuckRoutes = ()=>useContext(PuckHostContext);
+export function PuckHostProvider({ routes, children }) {
+    return /*#__PURE__*/ _jsx(PuckHostContext.Provider, {
+        value: routes,
+        children: children
+    });
+}

package/dist/puck/integration.d.ts

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

package/dist/puck/integration.js

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

package/dist/puck/routes.d.ts

@@ -0,0 +1,12 @@
+export interface PuckRoutes {
+    admin?: string;
+    api?: string;
+}
+export declare const DEFAULT_PUCK_ROUTES: {
+    readonly admin: "/admin";
+    readonly api: "/api";
+};
+export declare function resolvePuckRoutes(routes?: PuckRoutes): {
+    admin: string;
+    api: string;
+};

package/dist/puck/routes.js

@@ -0,0 +1,11 @@
+// Payload's documented route defaults; hosts pass config.routes when customized.
+export const DEFAULT_PUCK_ROUTES = {
+    admin: '/admin',
+    api: '/api'
+};
+export function resolvePuckRoutes(routes) {
+    return {
+        admin: (routes?.admin ?? DEFAULT_PUCK_ROUTES.admin).replace(/\/$/, ''),
+        api: (routes?.api ?? DEFAULT_PUCK_ROUTES.api).replace(/\/$/, '')
+    };
+}

package/dist/puck/slotConfig.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentConfig } from '@puckeditor/core';
 import type { ExperimentSlotProps } from '../types/puck.js';
-export declare const experimentSlotLabel: "Experiment";
+export declare const experimentSlotLabel = "Experiment block";
 export declare const experimentSlotFields: NonNullable<ComponentConfig<ExperimentSlotProps>['fields']>;
 export declare const experimentSlotDefaultProps: NonNullable<ComponentConfig<ExperimentSlotProps>['defaultProps']>;

package/dist/puck/slotConfig.js

@@ -1,6 +1,6 @@
 import { createExperimentSlotField } from './experimentSlotField.js';
-import { pickerCopy, slotLabels } from './copy.js';
-export const experimentSlotLabel = pickerCopy.label;
+import { slotLabels } from './copy.js';
+export const experimentSlotLabel = 'Experiment block';
 export const experimentSlotFields = {
     experiment: createExperimentSlotField(),
     // Puck 0.24's defaultSlots prepends each slot, reversing declaration order in the outline.

package/dist/puck/xpGoalField.d.ts

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

package/dist/puck/xpGoalField.js

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

package/dist/results/health.d.ts

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

package/dist/results/health.js

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

package/dist/results/snapshot.js

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

package/dist/sanitizeReadinessDetail.js

@@ -8,6 +8,7 @@ const arm = (value)=>typeof value === 'string' && [
         'variantC',
         'holdout'
     ].includes(value);
+const path = (value)=>typeof value === 'string' && value.length <= 128 && value.startsWith('/') && !value.includes('//') && !/[^A-Za-z0-9_/-]/.test(value);
 const failure = (value)=>value === 'placements-failed' || value === 'forbidden' || value === 'not-found';
 /** Summary details contain identifiers only. Project known shapes rather than
  * recursively copying host objects: titles, messages and placement detail are text.
@@ -15,15 +16,64 @@ const failure = (value)=>value === 'placements-failed' || value === 'forbidden'
  * counts and layer capacity, which are not identifiers).
  */ export function sanitizeReadinessDetail(code, detail) {
     switch(code){
+        case 'goal-in-some-versions':
+            {
+                const rows = Array.isArray(detail) ? detail : [
+                    detail
+                ];
+                return rows.filter(object).filter((row)=>key(row.metricId) || typeof row.metricId === 'number' && Number.isSafeInteger(row.metricId)).map((row)=>({
+                        metricId: row.metricId
+                    }));
+            }
+        case 'placement-unchecked':
+            return object(detail) ? Object.fromEntries(Object.entries(detail).filter(([k, v])=>k === 'path' ? path(v) : [
+                    'collection',
+                    'id'
+                ].includes(k) && (key(v) || typeof v === 'number' && Number.isSafeInteger(v)))) : undefined;
+        case 'placement-unpublished':
+        case 'duplicate-version-row':
+        case 'interacting-tests':
+            return Array.isArray(detail) ? detail.filter(object).map((row)=>Object.fromEntries(Object.entries(row).filter(([k, v])=>[
+                        'collection',
+                        'id',
+                        'experimentId',
+                        'slug'
+                    ].includes(k) ? key(v) || typeof v === 'number' && Number.isSafeInteger(v) : k === 'path' ? path(v) : k === 'status' ? [
+                        'running',
+                        'decided'
+                    ].includes(String(v)) : k === 'version' && typeof v === 'boolean'))) : undefined;
+        case 'version-same-address':
+            return object(detail) && arm(detail.arm) && arm(detail.otherArm) && path(detail.path) ? {
+                arm: detail.arm,
+                otherArm: detail.otherArm,
+                path: detail.path
+            } : undefined;
+        case 'version-identical':
+            return object(detail) && arm(detail.arm) && key(detail.collection) && (key(detail.id) || typeof detail.id === 'number' && Number.isSafeInteger(detail.id)) ? {
+                arm: detail.arm,
+                collection: detail.collection,
+                id: detail.id,
+                ...path(detail.path) ? {
+                    path: detail.path
+                } : {}
+            } : undefined;
         case 'block-path-rule':
             return object(detail) && Array.isArray(detail.rules) && detail.rules.length && detail.rules.every((index)=>Number.isSafeInteger(index) && index >= 0) ? {
                 rules: detail.rules
             } : undefined;
         case 'no-placements':
             return failure(detail) ? detail : undefined;
+        case 'page-in-use':
+            {
+                if (!object(detail) || !Array.isArray(detail.paths)) return undefined;
+                const paths = detail.paths.filter(path);
+                return paths.length ? {
+                    paths
+                } : undefined;
+            }
         case 'page-target-unpublished':
             // Paths only: no query, fragment, whitespace, URL authority or encoded text.
-            return typeof detail === 'string' && detail.length <= 128 && detail.startsWith('/') && !detail.includes('//') && !/[^A-Za-z0-9_/-]/.test(detail) ? detail : undefined;
+            return path(detail) ? detail : undefined;
         case 'flag-params-invalid':
             {
                 if (!Array.isArray(detail) || !detail.length || !detail.every((item)=>object(item) && arm(item.arm) && key(item.field))) return undefined;

package/dist/server/metadata.js

@@ -13,14 +13,21 @@ import { serverManifest } from './context.js';
     const live = manifest?.experiments.find((e)=>e.kind === 'page' && e.arms.some((a)=>a.pageTarget !== undefined && normalisePath(a.pageTarget) === normalisePath(path)));
     if (live) {
         const controlPath = live.arms.find((a)=>a.kind === 'control')?.pageTarget;
-        return controlPath && normalisePath(path) !== normalisePath(controlPath) ? {
+        if (!controlPath) return {};
+        // The Original's URL may be served with a variant's route: its canonical must stay on the Original,
+        // never the (noindexed) variant route the host would otherwise derive.
+        return normalisePath(path) !== normalisePath(controlPath) ? {
             robots: {
                 index: false
             },
             alternates: {
                 canonical: controlPath
             }
-        } : {};
+        } : {
+            alternates: {
+                canonical: controlPath
+            }
+        };
     }
     const archivedPath = manifest ? findNormalisedPathKey(manifest.archivedPages, path) : undefined;
     const archived = archivedPath === undefined ? undefined : manifest?.archivedPages[archivedPath];

package/dist/server/normaliseContentRelationships.d.ts

@@ -0,0 +1,7 @@
+import type { Block, Field } from 'payload';
+/** Undo depth expansion only where the collection schema declares relationships.
+ * Hidden fields and field-level afterRead hooks are unaffected by depth, so
+ * relationship expansion is the only depth-dependent transformation to undo.
+ * Other objects (especially JSON content with its own ids) must stay intact.
+ */
+export declare function normaliseContentRelationships(data: unknown, fields: Field[], blocks?: Block[], locales?: readonly string[]): unknown;