@delmaredigital/payload-experiments 0.0.0-stage → 0.1.0-rc.3

package/dist/puck/editor/ExperimentSlotEditor.js

@@ -0,0 +1,225 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createUsePuck, registerOverlayPortal, useGetPuck } from '@puckeditor/core';
+import { useEffect, useId, useState } from 'react';
+import { pickerCopy } from '../copy.js';
+import { experimentSlotDefaultProps, experimentSlotFields, experimentSlotLabel } from '../slotConfig.js';
+import { bannerFor, tabsFor } from './editor.model.js';
+import { cloneSlot } from './cloneSlot.js';
+import { CreateExperimentDrawer } from './CreateExperimentDrawer.js';
+import { editorCopy } from './copy.js';
+const usePuckSelector = createUsePuck();
+// Public Puck registration enables native controls inside the editor canvas.
+const registerControls = (element)=>registerOverlayPortal(element, {
+        disableDrag: true
+    });
+function isExperiment(value) {
+    if (!value || typeof value !== 'object') return false;
+    const doc = value;
+    return typeof doc.name === 'string' && typeof doc.status === 'string' && Object.hasOwn(pickerCopy.statuses, doc.status) && Array.isArray(doc.arms) && doc.arms.every((arm)=>arm && typeof arm === 'object' && (Object.hasOwn(editorCopy.labels, arm.key) || arm.key === 'holdout') && [
+            'control',
+            'variant',
+            'holdout'
+        ].includes(arm.kind) && typeof arm.label === 'string');
+}
+function EditorRender(props) {
+    const getPuck = useGetPuck();
+    const tabId = useId();
+    const experimentId = props.experiment?.id;
+    const [loaded, setLoaded] = useState();
+    const [active, setActive] = useState();
+    const [creating, setCreating] = useState(false);
+    // A non-empty variant is only overwritten after an explicit second confirmation.
+    const [confirming, setConfirming] = useState(null);
+    const selected = usePuckSelector((state)=>state.selectedItem?.props.id === props.id);
+    const originalEmpty = usePuckSelector((state)=>{
+        const content = state.selectedItem?.props.control;
+        return state.selectedItem?.props.id !== props.id || !Array.isArray(content) || content.length === 0;
+    });
+    useEffect(()=>{
+        if (experimentId === undefined) return;
+        const controller = new AbortController();
+        let current = true;
+        async function load() {
+            try {
+                const response = await fetch(`/api/xp-experiments/${encodeURIComponent(experimentId)}?depth=0`, {
+                    credentials: 'include',
+                    signal: controller.signal
+                });
+                if (!response.ok) throw new Error('load');
+                const doc = await response.json();
+                if (!isExperiment(doc)) throw new Error('document');
+                if (current) setLoaded({
+                    id: experimentId,
+                    doc
+                });
+            } catch  {
+                if (current) setLoaded({
+                    id: experimentId,
+                    error: true
+                });
+            }
+        }
+        void load();
+        return ()=>{
+            current = false;
+            controller.abort();
+        };
+    }, [
+        experimentId
+    ]);
+    const result = experimentId === undefined || loaded?.id !== experimentId ? undefined : loaded;
+    const experiment = result?.doc;
+    const tabs = tabsFor(experiment);
+    const activeSlot = active && active.id === experimentId ? active.slot : undefined;
+    const slot = tabs.find((tab)=>tab.slot === activeSlot)?.slot ?? tabs[0]?.slot ?? 'control';
+    const Slot = props[slot];
+    const winnerKey = experiment?.decision?.winnerArm;
+    const winner = tabs.find((tab)=>tab.slot === winnerKey)?.label;
+    function requestCopy(variant) {
+        const { selectedItem: item } = getPuck();
+        const target = item?.props.id === props.id ? item.props[variant] : undefined;
+        if (Array.isArray(target) && target.length) setConfirming(variant);
+        else copyTo(variant);
+    }
+    function copyTo(variant) {
+        setConfirming(null);
+        const { selectedItem: item, dispatch, getSelectorForId } = getPuck();
+        if (!item || item.props.id !== props.id || !Array.isArray(item.props.control) || !item.props.control.length) return;
+        const selector = getSelectorForId(props.id);
+        if (!selector) return;
+        dispatch({
+            type: 'replace',
+            destinationIndex: selector.index,
+            destinationZone: selector.zone,
+            data: {
+                ...item,
+                props: {
+                    ...item.props,
+                    [variant]: cloneSlot(item.props.control)
+                }
+            }
+        });
+    }
+    function bind(experiment) {
+        const { getItemById, dispatch, getSelectorForId } = getPuck();
+        const item = getItemById(props.id), selector = getSelectorForId(props.id);
+        if (!item || !selector) return;
+        dispatch({
+            type: 'replace',
+            destinationIndex: selector.index,
+            destinationZone: selector.zone,
+            data: {
+                ...item,
+                props: {
+                    ...item.props,
+                    experiment
+                }
+            }
+        });
+    }
+    return /*#__PURE__*/ _jsxs("section", {
+        style: {
+            border: '1px solid #aaa',
+            padding: 12
+        },
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                ref: registerControls,
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        role: "status",
+                        children: experimentId === undefined ? bannerFor() : result?.error ? editorCopy.loadError : experiment ? bannerFor(experiment.status, winner) : editorCopy.loading
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        type: "button",
+                        disabled: !selected,
+                        onClick: ()=>setCreating(true),
+                        children: editorCopy.createLabel
+                    }),
+                    creating ? /*#__PURE__*/ _jsx(CreateExperimentDrawer, {
+                        onCreate: bind,
+                        onClose: ()=>setCreating(false)
+                    }) : null,
+                    /*#__PURE__*/ _jsx("div", {
+                        style: {
+                            display: 'flex',
+                            flexWrap: 'wrap',
+                            gap: 8,
+                            marginBlock: 8
+                        },
+                        children: tabs.filter((tab)=>tab.slot !== 'control').map((tab)=>/*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                disabled: originalEmpty,
+                                onClick: ()=>requestCopy(tab.slot),
+                                children: editorCopy.copy(tab.label)
+                            }, tab.slot))
+                    }),
+                    confirming ? /*#__PURE__*/ _jsxs("p", {
+                        role: "alert",
+                        children: [
+                            editorCopy.replaceConfirm(tabs.find((tab)=>tab.slot === confirming)?.label ?? confirming),
+                            ' ',
+                            /*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                onClick: ()=>copyTo(confirming),
+                                children: editorCopy.replace
+                            }),
+                            ' ',
+                            /*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                onClick: ()=>setConfirming(null),
+                                children: editorCopy.cancel
+                            })
+                        ]
+                    }) : null,
+                    /*#__PURE__*/ _jsx("div", {
+                        role: "tablist",
+                        "aria-label": editorCopy.tabs,
+                        style: {
+                            display: 'flex',
+                            gap: 8,
+                            marginBottom: 8
+                        },
+                        children: tabs.map((tab, index)=>/*#__PURE__*/ _jsx("button", {
+                                type: "button",
+                                role: "tab",
+                                id: `${tabId}-${tab.slot}`,
+                                "aria-selected": tab.slot === slot,
+                                tabIndex: tab.slot === slot ? 0 : -1,
+                                "aria-controls": `${tabId}-panel`,
+                                onClick: ()=>setActive({
+                                        id: experimentId,
+                                        slot: tab.slot
+                                    }),
+                                onKeyDown: (event)=>{
+                                    const next = event.key === 'ArrowRight' ? (index + 1) % tabs.length : event.key === 'ArrowLeft' ? (index + tabs.length - 1) % tabs.length : event.key === 'Home' ? 0 : event.key === 'End' ? tabs.length - 1 : undefined;
+                                    if (next === undefined) return;
+                                    event.preventDefault();
+                                    setActive({
+                                        id: experimentId,
+                                        slot: tabs[next].slot
+                                    });
+                                    const buttons = event.currentTarget.parentElement?.querySelectorAll('[role="tab"]');
+                                    buttons?.[next]?.focus();
+                                },
+                                children: tab.label
+                            }, tab.slot))
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                role: "tabpanel",
+                id: `${tabId}-panel`,
+                "aria-labelledby": `${tabId}-${slot}`,
+                children: /*#__PURE__*/ _jsx(Slot, {})
+            })
+        ]
+    });
+}
+export const ExperimentSlotEditor = {
+    label: experimentSlotLabel,
+    fields: experimentSlotFields,
+    defaultProps: experimentSlotDefaultProps,
+    render: EditorRender
+};

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

@@ -0,0 +1,3 @@
+import type { Slot } from '../../types/puck.js';
+/** Clone JSON Puck slot data, refreshing component ids even inside nested slots. */
+export declare function cloneSlot(slot: Slot): Slot;

package/dist/puck/editor/cloneSlot.js

@@ -0,0 +1,41 @@
+let sequence = 0;
+function freshId(type, used) {
+    let random;
+    try {
+        const bytes = new Uint32Array(4);
+        globalThis.crypto.getRandomValues(bytes);
+        random = Array.from(bytes, (byte)=>byte.toString(36)).join('');
+    } catch  {
+        random = Math.random().toString(36).slice(2);
+    }
+    let id;
+    do {
+        id = `${type}-${random}${(++sequence).toString(36)}`;
+    }while (used.has(id))
+    used.add(id);
+    return id;
+}
+/** Clone JSON Puck slot data, refreshing component ids even inside nested slots. */ export function cloneSlot(slot) {
+    const used = new Set();
+    function collect(value) {
+        if (!value || typeof value !== 'object') return;
+        if ('id' in value && typeof value.id === 'string') used.add(value.id);
+        Object.values(value).forEach(collect);
+    }
+    collect(slot);
+    function clone(value) {
+        if (Array.isArray(value)) return value.map(clone);
+        if (!value || typeof value !== 'object') return value;
+        const source = value;
+        const result = Object.fromEntries(Object.entries(source).map(([key, entry])=>[
+                key,
+                clone(entry)
+            ]));
+        if (typeof source.type === 'string' && result.props && typeof result.props === 'object') {
+            const props = result.props;
+            props.id = freshId(source.type, used);
+        }
+        return result;
+    }
+    return clone(slot);
+}

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

@@ -0,0 +1,25 @@
+export declare const editorCopy: {
+    readonly labels: {
+        readonly control: "Original";
+        readonly variantA: "Variant A";
+        readonly variantB: "Variant B";
+        readonly variantC: "Variant C";
+    };
+    readonly unbound: "Choose or create an experiment to show different versions.";
+    readonly draft: "This block shows the Original to everyone until the experiment starts.";
+    readonly running: "Changing this content mid-test mixes two versions in one result";
+    readonly decided: (winner: string) => string;
+    readonly archived: "This experiment is archived; the winning content is shown to everyone.";
+    readonly copy: (label: string) => string;
+    readonly replaceConfirm: (label: string) => string;
+    readonly replace: "Replace";
+    readonly createLabel: "Create experiment";
+    readonly creating: "Creating…";
+    readonly cancel: "Cancel";
+    readonly name: "Name";
+    readonly slug: "Slug";
+    readonly createError: "Couldn't create the experiment. Try again.";
+    readonly loading: "Loading experiment…";
+    readonly loadError: "Couldn't load this experiment. Try selecting it again.";
+    readonly tabs: "Experiment versions";
+};

package/dist/puck/editor/copy.js

@@ -0,0 +1,25 @@
+export const editorCopy = {
+    labels: {
+        control: 'Original',
+        variantA: 'Variant A',
+        variantB: 'Variant B',
+        variantC: 'Variant C'
+    },
+    unbound: 'Choose or create an experiment to show different versions.',
+    draft: 'This block shows the Original to everyone until the experiment starts.',
+    running: 'Changing this content mid-test mixes two versions in one result',
+    decided: (winner)=>`Decided: ${winner}. Use 'Make it the content' on the experiment to finish.`,
+    archived: 'This experiment is archived; the winning content is shown to everyone.',
+    copy: (label)=>`Copy Original → ${label}`,
+    replaceConfirm: (label)=>`${label} already has content. Replace it with a copy of the Original?`,
+    replace: 'Replace',
+    createLabel: 'Create experiment',
+    creating: 'Creating…',
+    cancel: 'Cancel',
+    name: 'Name',
+    slug: 'Slug',
+    createError: "Couldn't create the experiment. Try again.",
+    loading: 'Loading experiment…',
+    loadError: "Couldn't load this experiment. Try selecting it again.",
+    tabs: 'Experiment versions'
+};

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

@@ -0,0 +1,16 @@
+import type { Arm, Status } from '../../types/contracts.js';
+import type { ArmSlot } from '../../types/puck.js';
+export type EditorExperiment = {
+    name: string;
+    status: Status;
+    arms: Array<Pick<Arm, 'key' | 'kind' | 'label'>>;
+    decision?: {
+        winnerArm?: string;
+    } | null;
+};
+export declare function tabsFor(experiment?: Pick<EditorExperiment, 'arms'> | null): Array<{
+    slot: ArmSlot;
+    label: string;
+}>;
+export declare function bannerFor(status?: Status | null, winner?: string): string;
+export declare function slugify(name: string): string;

package/dist/puck/editor/editor.model.js

@@ -0,0 +1,33 @@
+import { editorCopy } from './copy.js';
+export function tabsFor(experiment) {
+    if (!experiment) return [
+        {
+            slot: 'control',
+            label: editorCopy.labels.control
+        }
+    ];
+    return experiment.arms.flatMap((arm)=>arm.kind === 'holdout' || arm.key === 'holdout' ? [] : [
+            {
+                slot: arm.key,
+                label: arm.label?.trim() ? arm.label : editorCopy.labels[arm.key]
+            }
+        ]);
+}
+export function bannerFor(status, winner = editorCopy.labels.control) {
+    switch(status){
+        case 'draft':
+        case 'stopped':
+            return editorCopy.draft;
+        case 'running':
+            return editorCopy.running;
+        case 'decided':
+            return editorCopy.decided(winner);
+        case 'archived':
+            return editorCopy.archived;
+        default:
+            return editorCopy.unbound;
+    }
+}
+export function slugify(name) {
+    return name.normalize('NFKD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64).replace(/-+$/g, '');
+}

package/dist/puck/experimentSlotField.d.ts

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

package/dist/puck/experimentSlotField.js

@@ -0,0 +1,13 @@
+import { createElement } from 'react';
+import { ExperimentPicker } from './ExperimentPicker.js';
+import { pickerCopy } from './copy.js';
+export function createExperimentSlotField(opts) {
+    return {
+        type: 'custom',
+        label: opts?.label ?? pickerCopy.label,
+        render: ({ value, onChange })=>createElement(ExperimentPicker, {
+                value,
+                onChange
+            })
+    };
+}

package/dist/puck/slot.model.d.ts

@@ -0,0 +1,2 @@
+import type { ArmSlot, ExperimentSlotProps } from '../types/puck.js';
+export declare function slotToRender(props: Pick<ExperimentSlotProps, 'xpSlot'>): ArmSlot;

package/dist/puck/slot.model.js

@@ -0,0 +1,11 @@
+export function slotToRender(props) {
+    switch(props.xpSlot){
+        case 'control':
+        case 'variantA':
+        case 'variantB':
+        case 'variantC':
+            return props.xpSlot;
+        default:
+            return 'control';
+    }
+}

package/dist/puck/slotConfig.d.ts

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

package/dist/puck/slotConfig.js

@@ -0,0 +1,25 @@
+import { createExperimentSlotField } from './experimentSlotField.js';
+import { pickerCopy } from './copy.js';
+export const experimentSlotLabel = pickerCopy.label;
+export const experimentSlotFields = {
+    experiment: createExperimentSlotField(),
+    control: {
+        type: 'slot'
+    },
+    variantA: {
+        type: 'slot'
+    },
+    variantB: {
+        type: 'slot'
+    },
+    variantC: {
+        type: 'slot'
+    }
+};
+export const experimentSlotDefaultProps = {
+    experiment: null,
+    control: [],
+    variantA: [],
+    variantB: [],
+    variantC: []
+};

package/dist/results/aggregate.d.ts

@@ -0,0 +1,34 @@
+export type Timestamp = Date | string | number;
+export interface ExposedUnit {
+    arm: string;
+    firstTs: Timestamp;
+}
+export interface MetricEvent {
+    unitId: string;
+    value: number;
+    ts: Timestamp;
+}
+/** Accept Date, timestamp text, or epoch milliseconds; reject invalid dates. */
+export declare function timestampMs(ts: Timestamp): number;
+/** Attribution windows must have a finite, positive length in hours. */
+export declare function windowMs(windowHours: number): number;
+/** Spec §7.6/§8.2: first exposure in a phase, excluding units seen in multiple arms. */
+export declare function firstExposures(rows: readonly {
+    unitId: string;
+    arm: string;
+    ts: Timestamp;
+}[], { endedAt }?: {
+    endedAt?: Timestamp;
+}): {
+    units: Map<string, {
+        arm: string;
+        firstTs: Date;
+    }>;
+    excludedMultiArm: number;
+};
+/** Spec §7.6/§8.2: zero-filled outcomes over each exposed unit's half-open window. */
+export declare function perUnitValues(units: ReadonlyMap<string, ExposedUnit>, events: readonly MetricEvent[], { kind, windowHours, endedAt }: {
+    kind: 'binomial' | 'count' | 'revenue';
+    windowHours: number;
+    endedAt?: Timestamp;
+}): Map<string, number>;

package/dist/results/aggregate.js

@@ -0,0 +1,66 @@
+/** Accept Date, timestamp text, or epoch milliseconds; reject invalid dates. */ export function timestampMs(ts) {
+    if (!(ts instanceof Date) && typeof ts !== 'string' && typeof ts !== 'number') {
+        throw new RangeError('Invalid timestamp');
+    }
+    const ms = ts instanceof Date ? ts.getTime() : new Date(ts).getTime();
+    if (!Number.isFinite(ms)) throw new RangeError('Invalid timestamp');
+    return ms;
+}
+/** Attribution windows must have a finite, positive length in hours. */ export function windowMs(windowHours) {
+    if (!Number.isFinite(windowHours) || windowHours <= 0) {
+        throw new RangeError('windowHours must be a finite number greater than 0');
+    }
+    return windowHours * 3_600_000;
+}
+/** Spec §7.6/§8.2: first exposure in a phase, excluding units seen in multiple arms. */ export function firstExposures(rows, { endedAt } = {}) {
+    const first = new Map();
+    const excluded = new Set();
+    const end = endedAt === undefined ? Infinity : timestampMs(endedAt);
+    for (const row of rows){
+        const ts = timestampMs(row.ts);
+        if (ts >= end || excluded.has(row.unitId)) continue;
+        const unit = first.get(row.unitId);
+        if (!unit) first.set(row.unitId, {
+            arm: row.arm,
+            firstTs: ts
+        });
+        else if (unit.arm !== row.arm) {
+            first.delete(row.unitId);
+            excluded.add(row.unitId);
+        } else if (ts < unit.firstTs) {
+            first.set(row.unitId, {
+                arm: row.arm,
+                firstTs: ts
+            });
+        }
+    }
+    const units = new Map();
+    for (const [unitId, unit] of first){
+        units.set(unitId, {
+            arm: unit.arm,
+            firstTs: new Date(unit.firstTs)
+        });
+    }
+    return {
+        units,
+        excludedMultiArm: excluded.size
+    };
+}
+/** Spec §7.6/§8.2: zero-filled outcomes over each exposed unit's half-open window. */ export function perUnitValues(units, events, { kind, windowHours, endedAt }) {
+    const values = new Map();
+    const starts = new Map();
+    const duration = windowMs(windowHours);
+    const phaseEnd = endedAt === undefined ? Infinity : timestampMs(endedAt);
+    for (const [unitId, unit] of units){
+        starts.set(unitId, timestampMs(unit.firstTs));
+        values.set(unitId, 0);
+    }
+    for (const event of events){
+        const ts = timestampMs(event.ts);
+        const start = starts.get(event.unitId);
+        if (start === undefined) continue;
+        if (ts < start || ts >= Math.min(start + duration, phaseEnd)) continue;
+        values.set(event.unitId, kind === 'binomial' ? 1 : values.get(event.unitId) + (kind === 'count' ? 1 : event.value));
+    }
+    return values;
+}

package/dist/results/analyse.d.ts

@@ -0,0 +1,79 @@
+import type { GaussianPrior } from '@delmaredigital/experiments-stats';
+import type { Arm, DocId, MetricSource } from '../types/contracts.js';
+import type { Snapshot } from '../types/snapshot.js';
+import type { ExposedUnit, Timestamp } from './aggregate.js';
+export interface FrozenMetric {
+    metricId: DocId;
+    name: string;
+    kind: MetricSource['kind'];
+    role: 'primary' | 'secondary' | 'guardrail';
+    direction: 'increase' | 'decrease';
+    attributionWindowHours: number;
+    minSampleSize: number;
+    guardrailThreshold?: number;
+    capping?: {
+        type: 'percentile' | 'absolute';
+        value: number;
+    };
+    resolvedCap?: number | null;
+    historyUnits?: number;
+}
+/** The caller decodes the phase JSON into this shape. No live metric or experiment
+ * settings are read by analysis. Rollout arms carry weights {100-h,h} and include
+ * only the shipped arm and holdout; units have already passed rolloutAnalysisUnits.
+ */
+export interface AnalysisPhase {
+    experiment: DocId;
+    phase: number;
+    phaseKind: 'test' | 'rollout';
+    startedAt: Timestamp;
+    endedAt?: Timestamp | null;
+    arms: readonly Pick<Arm, 'key' | 'label' | 'kind' | 'weight'>[];
+    metricDefinitions: readonly FrozenMetric[];
+    analysis: {
+        method: 'sequential' | 'bayesian';
+        alpha?: number;
+        sequentialTuningParameter: number;
+        cuped: 'auto' | 'off';
+        cupedLookbackDays?: number;
+        minExposuresPerArm: number;
+        plannedDurationDays: number;
+        attributionWindowHours?: number;
+        minSampleSizes?: Record<DocId, number>;
+        guardrailThresholds?: Record<DocId, number>;
+        prior?: GaussianPrior;
+        bayesian?: {
+            ctw: number;
+            risk: number;
+        };
+    };
+    contentChanges?: Snapshot['contentChanges'];
+}
+export interface MetricUnitData {
+    metricId: DocId;
+    /** CORE-14a perUnitValues output, zero-filled over exposed units only. */
+    values: ReadonlyMap<string, number>;
+    /** Host pre-period outcomes; absent entries in a supplied map mean zero. */
+    covariates?: ReadonlyMap<string, number>;
+    unavailable?: string;
+}
+export type AnalysePhaseInput = {
+    phase: AnalysisPhase;
+    status: 'running' | 'stopped' | 'decided';
+    now: Timestamp;
+    /** CORE-14a firstExposures output; same-unit multi-arm units already excluded. */
+    units: ReadonlyMap<string, ExposedUnit>;
+    metricData: readonly MetricUnitData[];
+    excludedMultiArm?: number;
+    armMismatch?: number;
+    /** Diagnostic from identity credit, supplied by the caller with its denominator. */
+    identityConflictShare?: number;
+} & ({
+    winnerArm?: never;
+} | {
+    winnerArm: string;
+});
+/** Pure exposure-based analysis (§6, §7.6, §8.4). All inference, moments, capping,
+ * CUPED, power and SRM are delegated to experiments-stats; now is always injected.
+ */
+export declare function analysePhase(input: AnalysePhaseInput): Snapshot;