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

package/dist/transitions/kernel.js

@@ -3,6 +3,7 @@ import { pooledExecutor, txExecutor } from '../db/executor.js';
 import { lockTransitionScope } from '../db/locks.js';
 import { currentTxid, txidStatus } from '../db/txid.js';
 import { contentChangeSavepoint } from '../db/appends.js';
+import { isPageBusy } from '../db/pageBusy.js';
 import { XpRefusal } from '../errors.js';
 import { buildAndStoreManifest } from '../manifest/compile.js';
 /** Runs transition writes on the request's transaction under ordered locks.
@@ -61,6 +62,9 @@ import { buildAndStoreManifest } from '../manifest/compile.js';
         };
     } catch (error) {
         if (!borrowedAudit) await killTransaction(req);
+        if (!scope.audit && isPageBusy(error)) throw new XpRefusal('page-busy', "One of this test's pages is being saved right now. Try again in a moment.", undefined, 409, {
+            cause: error
+        });
         throw error;
     } finally{
         if (hadTransition) req.context.xpTransition = previousTransition;

package/dist/transitions/makeContent.d.ts

@@ -10,6 +10,11 @@ type ContentDoc = {
     dismissedAt?: string;
     dismissedBy?: string | null;
 };
+/** Each placement commits independently while the outer transition retains its
+ * experiment locks. Keep the manager's exact req/user, temporarily lending it a
+ * fresh transaction; a denied host write must not kill the outer transaction.
+ */
+export declare function hostTransaction(req: PayloadRequest, experimentId: DocId, fn: () => Promise<void>): Promise<void>;
 export declare function makeContent<TUser extends {
     id: DocId;
 }>(req: PayloadRequest, { experimentId, options }: {

package/dist/transitions/makeContent.js

@@ -1,5 +1,7 @@
 import { Forbidden, NotFound, ValidationError, Locked, commitTransaction, initTransaction, killTransaction } from 'payload';
 import { latestDraftContent, publishedContent as readPublishedContent } from '../db/publishedContent.js';
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks, slotBlocks } from '../blocks/model.js';
+import { findRegisteredBlocksField, freshBlockIds } from '../blocks/formState.js';
 import { contentBlocks, hasLocalizedFields } from './contentFields.js';
 import { safeError } from '../log.js';
 import { XpRefusal } from '../errors.js';
@@ -7,7 +9,7 @@ import { lockContentDefaults } from '../db/appends.js';
 import { pooledExecutor, txExecutor } from '../db/executor.js';
 import { currentTxid, txidStatus } from '../db/txid.js';
 import { buildAndStoreManifest } from '../manifest/compile.js';
-import { puckCollections } from '../options.js';
+import { documentEditor, puckCollections } from '../options.js';
 import { contentDone } from '../contentDone.js';
 import { archive } from './archive.js';
 import { relationshipId } from './checkStart.js';
@@ -162,9 +164,14 @@ async function fieldRefusal(fields, req, doc, operation = 'update', data = doc,
 /** Each placement commits independently while the outer transition retains its
  * experiment locks. Keep the manager's exact req/user, temporarily lending it a
  * fresh transaction; a denied host write must not kill the outer transaction.
- */ async function hostTransaction(req, fn) {
+ */ export async function hostTransaction(req, experimentId, fn) {
     const transactionID = req.transactionID;
     const transition = req.context.xpTransition;
+    const hadHeld = Object.hasOwn(req.context, 'xpHeldExperiments');
+    const held = req.context.xpHeldExperiments;
+    req.context.xpHeldExperiments = [
+        experimentId
+    ];
     delete req.transactionID;
     delete req.context.xpTransition;
     try {
@@ -178,6 +185,8 @@ async function fieldRefusal(fields, req, doc, operation = 'update', data = doc,
         throw error;
     } finally{
         req.transactionID = transactionID;
+        if (hadHeld) req.context.xpHeldExperiments = held;
+        else delete req.context.xpHeldExperiments;
         if (transition === undefined) delete req.context.xpTransition;
         else req.context.xpTransition = transition;
     }
@@ -217,7 +226,7 @@ export async function makeContent(req, { experimentId, options }) {
             if (retainDismissed(collection, id)) return;
             let missing = false;
             try {
-                await hostTransaction(req, async ()=>{
+                await hostTransaction(req, experimentId, async ()=>{
                     try {
                         await fn();
                     } catch (error) {
@@ -264,7 +273,10 @@ export async function makeContent(req, { experimentId, options }) {
         };
         if (current.kind === 'block') {
             if (!winner.slot) refuse('invalid-winner');
-            const registrations = puckCollections(options);
+            const registrations = [
+                ...puckCollections(options),
+                ...options.blocks?.collections ?? []
+            ];
             const scanned = [];
             for (const registration of registrations){
                 const transactionID = req.transactionID;
@@ -272,9 +284,8 @@ export async function makeContent(req, { experimentId, options }) {
                 try {
                     scanned.push(...await scanBlockPlacements(req, {
                         slug: current.slug,
-                        puckCollections: [
-                            registration
-                        ]
+                        puckCollections: puckCollections(options).filter((r)=>r === registration),
+                        blocksCollections: (options.blocks?.collections ?? []).filter((r)=>r === registration)
                     }));
                 } catch (error) {
                     // A collection made unreadable since the last attempt still has
@@ -330,7 +341,7 @@ export async function makeContent(req, { experimentId, options }) {
                     let detail = isNotFound(error) ? 'forbidden' : contentFailureReason(error);
                     if (isNotFound(error)) {
                         try {
-                            await hostTransaction(req, async ()=>{
+                            await hostTransaction(req, experimentId, async ()=>{
                                 missing = !await readPublishedContent(req, collection, id);
                             });
                         } catch (checkError) {
@@ -367,7 +378,7 @@ export async function makeContent(req, { experimentId, options }) {
             for (const [key, { collection, id }] of placements){
                 if (skipped.has(key)) continue;
                 await attempt(collection, id, async ()=>{
-                    const field = registrations.find((entry)=>entry.slug === collection)?.field;
+                    let field = registrations.find((entry)=>entry.slug === collection)?.field;
                     if (!field) throw new Error('This content collection is no longer configured.');
                     const config = req.payload.config.collections.find((config)=>config.slug === collection);
                     if (hasLocalizedFields(config?.fields ?? [], req.payload.config)) throw new LocalizedContent();
@@ -382,10 +393,27 @@ export async function makeContent(req, { experimentId, options }) {
                     const drafts = Boolean(config?.versions && config.versions.drafts);
                     const published = await readPublishedContent(req, collection, id);
                     if (!published) throw new NotFound();
+                    const editor = documentEditor(options, collection, published);
+                    const blockRegistration = options.blocks?.collections.find((r)=>r.slug === collection);
+                    const contentField = editor === 'blocks' ? blockRegistration?.field : field;
+                    if (!contentField) throw new Error('This content field is no longer configured.');
+                    field = contentField;
+                    const transform = (value)=>editor === 'blocks' ? !hostBlocks(value).some((block)=>block.blockType === (blockRegistration?.blockSlug ?? EXPERIMENT_BLOCK_SLUG) && block.experiment === current.slug) ? value : hostBlocks(value).flatMap((block)=>{
+                            if (block.blockType !== (blockRegistration?.blockSlug ?? EXPERIMENT_BLOCK_SLUG) || block.experiment !== current.slug) return [
+                                block
+                            ];
+                            const rows = Array.isArray(block.slots) ? block.slots : [];
+                            if (!rows.some((row)=>row?.slot === winner.slot)) throw new Error('The winning content slot is missing.');
+                            const registered = findRegisteredBlocksField(config?.fields ?? [], field);
+                            if (!registered) throw new Error('This content field is no longer configured.');
+                            return slotBlocks(freshBlockIds([
+                                block
+                            ], registered.field, req.payload.config)[0], winner.slot);
+                        }) : unwrap(value, current.slug, winner.slot);
                     const draft = drafts ? await latestDraftContent(req, collection, id) ?? published : published;
                     const draftValue = draft[field] ?? null;
-                    const draftContent = unwrap(draftValue, current.slug, winner.slot);
-                    const publishedContent = unwrap(published[field], current.slug, winner.slot);
+                    const draftContent = transform(draftValue);
+                    const publishedContent = transform(published[field]);
                     const changedDraft = JSON.stringify(draftContent) !== JSON.stringify(draftValue);
                     const changedPublished = JSON.stringify(publishedContent) !== JSON.stringify(published[field]);
                     if (!changedDraft && !changedPublished) return;

package/dist/transitions/pageCollection.d.ts

@@ -0,0 +1,10 @@
+import type { PayloadRequest } from 'payload';
+import type { ExperimentsPageCollection, ResolvedOptions } from '../types/contracts.js';
+/** A stored collection is authoritative. Legacy tests fall back by the Original's path. */
+export declare function resolvePageCollection(req: PayloadRequest, options: Pick<ResolvedOptions, 'pages'>, experiment: {
+    pageCollection?: string | null;
+    arms: readonly {
+        kind?: string;
+        pageTarget?: string;
+    }[];
+}, propagateErrors?: boolean): Promise<ExperimentsPageCollection | undefined>;

package/dist/transitions/pageCollection.js

@@ -0,0 +1,20 @@
+import { safeError } from '../log.js';
+/** A stored collection is authoritative. Legacy tests fall back by the Original's path. */ export async function resolvePageCollection(req, options, experiment, propagateErrors = false) {
+    const collections = options.pages?.collections ?? [];
+    if (experiment.pageCollection) return collections.find((entry)=>entry.slug === experiment.pageCollection);
+    if (collections.length === 1) return collections[0];
+    const path = experiment.arms.find((arm)=>arm.kind === 'control')?.pageTarget;
+    if (!path) return undefined;
+    for (const entry of collections){
+        try {
+            if (await entry.findByPath(path, req)) return entry;
+        } catch (cause) {
+            if (propagateErrors) throw cause;
+            req.payload.logger.error({
+                err: safeError(cause),
+                collection: entry.slug
+            }, 'Experiment page lookup failed');
+        }
+    }
+    return undefined;
+}

package/dist/transitions/pageVersions.d.ts

@@ -0,0 +1,10 @@
+import type { PayloadRequest } from 'payload';
+import type { Arm, ExperimentsPageCollection } from '../types/contracts.js';
+/** Page copies have fresh nested row ids and editor labels; neither is rendered content. */
+export declare function comparableContent(value: unknown): unknown;
+export declare function identicalPageVersions(req: PayloadRequest, collection: ExperimentsPageCollection | undefined, arms: Arm[]): Promise<{
+    arm: import("../types/contracts.js").ArmKey;
+    path: string;
+    collection: string;
+    id: string | number;
+}[]>;

package/dist/transitions/pageVersions.js

@@ -0,0 +1,44 @@
+import { safeError } from '../log.js';
+import { isDeepStrictEqual } from 'node:util';
+import { pageVersionContent } from '../db/pageContent.js';
+/** Page copies have fresh nested row ids and editor labels; neither is rendered content. */ export function comparableContent(value) {
+    if (Array.isArray(value)) return value.map(comparableContent);
+    if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).filter(([key])=>key !== 'id' && key !== 'blockName').map(([key, nested])=>[
+            key,
+            comparableContent(nested)
+        ]));
+    return value;
+}
+export async function identicalPageVersions(req, collection, arms) {
+    if (!collection?.contentOf) return [];
+    const content = await Promise.all(arms.filter((arm)=>arm.kind !== 'holdout' && arm.pageTarget).map(async (arm)=>{
+        try {
+            const page = await collection.findByPath(arm.pageTarget, req);
+            if (!page?.published) return null;
+            const raw = await pageVersionContent(req, collection.slug, page.id);
+            if (!raw || raw._status === 'draft') return null;
+            return {
+                arm,
+                id: page.id,
+                value: comparableContent(collection.contentOf(raw))
+            };
+        } catch (cause) {
+            req.payload.logger.error({
+                err: safeError(cause),
+                collection: collection.slug,
+                id: arm.pageTarget
+            }, 'Experiment version comparison failed');
+            return null;
+        }
+    }));
+    const control = content.find((row)=>row?.arm.kind === 'control');
+    if (!control) return [];
+    return content.flatMap((row)=>row && row.arm.kind === 'variant' && isDeepStrictEqual(row.value, control.value) ? [
+            {
+                arm: row.arm.key,
+                path: row.arm.pageTarget,
+                collection: collection.slug,
+                id: row.id
+            }
+        ] : []);
+}

package/dist/transitions/phaseRecord.d.ts

@@ -16,6 +16,7 @@ export interface PhaseRecord {
     analysis?: Record<string, unknown> & {
         sequentialTuningParameter?: number | null;
     };
+    placementDocs?: import('../db/placements.js').PlacementDoc[] | null;
     contentChanges?: ContentChange[];
 }
 export declare function readPhaseRecord(req: PayloadRequest, experimentId: DocId, phase: number): Promise<PhaseRecord & {

package/dist/transitions/placementInteractions.d.ts

@@ -0,0 +1,40 @@
+import type { PayloadRequest } from 'payload';
+import type { Arm, DocId, ResolvedOptions } from '../types/contracts.js';
+import type { Executor } from '../db/executor.js';
+import { type PlacementDoc } from '../db/placements.js';
+import { type BlockPlacement } from './placements.js';
+export declare function detached<T>(req: PayloadRequest, fn: () => Promise<T>): Promise<T>;
+export declare function uniquePlacementDocs(placements: readonly Pick<BlockPlacement, 'collection' | 'id'>[]): PlacementDoc[];
+export declare function scanPlacements<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, options: ResolvedOptions<TUser>, slug: string): Promise<BlockPlacement[]>;
+export declare function placementPaths<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, options: ResolvedOptions<TUser>, docs: readonly PlacementDoc[]): Promise<string[]>;
+export interface InteractionDetail {
+    experimentId: DocId;
+    slug: string;
+    name: string;
+    status: string;
+    path: string;
+    version: boolean;
+}
+export declare function placementInteractions<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, exec: Executor, options: ResolvedOptions<TUser>, experiment: {
+    id: DocId;
+    kind: string;
+    arms: Arm[];
+    pageCollection?: string | null;
+}, paths: string[]): Promise<InteractionDetail[]>;
+export declare function lockAndRescanPlacements<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, exec: Executor, options: ResolvedOptions<TUser>, experiment: {
+    id: DocId;
+    slug: string;
+    kind: string;
+    arms: Arm[];
+}, before: readonly BlockPlacement[]): Promise<{
+    placements: BlockPlacement[];
+    docs: PlacementDoc[];
+}>;

package/dist/transitions/placementInteractions.js

@@ -0,0 +1,94 @@
+import { placementPathContent, placementTests } from '../db/placements.js';
+import { lockPagePaths } from '../db/locks.js';
+import { normalisePath } from '../runtime/normalisePath.js';
+import { scanBlockPlacements } from './placements.js';
+import { interactingTestsCopy } from '../admin/copy/readiness.js';
+import { XpRefusal } from '../errors.js';
+import { pageTargetPaths } from './checkStart.js';
+export async function detached(req, fn) {
+    const transactionID = req.transactionID;
+    delete req.transactionID;
+    try {
+        return await fn();
+    } finally{
+        req.transactionID = transactionID;
+    }
+}
+export function uniquePlacementDocs(placements) {
+    return [
+        ...new Map(placements.map((p)=>[
+                JSON.stringify([
+                    p.collection,
+                    String(p.id)
+                ]),
+                {
+                    collection: p.collection,
+                    id: p.id
+                }
+            ])).values()
+    ];
+}
+export function scanPlacements(req, options, slug) {
+    return scanBlockPlacements(req, {
+        slug,
+        puckCollections: options.puck?.collections ?? [],
+        blocksCollections: options.blocks?.collections ?? []
+    });
+}
+export async function placementPaths(req, options, docs) {
+    const paths = new Set();
+    for (const doc of docs){
+        const registration = options.pages?.collections.find((r)=>r.slug === doc.collection);
+        if (!registration) continue;
+        const row = await placementPathContent(req, doc.collection, doc.id);
+        if (!row || row._status === 'draft') continue;
+        const path = registration.pathOf(row);
+        if (path !== null) paths.add(normalisePath(path));
+    }
+    return [
+        ...paths
+    ].sort();
+}
+const active = (test)=>test.status === 'running' || test.status === 'decided';
+export async function placementInteractions(req, exec, options, experiment, paths) {
+    const result = [];
+    for (const test of (await placementTests(exec))){
+        if (!active(test) || String(test.id) === String(experiment.id)) continue;
+        if (experiment.kind === 'block' && test.kind === 'page') {
+            for (const path of paths.filter((path)=>pageTargetPaths(test.arms).includes(path)))result.push({
+                experimentId: test.id,
+                slug: test.slug,
+                name: test.name,
+                status: test.status,
+                path,
+                version: test.arms.some((a)=>a.kind === 'variant' && a.pageTarget && normalisePath(a.pageTarget) === path)
+            });
+        } else if (experiment.kind === 'page' && test.kind === 'block') {
+            const docs = test.placementDocs ?? uniquePlacementDocs(await detached(req, ()=>scanPlacements(req, options, test.slug)));
+            const relevant = docs.filter((doc)=>!experiment.pageCollection || doc.collection === experiment.pageCollection);
+            for (const path of (await placementPaths(req, options, relevant)).filter((path)=>paths.includes(path)))result.push({
+                experimentId: test.id,
+                slug: test.slug,
+                name: test.name,
+                status: test.status,
+                path,
+                version: experiment.arms.some((a)=>a.kind === 'variant' && a.pageTarget && normalisePath(a.pageTarget) === path)
+            });
+        }
+    }
+    return result;
+}
+export async function lockAndRescanPlacements(req, exec, options, experiment, before) {
+    const paths = await placementPaths(req, options, uniquePlacementDocs(before));
+    await lockPagePaths(exec, paths);
+    const placements = await detached(req, ()=>scanPlacements(req, options, experiment.slug));
+    const docs = uniquePlacementDocs(placements);
+    const afterPaths = await placementPaths(req, options, docs);
+    if (afterPaths.some((path)=>!paths.includes(path))) throw new XpRefusal('placements-changed', "This test's pages changed while it was starting. Try again.", undefined, 409);
+    const conflicts = await placementInteractions(req, exec, options, experiment, paths);
+    if (conflicts.length) throw new XpRefusal('interacting-tests', interactingTestsCopy(conflicts[0].path, conflicts[0].status, conflicts[0].name, conflicts[0].version), conflicts, 409);
+    return {
+        placements,
+        docs
+    };
+}

package/dist/transitions/placements.d.ts

@@ -2,7 +2,11 @@ import type { PayloadRequest } from 'payload';
 import type { Arm, DocId, FlagPoint, PreviewPlacement, ResolvedOptions } from '../types/contracts.js';
 import type { ArmSlot } from '../types/puck.js';
 export interface BlockPlacement extends PreviewPlacement {
+    editor?: 'puck' | 'blocks' | 'page';
+    doc?: Record<string, unknown>;
     slots: Record<ArmSlot, number>;
+    duplicateRows?: boolean;
+    identicalSlots?: string[];
     locked?: boolean;
     localized?: boolean;
 }
@@ -13,10 +17,14 @@ export type FlagPlacement = Awaited<ReturnType<NonNullable<FlagPoint['placements
 export declare function scanBlockPlacements(req: PayloadRequest, args: {
     slug: string;
     puckCollections: NonNullable<ResolvedOptions['puck']>['collections'];
+    blocksCollections: NonNullable<ResolvedOptions['blocks']>['collections'];
+    compareVersions?: boolean;
 }): Promise<BlockPlacement[]>;
 export declare function scanBlockPlacements(req: PayloadRequest, args: {
     slugs: ReadonlySet<string>;
     puckCollections: NonNullable<ResolvedOptions['puck']>['collections'];
+    blocksCollections: NonNullable<ResolvedOptions['blocks']>['collections'];
+    compareVersions?: boolean;
 }): Promise<Map<string, BlockPlacement[]>>;
 export declare function flagPlacements<TUser extends {
     id: DocId;

package/dist/transitions/placements.js

@@ -1,5 +1,10 @@
+import { BLOCK_SLOTS, EXPERIMENT_BLOCK_SLUG, hostBlocks, slotBlocks } from '../blocks/model.js';
+import { safeError } from '../log.js';
+import { pageVersionContent } from '../db/pageContent.js';
+import { comparableContent } from './pageVersions.js';
+import { isDeepStrictEqual } from 'node:util';
 import { hasLocalizedFields } from './contentFields.js';
-import { puckCollections as normalisePuckCollections } from '../options.js';
+import { documentEditor, puckCollections as normalisePuckCollections } from '../options.js';
 const slots = [
     'control',
     'variantA',
@@ -23,6 +28,7 @@ export async function scanBlockPlacements(req, args) {
             collections: puckCollections
         }
     })){
+        const editors = new Map();
         const publishedIds = new Set();
         const publishedSlugs = new Map();
         const draftsEnabled = req.payload.config.collections?.some((config)=>config.slug === collection && config.versions && config.versions.drafts);
@@ -53,9 +59,28 @@ export async function scanBlockPlacements(req, args) {
                     if (!draft && doc._status === 'draft') continue;
                     if (draft && doc._status !== 'draft' && publishedIds.has(String(doc.id))) continue;
                     if (!draft) {
+                        editors.set(String(doc.id), documentEditor({
+                            puck: {
+                                enabled: true,
+                                collections: puckCollections
+                            },
+                            blocks: {
+                                collections: args.blocksCollections
+                            }
+                        }, collection, doc));
                         publishedIds.add(String(doc.id));
                         if (typeof doc.slug === 'string') publishedSlugs.set(String(doc.id), doc.slug);
                     }
+                    const editor = editors.get(String(doc.id)) ?? documentEditor({
+                        puck: {
+                            enabled: true,
+                            collections: puckCollections
+                        },
+                        blocks: {
+                            collections: args.blocksCollections
+                        }
+                    }, collection, doc);
+                    if (editor !== 'puck') continue;
                     function walk(value) {
                         if (!value || typeof value !== 'object') return;
                         if (Array.isArray(value)) {
@@ -70,6 +95,8 @@ export async function scanBlockPlacements(req, args) {
                             placements.get(experiment).push({
                                 collection,
                                 id: doc.id,
+                                editor: 'puck',
+                                doc,
                                 title: String(doc.title ?? doc.name ?? doc.id),
                                 published: !draft || doc._status === 'published',
                                 ...publishedSlugs.has(String(doc.id)) ? {
@@ -87,7 +114,115 @@ export async function scanBlockPlacements(req, args) {
                         }
                         Object.values(node).forEach(walk);
                     }
+                    const offsets = new Map([
+                        ...placements
+                    ].map(([slug, list])=>[
+                            slug,
+                            list.length
+                        ]));
                     walk(doc[field]);
+                    if (args.compareVersions && !draft && [
+                        ...placements
+                    ].some(([slug, list])=>list.length > offsets.get(slug))) {
+                        const raw = await comparisonContent(req, collection, doc.id);
+                        const rawSlots = new Map();
+                        const collect = (value)=>{
+                            if (Array.isArray(value)) {
+                                value.forEach(collect);
+                                return;
+                            }
+                            if (!value || typeof value !== 'object') return;
+                            const node = value, props = node.props;
+                            const ref = props?.experiment;
+                            const slug = typeof ref === 'string' ? ref : ref && typeof ref === 'object' && 'slug' in ref ? ref.slug : undefined;
+                            if (node.type === 'ExperimentSlot' && props && typeof slug === 'string') {
+                                const list = rawSlots.get(slug) ?? [];
+                                list.push(props);
+                                rawSlots.set(slug, list);
+                            }
+                            Object.values(node).forEach(collect);
+                        };
+                        if (raw && raw._status !== 'draft') collect(raw[field]);
+                        for (const [slug, list] of placements)list.slice(offsets.get(slug)).forEach((placement, index)=>{
+                            const props = rawSlots.get(slug)?.[index];
+                            if (props) placement.identicalSlots = slots.filter((slot)=>slot !== 'control' && Array.isArray(props[slot]) && props[slot].length > 0 && isDeepStrictEqual(comparableContent(props.control ?? []), comparableContent(props[slot])));
+                        });
+                    }
+                }
+                if (!result.hasNextPage) break;
+                page++;
+            }
+        }
+    }
+    for (const registration of args.blocksCollections){
+        const { slug: collection, field } = registration;
+        const published = new Map();
+        const draftsEnabled = req.payload.config.collections?.some((c)=>c.slug === collection && c.versions && c.versions.drafts);
+        for (const draft of [
+            false,
+            true
+        ]){
+            let page = 1;
+            while(true){
+                const result = await req.payload.find({
+                    collection,
+                    req,
+                    overrideAccess: false,
+                    depth: 0,
+                    limit: 100,
+                    page,
+                    draft,
+                    includeLockStatus: true,
+                    ...!draft && draftsEnabled ? {
+                        where: {
+                            _status: {
+                                equals: 'published'
+                            }
+                        }
+                    } : {}
+                });
+                for (const doc of result.docs){
+                    if (!draft && doc._status === 'draft') continue;
+                    if (!draft) published.set(String(doc.id), doc);
+                    else if (doc._status !== 'draft' && published.has(String(doc.id))) continue;
+                    const baseline = published.get(String(doc.id)) ?? doc;
+                    if (documentEditor({
+                        blocks: {
+                            collections: args.blocksCollections
+                        },
+                        puck: {
+                            enabled: true,
+                            collections: puckCollections
+                        }
+                    }, collection, baseline) !== 'blocks') continue;
+                    const raw = args.compareVersions && !draft && hostBlocks(doc[field]).some((block)=>block.blockType === (registration.blockSlug ?? EXPERIMENT_BLOCK_SLUG) && typeof block.experiment === 'string' && slugs.has(block.experiment)) ? await comparisonContent(req, collection, doc.id) : undefined;
+                    for (const [index, block] of hostBlocks(doc[field]).entries()){
+                        if (block.blockType !== (registration.blockSlug ?? EXPERIMENT_BLOCK_SLUG) || typeof block.experiment !== 'string' || !slugs.has(block.experiment)) continue;
+                        const stored = raw ? hostBlocks(raw[field]).find((row)=>row.id === block.id) ?? hostBlocks(raw[field])[index] ?? block : block;
+                        const rows = Array.isArray(stored.slots) ? stored.slots : [];
+                        const keys = rows.map((row)=>row?.slot);
+                        placements.get(block.experiment).push({
+                            collection,
+                            id: doc.id,
+                            editor: 'blocks',
+                            doc,
+                            title: String(doc.title ?? doc.name ?? doc.id),
+                            published: !draft || doc._status === 'published',
+                            ...typeof baseline.slug === 'string' ? {
+                                slug: baseline.slug
+                            } : {},
+                            slots: Object.fromEntries(BLOCK_SLOTS.map((slot)=>[
+                                    slot,
+                                    slotBlocks(block, slot).length
+                                ])),
+                            duplicateRows: new Set(keys).size !== keys.length,
+                            identicalSlots: raw ? BLOCK_SLOTS.filter((slot)=>slot !== 'control' && slotBlocks(block, slot).length > 0 && isDeepStrictEqual(comparableContent(slotBlocks(stored, 'control')), comparableContent(slotBlocks(stored, slot)))) : [],
+                            locked: doc._isLocked === true || doc.locked === true,
+                            ...hasLocalizedFields(req.payload.config.collections?.find((c)=>c.slug === collection)?.fields ?? [], req.payload.config) ? {
+                                localized: true
+                            } : {}
+                        });
+                    }
                 }
                 if (!result.hasNextPage) break;
                 page++;
@@ -105,3 +240,15 @@ export async function flagPlacements(options, experiment, req) {
         req
     });
 }
+/** A warning-only comparison must never turn an adapter failure into a Start refusal. */ async function comparisonContent(req, collection, id) {
+    try {
+        return await pageVersionContent(req, collection, id);
+    } catch (cause) {
+        req.payload.logger.error({
+            err: safeError(cause),
+            collection,
+            id
+        }, 'Experiment version comparison failed');
+        return undefined;
+    }
+}

package/dist/transitions/preflightData.d.ts

@@ -17,10 +17,10 @@ export declare function loadStartInputs<TUser extends {
  * Start's locked recheck. Raw SQL on the request's transaction when there is one. */
 export declare function loadPageTestsInUse(req: PayloadRequest): Promise<NonNullable<CheckStartInput['pageTestsInUse']>>;
 /** 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. */
+ * unpublished (logged) unless propagateErrors is requested by decide. Start calls it again under its page-path locks on a detached request. */
 export declare function unpublishedPageTargets<TUser extends {
     id: DocId;
-}>(req: PayloadRequest, options: ResolvedOptions<TUser>, experiment: Pick<StartExperiment, 'id' | 'arms'>): Promise<string[]>;
+}>(req: PayloadRequest, options: ResolvedOptions<TUser>, experiment: Pick<StartExperiment, 'id' | 'arms' | 'pageCollection'>, propagateErrors?: boolean): Promise<string[]>;
 /** Shared, request-scoped reads for summary; a failed row is null in tolerant mode.
  * Preflight/Start use the same builder and retain their throwing read behaviour.
  */