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

package/dist/transitions/preflightData.js

@@ -1,4 +1,9 @@
+import { goalContent, OUTSIDE_GOAL } from '../goals/fairness.js';
+import { placementInteractions, placementPaths, uniquePlacementDocs } from './placementInteractions.js';
 import { Forbidden, NotFound } from 'payload';
+import { normalisePath } from '../runtime/normalisePath.js';
+import { resolvePageCollection } from './pageCollection.js';
+import { identicalPageVersions } from './pageVersions.js';
 import { safeError } from '../log.js';
 import { powerMetricWeeks } from '@delmaredigital/experiments-stats';
 import { checkStart, relationshipId } from './checkStart.js';
@@ -35,13 +40,18 @@ const failureDetail = (cause)=>{
     return routedPageTests(await req.transactionID != null ? txExecutor(req) : pooledExecutor(req.payload));
 }
 /** Page targets no registered collection reports as published. A lookup that throws counts as
- * unpublished (logged). Start calls it again under its page-path locks on a detached request. */ export async function unpublishedPageTargets(req, options, experiment) {
+ * unpublished (logged) unless propagateErrors is requested by decide. Start calls it again under its page-path locks on a detached request. */ export async function unpublishedPageTargets(req, options, experiment, propagateErrors = false) {
+    const resolved = await resolvePageCollection(req, options, experiment, propagateErrors);
+    const collections = resolved ? [
+        resolved
+    ] : [];
     const targets = await Promise.all(experiment.arms.filter((arm)=>arm.kind !== 'holdout' && arm.pageTarget?.trim()).map(async (arm)=>{
-        for (const collection of options.pages?.collections ?? []){
+        for (const collection of collections){
             try {
                 const page = await collection.findByPath(arm.pageTarget, req);
                 if (page?.published === true) return null;
             } catch (cause) {
+                if (propagateErrors) throw cause;
                 req.payload.logger.error({
                     err: safeError(cause),
                     experimentId: experiment.id,
@@ -114,13 +124,19 @@ const metricIds = (experiment)=>[
                 pageTestsInUse ??= loadPageTestsInUse(req);
                 input.pageTestsInUse = await pageTestsInUse;
                 input.pageTargetsUnchecked = options.pages === undefined;
-                if (options.pages) input.unpublishedPageTargets = await unpublishedPageTargets(req, options, experiment);
+                input.unknownPageCollection = Boolean(experiment.pageCollection && !options.pages?.collections.some((entry)=>entry.slug === experiment.pageCollection));
+                if (options.pages) {
+                    input.unpublishedPageTargets = await unpublishedPageTargets(req, options, experiment);
+                    if (options.pages.collections.some((entry)=>entry.contentOf)) input.identicalVersions = await identicalPageVersions(req, await resolvePageCollection(req, options, experiment), experiment.arms);
+                }
             }
             if (experiment.kind === 'block') {
                 try {
                     blocks ??= scanBlockPlacements(req, {
                         slugs: blockSlugs,
-                        puckCollections: options.puck?.collections ?? []
+                        compareVersions: true,
+                        puckCollections: options.puck?.collections ?? [],
+                        blocksCollections: options.blocks?.collections ?? []
                     });
                     input.placements = (await blocks).get(experiment.slug) ?? [];
                 } catch (cause) {
@@ -250,6 +266,13 @@ const metricIds = (experiment)=>[
                 })());
                 input.layer = await layers.get(key);
             }
+            if ((experiment.kind === 'page' || experiment.kind === 'block') && options.pages?.collections.length) {
+                const paths = experiment.kind === 'page' ? experiment.arms.flatMap((a)=>typeof a.pageTarget === 'string' ? [
+                        a.pageTarget
+                    ] : []) : await placementPaths(req, options, uniquePlacementDocs(input.placements ?? []));
+                input.interactions = await placementInteractions(req, await req.transactionID != null ? txExecutor(req) : pooledExecutor(req.payload), options, experiment, paths.map(normalisePath));
+            }
+            if (input.metrics.some((metric)=>metric.source.startsWith('click:'))) input.goalContent = await goalContent(req, options, experiment, input.placements ? uniquePlacementDocs(input.placements.filter((placement)=>placement.published)) : undefined);
             inputs.set(String(experiment.id), input);
         } catch (cause) {
             if (!tolerateErrors) throw cause;
@@ -279,7 +302,9 @@ async function placementUrls(options, placement, pendingPreviews, onFailure, pre
         const url = options.admin?.editorUrl?.({
             collection,
             id,
-            draft: !published
+            draft: !published,
+            editor: placement.editor ?? 'puck',
+            doc: placement.doc
         });
         if (typeof url === 'string') result.editorUrl = url;
     } catch  {}
@@ -476,9 +501,116 @@ export async function preflightData(req, { experimentId, options }, { now = new
             detail: placement.detail
         } : {}
     });
+    const pagePlacements = [];
+    if (e.kind === 'page') {
+        const collection = await resolvePageCollection(req, options, e);
+        for (const arm of e.arms.filter((arm)=>arm.kind !== 'holdout')){
+            const path = arm.pageTarget ?? '';
+            let page = null;
+            try {
+                page = path && collection ? await collection.findByPath(path, req) : null;
+            } catch (cause) {
+                onPreviewFailure(cause, {
+                    collection: collection.slug,
+                    id: path,
+                    title: path,
+                    published: false,
+                    slots: {
+                        control: 0,
+                        variantA: 0,
+                        variantB: 0,
+                        variantC: 0
+                    }
+                });
+            }
+            if (!page || !collection) {
+                pagePlacements.push({
+                    arm: arm.key,
+                    path,
+                    published: false,
+                    id: null,
+                    ...collection ? {
+                        collection: collection.slug
+                    } : {}
+                });
+                continue;
+            }
+            let doc;
+            try {
+                doc = await req.payload.findByID({
+                    collection: collection.slug,
+                    id: page.id,
+                    req,
+                    overrideAccess: false,
+                    depth: 0,
+                    draft: !page.published
+                });
+            } catch (cause) {
+                onPreviewFailure(cause, {
+                    collection: collection.slug,
+                    id: page.id,
+                    title: path,
+                    published: false,
+                    slots: {
+                        control: 0,
+                        variantA: 0,
+                        variantB: 0,
+                        variantC: 0
+                    }
+                });
+                pagePlacements.push({
+                    arm: arm.key,
+                    path,
+                    collection: collection.slug,
+                    published: false,
+                    id: null
+                });
+                continue;
+            }
+            const titleField = req.payload.config.collections?.find((entry)=>entry.slug === collection.slug)?.admin.useAsTitle ?? 'title';
+            const placement = {
+                collection: collection.slug,
+                id: page.id,
+                title: String(doc[titleField] ?? doc.id),
+                published: page.published,
+                ...page.published && typeof doc.slug === 'string' ? {
+                    slug: doc.slug
+                } : {},
+                slots: {
+                    control: 0,
+                    variantA: 0,
+                    variantB: 0,
+                    variantC: 0
+                },
+                editor: 'page',
+                doc
+            };
+            pagePlacements.push({
+                arm: arm.key,
+                path,
+                collection: collection.slug,
+                id: page.id,
+                title: placement.title,
+                published: placement.published,
+                ...placement.slug ? {
+                    slug: placement.slug
+                } : {},
+                ...await placementUrls(options, placement, pendingPreviews, onPreviewFailure, previews)
+            });
+        }
+    }
     return {
         checks: checkStart(input),
+        ...input.goalContent ? {
+            goalNotes: input.metrics.filter((m)=>m.source.startsWith('click:') && input.goalContent && !input.goalContent.skipped && !input.goalContent.unchecked.length && !input.goalContent.keys.some((k)=>`click:${k.key}` === m.source)).map((m)=>({
+                    metricId: m.id,
+                    message: OUTSIDE_GOAL
+                }))
+        } : {},
         placements,
+        ...e.kind === 'page' ? {
+            pagePlacements
+        } : {},
         baseline,
         trafficPerDay,
         estimate: power

package/dist/transitions/resolveCaps.d.ts

@@ -2,6 +2,7 @@ import type { DocId, MetricSource } from '../types/contracts.js';
 export interface MetricDefinition extends Record<string, unknown> {
     id: DocId;
     source: string;
+    direction?: 'increase' | 'decrease';
     attributionWindowHours?: number | null;
     minSampleSize?: number | null;
     guardrailThreshold?: number | null;

package/dist/transitions/resolveCaps.js

@@ -8,7 +8,7 @@ import { perUnitHistory } from '../results/history.js';
     const from = new Date(start.getTime() - 90 * 86400000);
     for (const metric of metrics){
         const source = sources.find((source)=>source.id === metric.source);
-        const kind = metric.source.startsWith('events:') ? 'binomial' : source?.kind;
+        const kind = metric.source.startsWith('events:') || metric.source.startsWith('click:') ? 'binomial' : source?.kind;
         const definition = {
             ...structuredClone(metric),
             ...source ? {
@@ -19,11 +19,15 @@ import { perUnitHistory } from '../results/history.js';
             historyUnits: undefined,
             capNotice: undefined
         };
+        if (metric.source.startsWith('click:')) {
+            definition.direction = 'increase';
+            definition.capping = null;
+        }
         const cap = metric.capping?.type ? metric.capping : kind === 'revenue' ? {
             type: 'percentile',
             value: 0.99
         } : null;
-        if (kind === 'revenue' || !source && cap && !metric.source.startsWith('events:')) {
+        if (kind === 'revenue' || !source && cap && !(metric.source.startsWith('events:') || metric.source.startsWith('click:'))) {
             definition.capping = cap;
             if (cap?.type === 'absolute' && typeof cap.value === 'number' && Number.isFinite(cap.value) && cap.value >= 0) {
                 definition.resolvedCap = cap.value;

package/dist/transitions/start.js

@@ -1,8 +1,12 @@
+import { goalContent } from '../goals/fairness.js';
+import { detached } from './placementInteractions.js';
+import { lockAndRescanPlacements, placementInteractions } from './placementInteractions.js';
 import { lockPagePaths } from '../db/locks.js';
 import { lockMetricsForFreeze } from '../db/metricUsage.js';
 import { DEFAULT_SEQUENTIAL_TUNING_PARAMETER } from '../constants.js';
 import { claimSlices } from '../db/slices.js';
-import { pageInUseCopy, unpublishedPageCopy } from '../admin/copy/readiness.js';
+import { asymmetricGoalsCopy, sameAddressCopy, interactingTestsCopy, pageInUseCopy, unpublishedPageCopy } from '../admin/copy/readiness.js';
+import { GROUP_LABELS } from '../admin/copy/arms.js';
 import { XpRefusal } from '../errors.js';
 import { isOpValid } from '../targeting/ops.js';
 import { newSeed } from '../runtime/seed.js';
@@ -31,7 +35,19 @@ export async function readExperiment(req, id) {
 }
 export function refuse(code, detail) {
     const messages = {
+        'goal-in-some-versions': asymmetricGoalsCopy(detail),
+        'placements-changed': "This test's pages changed while it was starting. Try again.",
+        'page-busy': "One of this test's pages is being saved right now. Try again in a moment.",
+        'interacting-tests': (()=>{
+            const d = detail?.[0];
+            return d ? interactingTestsCopy(d.path, d.status, d.name, d.version) : 'Finish one of the tests first.';
+        })(),
+        'unknown-collection': "That page type isn't set up for tests.",
         'page-in-use': pageInUseCopy(detail?.paths?.[0] ?? 'this page'),
+        'version-same-address': (()=>{
+            const d = detail;
+            return sameAddressCopy(GROUP_LABELS[d?.arm ?? 'variantA'], GROUP_LABELS[d?.otherArm ?? 'control'], d?.path ?? 'this address');
+        })(),
         'page-target-unpublished': unpublishedPageCopy(typeof detail === 'string' ? detail : 'This page'),
         'invalid-status': 'This action is not available in the current status.',
         'stale-draft': 'The experiment changed. Review it again before starting.',
@@ -46,6 +62,9 @@ export function refuse(code, detail) {
         'entry-not-dismissed': 'That page is not dismissed.'
     };
     const conflict = [
+        'page-busy',
+        'placements-changed',
+        'interacting-tests',
         'invalid-status',
         'stale-draft',
         'page-in-use',
@@ -110,6 +129,17 @@ export async function start(req, { experimentId, options }) {
         const current = await readExperiment(req, experimentId);
         if (current.updatedAt !== updatedAt) refuse('stale-draft');
         if (current.status !== 'draft' && current.status !== 'stopped') refuse('invalid-status');
+        let placementDocs;
+        if (current.kind === 'block') {
+            const rescan = await lockAndRescanPlacements(req, exec, options, current, input.placements ?? []);
+            placementDocs = rescan.docs;
+            const failure = checkStart({
+                ...input,
+                experiment: current,
+                placements: rescan.placements
+            }).find((check)=>!check.ok);
+            if (failure && failure.code !== 'page-targets-unchecked' && failure.code !== 'make-content-unsupported') refuse(failure.code, failure.detail);
+        }
         if (current.kind === 'page') {
             // Independent experiment/layer locks do not serialize overlapping pages.
             // Re-read occupancy after acquiring sorted path locks; hold through commit.
@@ -121,6 +151,8 @@ export async function start(req, { experimentId, options }) {
                 pageTestsInUse: await loadPageTestsInUse(req)
             }).find((check)=>check.code === 'page-in-use' && !check.ok);
             if (recheck) refuse('page-in-use', recheck.detail);
+            const conflicts = await placementInteractions(req, exec, options, current, pageTargetPaths(current.arms));
+            if (conflicts.length) refuse('interacting-tests', conflicts);
             if (options.pages) {
                 // The page guard takes the same path locks, so a delete, unpublish or rename that committed
                 // while Start waited is visible now. Read it on a detached request (committed state, outside
@@ -181,6 +213,15 @@ export async function start(req, { experimentId, options }) {
             }).find((check)=>!check.ok);
             if (recheck && recheck.code !== 'page-targets-unchecked' && recheck.code !== 'make-content-unsupported') refuse(recheck.code, recheck.detail);
         }
+        if (input.metrics.some((metric)=>metric.source.startsWith('click:'))) {
+            const content = await detached(req, ()=>goalContent(req, options, current, placementDocs));
+            const failure = checkStart({
+                ...input,
+                experiment: current,
+                goalContent: content
+            }).find((check)=>check.code === 'goal-in-some-versions' && !check.ok);
+            if (failure) refuse('goal-in-some-versions', failure.detail);
+        }
         const lockedMetrics = await lockMetricsForFreeze(exec, caps.definitions.map((metric)=>metric.id));
         if (!lockedMetrics) {
             throw new XpRefusal('stale-draft', 'A goal in this test was deleted. Review the goals before starting.', undefined, 409);
@@ -233,6 +274,9 @@ export async function start(req, { experimentId, options }) {
             allocationChanges: [],
             targeting,
             metricDefinitions: definitions,
+            ...placementDocs ? {
+                placementDocs
+            } : {},
             analysis: {
                 ...current.analysis,
                 method: current.analysis?.method ?? 'sequential',

package/dist/types/admin.d.ts

@@ -18,4 +18,4 @@ export type SerializedAttributeKeys = Record<string, {
     type: 'string' | 'number' | 'boolean';
     values?: string[];
 }>;
-export type EditableField = 'name' | 'hypothesis' | 'arms' | 'targeting' | 'allocation' | 'flagPoint' | 'metrics' | 'analysis' | 'exposurePolicy';
+export type EditableField = 'name' | 'hypothesis' | 'arms' | 'targeting' | 'allocation' | 'flagPoint' | 'metrics' | 'analysis' | 'exposurePolicy' | 'pageCollection';

package/dist/types/assignments.d.ts

@@ -32,6 +32,7 @@ export interface FlagPointResult {
     exposable: boolean;
 }
 export interface ClientAssignments {
+    clickGoalsArmed?: boolean;
     v: 1;
     revision: number;
     apiRoute: string;

package/dist/types/contracts.d.ts

@@ -103,6 +103,10 @@ export type ExperimentsAccess = (args: {
 }) => boolean | Promise<boolean>;
 export interface ExperimentsPageCollection {
     slug: string;
+    contentOf?: (doc: Record<string, unknown>) => unknown;
+    copyHint?: string;
+    copyUrl?: string;
+    copyLabel?: string;
     pathOf: (doc: Record<string, unknown>) => string | null;
     /** Lookup with the supplied req and overrideAccess: false. Under an anonymous req (results checks) only published pages are visible, so a hit is { published: true } or null. Under a req that can read drafts (Start), a draft-only page may be reported as { published: false }. */
     findByPath: (path: string, req: PayloadRequest) => Promise<{
@@ -130,9 +134,12 @@ export interface ExperimentsPluginOptions<TUser extends {
             collection: string;
             id: DocId;
             draft?: boolean;
+            editor: 'puck' | 'blocks' | 'page';
+            doc?: Record<string, unknown>;
         }) => string;
         previewUrl?: (placement: PreviewPlacement) => string | null | undefined | Promise<string | null | undefined>;
         descriptions?: {
+            page?: string;
             block?: string;
             document?: string;
             setting?: string;
@@ -151,6 +158,14 @@ export interface ExperimentsPluginOptions<TUser extends {
     pages?: {
         collections: ExperimentsPageCollection[];
     };
+    blocks?: {
+        collections: Array<{
+            slug: string;
+            field: string;
+            blockSlug?: string;
+            appliesTo?: (doc: Record<string, unknown>) => boolean;
+        }>;
+    };
     puck?: {
         enabled: boolean;
         collections: Array<string | {

package/dist/types/endpoints.d.ts

@@ -7,7 +7,7 @@ import type { Snapshot, VerdictCode } from './snapshot.js';
 export type ArmIssueCode = 'weights-total' | 'control-count' | 'control-first' | 'holdout-last' | 'holdout-count' | 'variant-count' | 'duplicate-key' | 'duplicate-slot' | 'slot-required' | 'invalid-key';
 /** Content-report dismiss/restore refusals (CORE-44). */
 export type ContentEntryRefusal = 'not-decided' | 'entry-not-found' | 'entry-ok' | 'entry-dismissed' | 'entry-not-dismissed';
-export type RefusalCode = ArmIssueCode | 'not-found' | ContentEntryRefusal | 'no-planned-duration' | 'no-primary-metric' | 'no-placements' | 'empty-slot' | 'page-in-use' | 'page-no-targets' | 'page-target-unpublished' | 'page-user-unit' | 'version-page-unavailable' | 'version-page-unchecked' | 'flag-no-point' | 'flag-params-invalid' | 'flag-point-busy' | 'flag-placement-missing' | 'layer-full' | 'layer-unit-mismatch' | 'unknown-metric-source' | 'unit-source-mismatch' | 'no-reach-per-day' | 'invalid-status' | 'stale-draft' | 'stale-edit' | 'commit-unverified' | 'allocation-lower' | 'confirmation-required' | 'invalid-winner' | 'slices-taken' | 'locked-placement' | 'not-implemented' | 'forbidden' | 'unauthenticated' | 'body-too-large' | 'invalid-body' | 'too-many-ids' | 'invalid-phase' | 'invalid-ids' | 'recompute-failed' | 'analysis-failed' | 'undeclared-targeting-key' | 'invalid-targeting-rule' | 'block-path-rule' | 'duplicate-metric';
+export type RefusalCode = ArmIssueCode | 'goal-in-some-versions' | 'placement-unchecked' | 'placement-unpublished' | 'duplicate-version-row' | 'interacting-tests' | 'placements-changed' | 'page-busy' | 'wrap-target-missing' | 'version-identical' | 'version-same-address' | 'unknown-collection' | 'not-found' | ContentEntryRefusal | 'no-planned-duration' | 'no-primary-metric' | 'no-placements' | 'empty-slot' | 'page-in-use' | 'page-no-targets' | 'page-target-unpublished' | 'page-user-unit' | 'version-page-unavailable' | 'version-page-unchecked' | 'flag-no-point' | 'flag-params-invalid' | 'flag-point-busy' | 'flag-placement-missing' | 'layer-full' | 'layer-unit-mismatch' | 'unknown-metric-source' | 'unit-source-mismatch' | 'no-reach-per-day' | 'invalid-status' | 'stale-draft' | 'stale-edit' | 'commit-unverified' | 'allocation-lower' | 'confirmation-required' | 'invalid-winner' | 'slices-taken' | 'locked-placement' | 'not-implemented' | 'forbidden' | 'unauthenticated' | 'body-too-large' | 'invalid-body' | 'too-many-ids' | 'invalid-phase' | 'invalid-ids' | 'recompute-failed' | 'analysis-failed' | 'undeclared-targeting-key' | 'invalid-targeting-rule' | 'block-path-rule' | 'duplicate-metric';
 export type ErrorEnvelope = {
     errors: Array<{
         code: RefusalCode;
@@ -22,6 +22,13 @@ export type TransitionSuccess = {
 export type AllocateBody = {
     allocation: number;
 };
+export type AddMetricWarning = {
+    code: 'goal-in-some-versions' | 'goal-added-mid-test' | 'placement-unchecked';
+    detail?: unknown;
+};
+export type AddMetricResult = TransitionSuccess & {
+    warnings: AddMetricWarning[];
+};
 export type AddMetricBody = {
     metric: DocId;
     role: 'secondary' | 'guardrail';
@@ -57,12 +64,27 @@ export type MakeContentResult = TransitionSuccess & {
     }>;
 };
 export type PreflightResult = {
+    goalNotes?: Array<{
+        metricId: DocId;
+        message: string;
+    }>;
     checks: Array<{
         code: ReadinessCode;
         ok: boolean;
         detail?: unknown;
         warning?: boolean;
     }>;
+    pagePlacements?: Array<{
+        arm: string;
+        path: string;
+        collection?: string;
+        id?: DocId | null;
+        title?: string;
+        published: boolean;
+        slug?: string;
+        url?: string;
+        editorUrl?: string;
+    }>;
     placements: Array<{
         collection: string;
         id: DocId;
@@ -104,6 +126,7 @@ export interface PhaseSummary {
         name: string;
         kind: MetricSource['kind'];
         role: 'primary' | 'secondary' | 'guardrail';
+        clickGoal?: true;
         resolvedCap?: number | null;
         historyUnits?: number;
         capNotice?: 'no-history';
@@ -137,10 +160,7 @@ export type SummaryResponse = Record<DocId, {
         code: ReadinessCode;
         detail?: unknown;
     };
-    health?: Array<{
-        code: 'version-page-unavailable' | 'version-page-unchecked';
-        path: string;
-    }>;
+    health?: import('./snapshot.js').SnapshotHealth[];
     exposures: number;
     days: number;
     verdict: {
@@ -174,3 +194,70 @@ export type EndpointContext<TUser extends {
         visitorId: string;
     };
 };
+export type ClickKeysResult = {
+    keys: Array<{
+        key: string;
+        arms: string[];
+        label: string;
+    }>;
+};
+export type PagesResult = {
+    docs: Array<{
+        id: DocId;
+        title: string;
+        path: string | null;
+        pathKey: string | null;
+        published: boolean;
+    }>;
+    hasNextPage: boolean;
+};
+export type PlacementStatusBody = {
+    docs?: Array<{
+        collection: string;
+        id: DocId;
+    }>;
+    slugs?: string[];
+};
+export type PageTestStatus = {
+    slug: string;
+    name: string;
+    status: Status;
+    role: 'original' | 'version';
+    winner: boolean;
+    armLabel: string;
+    winnerLabel?: string;
+    winnerTitle?: string;
+    winnerPath?: string;
+    originalPath?: string;
+    rollout: boolean;
+    pagesReleased: boolean;
+};
+export type PlacementStatusResult = {
+    docs: Record<string, {
+        path: string | null;
+        tests: PageTestStatus[];
+    }>;
+    slugs: Record<string, {
+        missing: true;
+    } | {
+        deleted: true;
+    } | {
+        name: string;
+        status: Status;
+        kind: ExperimentKind;
+        arms: Array<{
+            key: string;
+            label: string;
+            slot?: string;
+        }>;
+        winnerArm?: string;
+        rollout: boolean;
+    }>;
+};
+export type WrapBlockBody = {
+    collection: string;
+    id: DocId;
+    field: string;
+    blockId: string;
+    experiment: string;
+};

package/dist/types/index.d.ts

@@ -7,3 +7,6 @@ export * from './admin.js';
 export * from './endpoints.js';
 export * from './snapshot.js';
 export * from './reasons.js';
+export type { HostBlock, ExperimentBlock, ExperimentBlockGroup, ResolvedHostBlock, ResolvedExperimentBlocks } from '../blocks/model.js';
+export type { WrapBlockBody } from './endpoints.js';
+export type { SnapshotHealth } from './snapshot.js';

package/dist/types/puck.d.ts

@@ -1,5 +1,5 @@
 import type { DocId } from './contracts.js';
-import type { Slot } from '@puckeditor/core';
+import type { ComponentConfig, Config, Plugin, Slot } from '@puckeditor/core';
 export type { Slot } from '@puckeditor/core';
 export type ArmSlot = 'control' | 'variantA' | 'variantB' | 'variantC';
 export type ExperimentRef = {
@@ -21,3 +21,9 @@ export type ExperimentSlotProps = {
     };
 };
 export declare const EXPERIMENT_SLOT_TYPE: "ExperimentSlot";
+export interface ExperimentsPuckIntegration {
+    name: string;
+    components: Record<string, ComponentConfig<ExperimentSlotProps>>;
+    categories: Config['categories'];
+    plugins?: readonly Plugin[];
+}

package/dist/types/snapshot.d.ts

@@ -1,3 +1,18 @@
+export type SnapshotHealth = {
+    code: 'version-page-unavailable' | 'version-page-unchecked';
+    path: string;
+} | {
+    code: 'goal-in-some-versions';
+    metricId: string | number;
+    name: string;
+} | {
+    code: 'placement-unchecked';
+    detail: {
+        collection?: string;
+        id?: string | number;
+        path?: string;
+    };
+};
 import type { GaussianPrior } from '@delmaredigital/experiments-stats';
 import type { DocId, MetricSource } from './contracts.js';
 import type { MetricUnavailableReason } from './reasons.js';
@@ -108,10 +123,8 @@ export interface Snapshot {
         guardrailLine?: string;
         worstArm?: string;
     };
-    health?: Array<{
-        code: 'version-page-unavailable' | 'version-page-unchecked';
-        path: string;
-    }>;
+    goalFairnessNotice?: string;
+    health?: SnapshotHealth[];
     contentChanges: Array<{
         at: string;
         doc: {

package/dist/types/surface.d.ts

@@ -7,6 +7,9 @@ export interface TestsSurfaceProps {
     returnToTest?: string;
     adminRoute: string;
     apiRoute: string;
+    collectionTitles?: Record<string, string>;
+    userId?: string | number;
+    userCollection?: string;
     isAdmin: boolean;
     pages?: Array<{
         collection: string;
@@ -14,6 +17,15 @@ export interface TestsSurfaceProps {
         id: DocId;
         title: string;
         editorUrl: string;
+        editor: 'puck' | 'blocks';
+    }>;
+    pageCollections?: Array<{
+        slug: string;
+        label: string;
+        contentChecks: boolean;
+        copyHint?: string;
+        copyUrl?: string;
+        copyLabel?: string;
     }>;
     canManage: boolean;
     canReadResults: boolean;
@@ -22,6 +34,7 @@ export interface TestsSurfaceProps {
     metricSources: SerializedMetricSource[];
     admin?: {
         descriptions?: {
+            page?: string;
             block?: string;
             document?: string;
             setting?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delmaredigital/payload-experiments",
-  "version": "0.3.0-rc.4",
+  "version": "0.4.0-rc.1",
   "description": "No-code A/B testing for Payload CMS and Next.js: block, page and flag experiments with holdouts, layers, exposure logging and honest statistics inside the admin — no vendor",
   "type": "module",
   "license": "MIT",
@@ -37,6 +37,12 @@
       "import": "./dist/exports/rsc.js",
       "default": "./dist/exports/rsc.js"
     },
+    "./blocks": {
+      "@delmaredigital/source": "./src/exports/blocks.ts",
+      "types": "./dist/exports/blocks.d.ts",
+      "import": "./dist/exports/blocks.js",
+      "default": "./dist/exports/blocks.js"
+    },
     "./client": {
       "@delmaredigital/source": "./src/exports/client.ts",
       "types": "./dist/exports/client.d.ts",
@@ -120,6 +126,7 @@
   },
   "homepage": "https://delmaredigital.com/developers",
   "devDependencies": {
+    "@delmaredigital/payload-puck": "0.10.3",
     "payload": "^3.90.2",
     "@payloadcms/db-postgres": "^3.90.2",
     "@payloadcms/ui": "^3.90.2",