@delmaredigital/payload-experiments 0.2.0-rc.7 → 0.3.0-rc.4

package/dist/transitions/makeContent.js

@@ -1,14 +1,32 @@
-import { commitTransaction, initTransaction, killTransaction } from 'payload';
+import { Forbidden, NotFound, ValidationError, Locked, commitTransaction, initTransaction, killTransaction } from 'payload';
+import { latestDraftContent, publishedContent as readPublishedContent } from '../db/publishedContent.js';
+import { contentBlocks, hasLocalizedFields } from './contentFields.js';
+import { safeError } from '../log.js';
+import { XpRefusal } from '../errors.js';
 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 { contentDone } from '../contentDone.js';
 import { archive } from './archive.js';
 import { relationshipId } from './checkStart.js';
 import { withTransition } from './kernel.js';
 import { scanBlockPlacements } from './placements.js';
 import { readExperiment, refuse, updateExperiment } from './start.js';
+/** Classify by type/name only; host error messages can contain row data. */ function contentFailureReason(error) {
+    // Payload classes may use APIError as their name, so check instances too.
+    const name = error instanceof Error ? error.name : undefined;
+    if (error instanceof LocalizedContent) return 'localized';
+    if (error instanceof Forbidden || name === 'Forbidden') return 'forbidden';
+    if (error instanceof NotFound || name === 'NotFound') return 'not-found';
+    if (error instanceof ValidationError || name === 'ValidationError') return 'validation';
+    if (error instanceof Locked || name === 'Locked' || error instanceof XpRefusal && error.code === 'locked-placement') return 'locked';
+    return 'update-failed';
+}
+class LocalizedContent extends Error {
+}
+const isNotFound = (error)=>contentFailureReason(error) === 'not-found' || Boolean(error && typeof error === 'object' && 'status' in error && error.status === 404);
 const object = (value)=>value !== null && typeof value === 'object' && !Array.isArray(value);
 /** Flatten selected slots in every content array, including nested selected slots. */ function unwrap(value, slug, slot) {
     if (Array.isArray(value)) return value.flatMap((node)=>{
@@ -32,26 +50,69 @@ const object = (value)=>value !== null && typeof value === 'object' && !Array.is
 }
 /** Payload update merges omissions from the latest version even on publish.
  * Restore each captured document's fields, omitting API/adapter metadata.
- */ function contentData(doc, field, content) {
-    const metadata = new Set([
-        'id',
-        'createdAt',
-        'updatedAt',
-        '_isLocked',
-        '_userEditing'
-    ]);
-    return {
-        ...Object.fromEntries(Object.entries(doc).filter(([key])=>!metadata.has(key))),
+ */ const contentMetadata = new Set([
+    'id',
+    'createdAt',
+    'updatedAt',
+    '_isLocked',
+    '_userEditing'
+]);
+function contentData(doc, field, content, fields, blocks = []) {
+    const data = {
+        ...Object.fromEntries(Object.entries(doc).filter(([key])=>!contentMetadata.has(key))),
         [field]: content
     };
+    return fillContentFields(fields, data, blocks);
+}
+/** Adapter reads can omit empty fields (notably single polymorphic links).
+ * Make every stored value explicit so Payload cannot fill it from the other version.
+ */ function fillContentFields(fields, source, blocks = []) {
+    const result = {
+        ...source
+    };
+    for (const field of fields){
+        if (field.type === 'ui' || field.type === 'join' || 'virtual' in field && field.virtual) continue;
+        const name = 'name' in field ? field.name : undefined;
+        if (name && contentMetadata.has(name)) continue;
+        if (name && result[name] === undefined) result[name] = field.type === 'array' || field.type === 'blocks' || 'hasMany' in field && field.hasMany ? [] : null;
+        if ('tabs' in field) for (const tab of field.tabs){
+            if ('name' in tab && tab.name) {
+                const value = result[tab.name];
+                // Payload traverses groups/tabs as objects; null would be dereferenced.
+                result[tab.name] = fillContentFields(tab.fields, object(value) ? value : {}, blocks);
+            } else Object.assign(result, fillContentFields(tab.fields, result, blocks));
+        }
+        const value = name ? result[name] : result;
+        if ('fields' in field) {
+            if (Array.isArray(value)) result[name] = value.map((row)=>object(row) ? fillContentFields(field.fields, row, blocks) : row);
+            else if (object(value) || field.type === 'group') {
+                const filled = fillContentFields(field.fields, object(value) ? value : {}, blocks);
+                if (name) result[name] = filled;
+                else Object.assign(result, filled);
+            }
+        }
+        if (field.type === 'blocks' && Array.isArray(value)) {
+            const definitions = contentBlocks(field, blocks);
+            result[name] = value.map((row)=>{
+                const block = object(row) ? definitions.find((block)=>block.slug === row.blockType) : undefined;
+                return block && object(row) ? fillContentFields(block.fields, row, blocks) : row;
+            });
+        }
+    }
+    return result;
 }
-/** Refuse unsafe collection shapes before rebuilding complete host documents. */ async function fieldRefusal(fields, req, doc, operation = 'read', data = doc, siblingData = data, blockData, seen = new Set()) {
+/** Payload strips denied updates and fills them from the latest version. Only
+ * refuse when that substitution would change the proposed value (KI-1).
+ */ // Payload beforeChange/getExistingRowDoc.js matches array/block rows by ID.
+const existingRow = (row, original)=>object(row) && row.id && Array.isArray(original) ? original.find((value)=>object(value) && value.id === row.id) ?? {} : {};
+async function fieldRefusal(fields, req, doc, operation = 'update', data = doc, siblingData = data, blockData, originalSibling = fillContentFields(fields, doc, req.payload.config.blocks)) {
     for (const field of fields){
-        if (seen.has(field)) continue;
-        const branch = new Set(seen).add(field);
-        if ('localized' in field && field.localized) return 'This page is localized; update it by hand.';
-        if ('hidden' in field && field.hidden === true) return 'This page has hidden fields; update it by hand.';
-        if ('access' in field && field.access?.[operation] && !await field.access[operation]({
+        if (field.type === 'ui' || field.type === 'join' || 'virtual' in field && field.virtual) continue;
+        if ('name' in field && ![
+            'id',
+            'createdAt',
+            'updatedAt'
+        ].includes(field.name) && JSON.stringify(siblingData[field.name] ?? null) !== JSON.stringify(originalSibling[field.name] ?? null) && 'access' in field && field.access?.[operation] && !await field.access[operation]({
             id: doc.id,
             req,
             doc,
@@ -59,13 +120,11 @@ const object = (value)=>value !== null && typeof value === 'object' && !Array.is
             siblingData,
             blockData
         })) {
-            return operation === 'read' ? 'This page has fields you cannot read; update it by hand.' : 'This page has fields you cannot update; update it by hand.';
+            return 'This page has fields you cannot update; update it by hand.';
         }
         const value = 'name' in field ? siblingData[field.name] : siblingData;
         if ('tabs' in field) for (const tab of field.tabs){
-            if ('localized' in tab && tab.localized) return 'This page is localized; update it by hand.';
-            if ('hidden' in tab && tab.hidden === true) return 'This page has hidden fields; update it by hand.';
-            if ('access' in tab && tab.access?.[operation] && !await tab.access[operation]({
+            if ('name' in tab && tab.name && JSON.stringify(siblingData[tab.name] ?? null) !== JSON.stringify(originalSibling[tab.name] ?? null) && 'access' in tab && tab.access?.[operation] && !await tab.access[operation]({
                 id: doc.id,
                 req,
                 doc,
@@ -73,31 +132,29 @@ const object = (value)=>value !== null && typeof value === 'object' && !Array.is
                 siblingData,
                 blockData
             })) {
-                return operation === 'read' ? 'This page has fields you cannot read; update it by hand.' : 'This page has fields you cannot update; update it by hand.';
+                return 'This page has fields you cannot update; update it by hand.';
             }
             const tabData = 'name' in tab && tab.name ? siblingData[tab.name] : siblingData;
-            const refusal = await fieldRefusal(tab.fields, req, doc, operation, data, object(tabData) ? tabData : {}, blockData, branch);
+            const originalTab = 'name' in tab && tab.name ? originalSibling[tab.name] : originalSibling;
+            const refusal = await fieldRefusal(tab.fields, req, doc, operation, data, object(tabData) ? tabData : {}, blockData, object(originalTab) ? originalTab : {});
             if (refusal) return refusal;
         }
+        const originalValue = 'name' in field ? originalSibling[field.name] : originalSibling;
         if ('fields' in field) for (const row of Array.isArray(value) && value.length ? value : [
             value
         ]){
-            const refusal = await fieldRefusal(field.fields, req, doc, operation, data, object(row) ? row : {}, blockData, branch);
+            const original = Array.isArray(value) ? existingRow(row, originalValue) : originalValue;
+            const refusal = await fieldRefusal(field.fields, req, doc, operation, data, object(row) ? row : {}, blockData, object(original) ? original : {});
             if (refusal) return refusal;
         }
         if (field.type === 'blocks') {
-            const blocks = [
-                ...field.blocks,
-                ...(field.blockReferences ?? []).map((slug)=>req.payload.config.blocks?.find((block)=>block.slug === slug)).filter((block)=>block !== undefined)
-            ];
-            for (const block of blocks){
-                const rows = Array.isArray(value) ? value.filter((row)=>object(row) && row.blockType === block.slug) : [];
-                for (const row of rows.length ? rows : [
-                    {}
-                ]){
-                    const refusal = await fieldRefusal(block.fields, req, doc, operation, data, row, row, branch);
-                    if (refusal) return refusal;
-                }
+            const blocks = contentBlocks(field, req.payload.config.blocks);
+            for (const row of Array.isArray(value) ? value : []){
+                const block = object(row) ? blocks.find((block)=>block.slug === row.blockType) : undefined;
+                if (!block || !object(row)) continue;
+                const original = existingRow(row, originalValue);
+                const refusal = await fieldRefusal(block.fields, req, doc, operation, data, row, row, object(original) ? original : {});
+                if (refusal) return refusal;
             }
         }
     }
@@ -142,29 +199,71 @@ export async function makeContent(req, { experimentId, options }) {
         const decision = current.decision;
         const winner = current.arms.find((arm)=>arm.key === decision?.winnerArm && arm.kind !== 'holdout');
         if (!winner) refuse('invalid-winner');
+        const report = decision?.contentReport;
+        const previous = new Map((report?.docs ?? []).map((doc)=>[
+                doc.collection + ':' + doc.id,
+                doc
+            ]));
         const docs = [];
-        const attempt = async (collection, id, fn)=>{
+        // Dismissed failures are handled by the manager: retain them unchanged and
+        // never retry them until restored. Each retried entry gets a fresh outcome.
+        const retainDismissed = (collection, id)=>{
+            const entry = previous.get(collection + ':' + id);
+            if (!entry?.dismissedAt) return false;
+            docs.push(entry);
+            return true;
+        };
+        const attempt = async (collection, id, fn, missingOk = false)=>{
+            if (retainDismissed(collection, id)) return;
+            let missing = false;
             try {
-                await hostTransaction(req, fn);
+                await hostTransaction(req, async ()=>{
+                    try {
+                        await fn();
+                    } catch (error) {
+                        if (missingOk && isNotFound(error)) {
+                            // Payload may already have killed the failed write's transaction.
+                            // Roll back any remaining writes, then check the row while still
+                            // detached from the outer transition and its privileged context.
+                            await killTransaction(req);
+                            if (!await initTransaction(req)) throw new Error('A content transaction could not be started.');
+                            missing = !await readPublishedContent(req, collection, id);
+                        }
+                        throw error;
+                    }
+                });
                 docs.push({
                     collection,
                     id,
                     ok: true
                 });
             } catch (error) {
-                const detail = error instanceof Error ? error.message : 'The content could not be updated.';
+                let detail;
+                if (isNotFound(error)) {
+                    if (missingOk) detail = 'forbidden';
+                    else detail = 'not-found';
+                } else {
+                    detail = contentFailureReason(error);
+                }
+                req.payload.logger.error({
+                    err: safeError(error),
+                    experimentId,
+                    collection,
+                    id
+                }, 'Experiment content update failed');
                 docs.push({
                     collection,
                     id,
-                    ok: false,
-                    detail,
-                    error: detail
+                    ok: Boolean(missing),
+                    detail: missing ? 'not-found' : detail,
+                    ...!missing ? {
+                        error: detail
+                    } : {}
                 });
             }
         };
         if (current.kind === 'block') {
             if (!winner.slot) refuse('invalid-winner');
-            const report = decision?.contentReport;
             const registrations = puckCollections(options);
             const scanned = [];
             for (const registration of registrations){
@@ -180,13 +279,18 @@ export async function makeContent(req, { experimentId, options }) {
                 } catch (error) {
                     // A collection made unreadable since the last attempt still has
                     // retained placements to report below. Never sacrifice the outer tx.
+                    req.payload.logger.error({
+                        err: safeError(error),
+                        experimentId,
+                        collection: registration.slug
+                    }, 'Experiment content scan failed');
                     const denied = error && typeof error === 'object' && 'status' in error && error.status === 403;
                     if (!denied || !report?.docs?.some((doc)=>doc.collection === registration.slug)) throw error;
                 } finally{
                     req.transactionID = transactionID;
                 }
             }
-            if (scanned.some((doc)=>doc.locked)) refuse('locked-placement');
+            if (scanned.some((doc)=>doc.locked && !previous.get(doc.collection + ':' + doc.id)?.dismissedAt)) refuse('locked-placement');
             const placements = new Map();
             for (const doc of [
                 ...report?.docs ?? [],
@@ -196,14 +300,13 @@ export async function makeContent(req, { experimentId, options }) {
             // Probe with no borrowed transaction: disableErrors handles expected
             // NotFound/Forbidden, and even a host read hook cannot kill the outer tx.
             for (const [key, { collection, id }] of placements){
+                if (retainDismissed(collection, id)) {
+                    skipped.add(key);
+                    continue;
+                }
                 const transactionID = req.transactionID;
                 delete req.transactionID;
                 try {
-                    const config = req.payload.config.collections.find((config)=>config.slug === collection);
-                    const access = config?.access?.read ? await config.access.read({
-                        id,
-                        req
-                    }) : true;
                     const doc = await req.payload.findByID({
                         collection,
                         id,
@@ -214,34 +317,44 @@ export async function makeContent(req, { experimentId, options }) {
                         includeLockStatus: true,
                         disableErrors: true
                     });
-                    if (!doc) {
-                        // Fail closed (exp-orch 16:20): only an unfiltered read proves the page is gone;
-                        // a Where-filtered miss may be a page this manager cannot see.
-                        const ok = access === true || typeof access === 'object' && access !== null && Object.keys(access).length === 0;
-                        const detail = ok ? 'This page no longer exists; nothing to change.' : access === false ? 'You can no longer read this page.' : 'You can no longer read this page. If it was deleted, archive this experiment with discard or hard-coded instead.';
-                        docs.push({
-                            collection,
-                            id,
-                            ok,
-                            detail,
-                            ...!ok ? {
-                                error: detail
-                            } : {}
-                        });
-                        skipped.add(key);
-                    } else if (doc._isLocked === true || doc.locked === true) refuse('locked-placement', {
+                    // Null can also mean trashed or hidden by a host hook. Use the same
+                    // unfiltered existence check as a thrown NotFound before reporting done.
+                    if (!doc) throw new NotFound();
+                    if (doc._isLocked === true || doc.locked === true) refuse('locked-placement', {
                         collection,
                         id
                     });
                 } catch (error) {
                     if (error && typeof error === 'object' && 'code' in error && error.code === 'locked-placement') throw error;
-                    const missing = error && typeof error === 'object' && 'status' in error && error.status === 404;
-                    const detail = missing ? 'This page no longer exists; nothing to change.' : 'You can no longer read this page.';
+                    let missing = false;
+                    let detail = isNotFound(error) ? 'forbidden' : contentFailureReason(error);
+                    if (isNotFound(error)) {
+                        try {
+                            await hostTransaction(req, async ()=>{
+                                missing = !await readPublishedContent(req, collection, id);
+                            });
+                        } catch (checkError) {
+                            missing = false;
+                            detail = 'update-failed';
+                            req.payload.logger.error({
+                                err: safeError(checkError),
+                                experimentId,
+                                collection,
+                                id
+                            }, 'Experiment content existence check failed');
+                        }
+                    }
+                    req.payload.logger.error({
+                        err: safeError(error),
+                        experimentId,
+                        collection,
+                        id
+                    }, 'Experiment content read failed');
                     docs.push({
                         collection,
                         id,
                         ok: Boolean(missing),
-                        detail,
+                        detail: missing ? 'not-found' : detail,
                         ...!missing ? {
                             error: detail
                         } : {}
@@ -256,7 +369,9 @@ export async function makeContent(req, { experimentId, options }) {
                 await attempt(collection, id, async ()=>{
                     const field = registrations.find((entry)=>entry.slug === collection)?.field;
                     if (!field) throw new Error('This content collection is no longer configured.');
-                    const draft = await req.payload.findByID({
+                    const config = req.payload.config.collections.find((config)=>config.slug === collection);
+                    if (hasLocalizedFields(config?.fields ?? [], req.payload.config)) throw new LocalizedContent();
+                    await req.payload.findByID({
                         collection,
                         id,
                         req,
@@ -264,50 +379,48 @@ export async function makeContent(req, { experimentId, options }) {
                         depth: 0,
                         draft: true
                     });
-                    const config = req.payload.config.collections.find((config)=>config.slug === collection);
                     const drafts = Boolean(config?.versions && config.versions.drafts);
-                    const published = drafts ? await req.payload.findByID({
-                        collection,
-                        id,
-                        req,
-                        overrideAccess: false,
-                        depth: 0,
-                        draft: false
-                    }) : draft;
-                    const draftContent = unwrap(draft[field], current.slug, winner.slot);
+                    const published = await readPublishedContent(req, collection, id);
+                    if (!published) throw new NotFound();
+                    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 changedDraft = JSON.stringify(draftContent) !== JSON.stringify(draft[field]);
+                    const changedDraft = JSON.stringify(draftContent) !== JSON.stringify(draftValue);
                     const changedPublished = JSON.stringify(publishedContent) !== JSON.stringify(published[field]);
-                    // Nothing left to rewrite (e.g. an editor already did it by hand): done, before any refusal —
-                    // but only when the content field was really read (not stripped as hidden/unreadable, not localized).
-                    const contentField = topLevelField(config?.fields ?? [], field);
-                    // Payload strips hidden and read-denied fields from a read, so presence in both proves readability;
-                    // a localized content field compares only one locale, so it never takes the shortcut.
-                    const contentReadable = Object.hasOwn(draft, field) && Object.hasOwn(published, field) && !contentField?.localized;
-                    if (contentReadable && !changedDraft && !changedPublished) return;
-                    for (const doc of [
-                        draft,
-                        published
-                    ]){
-                        const refusal = await fieldRefusal(config?.fields ?? [], req, doc);
-                        if (refusal) throw new Error(refusal);
-                    }
-                    const publishedData = contentData(published, field, publishedContent);
+                    if (!changedDraft && !changedPublished) return;
+                    const publishedData = contentData(published, field, publishedContent, config?.fields ?? [], req.payload.config.blocks);
                     const draftData = {
-                        ...contentData(draft, field, draftContent),
+                        ...contentData(draft, field, draftContent, config?.fields ?? [], req.payload.config.blocks),
                         _status: 'draft'
                     };
                     // Payload beforeValidate receives the latest version as doc, and the
                     // proposed write as data/siblingData (blockData is the proposed row).
-                    const publicationRefusal = await fieldRefusal(config?.fields ?? [], req, draft, 'update', publishedData);
-                    if (publicationRefusal) throw new Error(publicationRefusal);
+                    if (changedPublished) {
+                        const publicationRefusal = await fieldRefusal(config?.fields ?? [], req, draft, 'update', publishedData);
+                        if (publicationRefusal) throw new ValidationError({
+                            errors: [
+                                {
+                                    message: publicationRefusal,
+                                    path: field
+                                }
+                            ]
+                        });
+                    }
                     if (drafts) {
                         const draftOriginal = changedPublished ? {
                             ...published,
                             ...publishedData
                         } : draft;
                         const draftRefusal = await fieldRefusal(config?.fields ?? [], req, draftOriginal, 'update', draftData);
-                        if (draftRefusal) throw new Error(draftRefusal);
+                        if (draftRefusal) throw new ValidationError({
+                            errors: [
+                                {
+                                    message: draftRefusal,
+                                    path: field
+                                }
+                            ]
+                        });
                     }
                     // Host writes are access checked with the manager's req (§7.8).
                     if (changedPublished) await req.payload.update({
@@ -328,7 +441,7 @@ export async function makeContent(req, { experimentId, options }) {
                         draft: true,
                         data: draftData
                     });
-                });
+                }, true);
             }
         } else if (current.kind === 'flag') {
             const point = options.flagPoints?.find((point)=>point.id === current.flagPoint);
@@ -341,6 +454,7 @@ export async function makeContent(req, { experimentId, options }) {
                     },
                     req
                 }));
+            else retainDismissed('xp-experiments', experimentId);
             // Lock the shared state before its read/modify/write, after L/F/E.
             await lockContentDefaults(exec);
             // §7.8 transition exception: durable made-content defaults in plugin state.
@@ -376,7 +490,9 @@ export async function makeContent(req, { experimentId, options }) {
                 }
             }
         });
-        if (docs.every((doc)=>doc.ok)) return {
+        if (contentDone({
+            docs
+        })) return {
             ...await archive(req, {
                 experimentId,
                 mode: 'after-content'
@@ -392,20 +508,3 @@ export async function makeContent(req, { experimentId, options }) {
     });
     return result;
 }
-/** The top-level data field with this name, looking through unnamed rows, collapsibles and tabs. */ function topLevelField(fields, name) {
-    for (const raw of fields){
-        const field = raw;
-        if (field.name === name) return field;
-        if (!field.name && (field.type === 'row' || field.type === 'collapsible') && field.fields) {
-            const found = topLevelField(field.fields, name);
-            if (found) return found;
-        }
-        if (field.type === 'tabs') {
-            for (const tab of field.tabs ?? [])if (!tab.name && tab.fields) {
-                const found = topLevelField(tab.fields, name);
-                if (found) return found;
-            }
-        }
-    }
-    return undefined;
-}

package/dist/transitions/phaseRecord.d.ts

@@ -13,14 +13,20 @@ export interface PhaseRecord {
     allocationChanges?: AllocationChange[];
     targeting: TargetingRule[];
     metricDefinitions?: Array<Record<string, unknown>>;
-    analysis?: Record<string, unknown>;
+    analysis?: Record<string, unknown> & {
+        sequentialTuningParameter?: number | null;
+    };
     contentChanges?: ContentChange[];
 }
 export declare function readPhaseRecord(req: PayloadRequest, experimentId: DocId, phase: number): Promise<PhaseRecord & {
     id: DocId;
 }>;
 /** Caller holds the experiment lock and passes the kernel's transaction req. */
-export declare function writePhaseRecord(req: PayloadRequest, record: PhaseRecord): Promise<import("payload").JsonObject & import("payload").TypeWithID>;
+export declare function writePhaseRecord(req: PayloadRequest, record: PhaseRecord & {
+    analysis: Record<string, unknown> & {
+        sequentialTuningParameter: number;
+    };
+}): Promise<import("payload").JsonObject & import("payload").TypeWithID>;
 /** End only an open phase, preserving the original stop time on a later decide.
  * Caller holds the experiment lock and passes the kernel's transaction req.
  */

package/dist/transitions/placements.d.ts

@@ -1,13 +1,10 @@
 import type { PayloadRequest } from 'payload';
-import type { Arm, DocId, FlagPoint, ResolvedOptions } from '../types/contracts.js';
+import type { Arm, DocId, FlagPoint, PreviewPlacement, ResolvedOptions } from '../types/contracts.js';
 import type { ArmSlot } from '../types/puck.js';
-export interface BlockPlacement {
-    collection: string;
-    id: DocId;
-    title: string;
-    published: boolean;
+export interface BlockPlacement extends PreviewPlacement {
     slots: Record<ArmSlot, number>;
     locked?: boolean;
+    localized?: boolean;
 }
 export type FlagPlacement = Awaited<ReturnType<NonNullable<FlagPoint['placements']>>>[number];
 /** Each matching ExperimentSlot is checked separately, including multiple slots

package/dist/transitions/placements.js

@@ -1,3 +1,4 @@
+import { hasLocalizedFields } from './contentFields.js';
 import { puckCollections as normalisePuckCollections } from '../options.js';
 const slots = [
     'control',
@@ -23,6 +24,7 @@ export async function scanBlockPlacements(req, args) {
         }
     })){
         const publishedIds = new Set();
+        const publishedSlugs = new Map();
         const draftsEnabled = req.payload.config.collections?.some((config)=>config.slug === collection && config.versions && config.versions.drafts);
         for (const draft of [
             false,
@@ -50,7 +52,10 @@ export async function scanBlockPlacements(req, args) {
                 for (const doc of result.docs){
                     if (!draft && doc._status === 'draft') continue;
                     if (draft && doc._status !== 'draft' && publishedIds.has(String(doc.id))) continue;
-                    if (!draft) publishedIds.add(String(doc.id));
+                    if (!draft) {
+                        publishedIds.add(String(doc.id));
+                        if (typeof doc.slug === 'string') publishedSlugs.set(String(doc.id), doc.slug);
+                    }
                     function walk(value) {
                         if (!value || typeof value !== 'object') return;
                         if (Array.isArray(value)) {
@@ -67,10 +72,16 @@ export async function scanBlockPlacements(req, args) {
                                 id: doc.id,
                                 title: String(doc.title ?? doc.name ?? doc.id),
                                 published: !draft || doc._status === 'published',
+                                ...publishedSlugs.has(String(doc.id)) ? {
+                                    slug: publishedSlugs.get(String(doc.id))
+                                } : {},
                                 slots: Object.fromEntries(slots.map((slot)=>[
                                         slot,
                                         Array.isArray(props[slot]) ? props[slot].length : 0
                                     ])),
+                                ...hasLocalizedFields(req.payload.config.collections?.find((config)=>config.slug === collection)?.fields ?? [], req.payload.config) ? {
+                                    localized: true
+                                } : {},
                                 locked: doc._isLocked === true || doc.locked === true
                             });
                         }

package/dist/transitions/preflightData.d.ts

@@ -1,4 +1,4 @@
-import type { PayloadRequest } from 'payload';
+import { type PayloadRequest } from 'payload';
 import type { PowerWeeksInput, PowerWeeksResult } from '@delmaredigital/experiments-stats';
 import type { DocId, ResolvedOptions } from '../types/contracts.js';
 import type { PreflightResult } from '../types/endpoints.js';
@@ -13,6 +13,14 @@ export interface PreflightDependencies {
 export declare function loadStartInputs<TUser extends {
     id: DocId;
 }>(req: PayloadRequest, options: ResolvedOptions<TUser>, experimentId: DocId): Promise<CheckStartInput | null>;
+/** Occupancy from the arms the runtime routes on (frozen rounds), shared by preflight and
+ * 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. */
+export declare function unpublishedPageTargets<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, options: ResolvedOptions<TUser>, experiment: Pick<StartExperiment, 'id' | 'arms'>): 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.
  */