@delmaredigital/payload-experiments 0.2.0-rc.6 → 0.3.0-rc.1

package/dist/server/runResults.js

@@ -1,3 +1,6 @@
+import { XpAnalysisError } from '../errors.js';
+import { safeError } from '../log.js';
+import { createLocalReq } from 'payload';
 import { resultsCandidates, resultsExecutor, writeSnapshots } from '../db/snapshots.js';
 import { sweepEvents } from '../db/sweep.js';
 import { armMismatchCount, identityRows, metricEventRows, phaseExposureRows, rolloutExposureRows } from '../db/results.js';
@@ -5,8 +8,8 @@ import { raceDeadline, ResultsBudgetError, RESULTS_TIMEOUT_MARGIN_MS } from '../
 import { analysePhase } from '../results/analyse.js';
 import { firstExposures, perUnitValues, timestampMs } from '../results/aggregate.js';
 import { rolloutAnalysisUnits } from '../results/rolloutUnits.js';
-import { creditUserEvents } from '../results/identityCredit.js';
-async function analyseCandidate(exec, candidate, options, now, deadline, unavailableMetrics) {
+import { creditUserEvents, eligibleIdentityLinks } from '../results/identityCredit.js';
+async function analyseCandidate(exec, candidate, options, now, deadline, unavailableMetrics, logger) {
     const { phase } = candidate;
     // Rollout assignment preserves the original test ranges, but its SRM compares
     // only the shipped group against holdout with weights {100-h, h}.
@@ -58,6 +61,7 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
         ...new Set(identities.map((identity)=>identity.userId))
     ];
     const linked = new Set(userIds);
+    const identityConflicts = new Set();
     const credit = (events, userKeyed)=>{
         if (candidate.unitType === 'user') return events.map((event)=>({
                 ...event,
@@ -68,13 +72,12 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
                 value: event.value,
                 ts: event.ts
             }));
-        const credited = creditUserEvents(units, identities, userEvents).events;
+        const credited = creditUserEvents(units, identities, userEvents, (userId)=>identityConflicts.add(userId)).events;
         return userKeyed ? credited : [
             ...events.filter((event)=>event.userId == null || !linked.has(event.userId)),
             ...credited
         ];
     };
-    const diagnostics = creditUserEvents(units, identities, []);
     const metricData = [];
     for (const definition of phase.metricDefinitions){
         try {
@@ -88,7 +91,7 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
             let events, covariates;
             if (definition.source.startsWith('events:')) {
                 const eventName = definition.source.slice(7);
-                if (!options.eventSources?.some((source)=>source.name === eventName)) throw new Error('Metric source unavailable');
+                if (!options.eventSources?.some((source)=>source.name === eventName)) throw new XpAnalysisError('source-unavailable');
                 const read = async (start)=>{
                     if (candidate.unitType === 'user') return metricEventRows(exec, {
                         eventName,
@@ -131,9 +134,9 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
                 }
             } else {
                 const source = options.metricSources?.find((source)=>source.id === definition.source);
-                if (!source || source.kind !== kind || definition.keyedBy && source.keyedBy !== definition.keyedBy) throw new Error('Metric source unavailable');
+                if (!source || source.kind !== kind || definition.keyedBy && source.keyedBy !== definition.keyedBy) throw new XpAnalysisError('source-unavailable');
                 const userKeyed = source.keyedBy === 'user' && candidate.unitType === 'visitor';
-                if (candidate.unitType === 'user' && source.keyedBy !== 'user') throw new Error('Metric unit type unavailable');
+                if (candidate.unitType === 'user' && source.keyedBy !== 'user') throw new XpAnalysisError('unit-type-unavailable');
                 const sourceIds = userKeyed ? userIds : ids;
                 events = credit(await raceDeadline(deadline, ()=>source.query({
                         from,
@@ -141,35 +144,51 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
                         unitIds: sourceIds
                     })), userKeyed);
                 if (phase.analysis.cuped === 'auto' && source.covariate) {
-                    const sourceUnits = userKeyed ? creditUserEvents(units, identities, userIds.map((userId)=>({
-                            userId,
-                            ts: now,
-                            value: 0
-                        }))).events.map((event)=>({
-                            unitId: identities.find((identity)=>identity.anonymousId === event.unitId).userId,
-                            firstExposureTs: units.get(event.unitId).firstTs
+                    const userUnits = new Map();
+                    if (userKeyed) for (const link of identities){
+                        const unit = units.get(link.anonymousId);
+                        if (!unit) continue;
+                        // Hosts aggregate pre-period values in SQL; per-event rows over 14 days would break the one-row-per-unit contract and multiply host traffic.
+                        // CUPED only reduces variance: mis-credited pre-exposure values add noise, but cannot bias the effect because they are independent of assignment.
+                        if (!eligibleIdentityLinks([
+                            link
+                        ], unit.firstTs).length) continue;
+                        const previous = userUnits.get(link.userId);
+                        if (!previous || +unit.firstTs < +previous.firstExposureTs || +unit.firstTs === +previous.firstExposureTs && link.anonymousId < previous.unitId) {
+                            userUnits.set(link.userId, {
+                                unitId: link.anonymousId,
+                                firstExposureTs: unit.firstTs
+                            });
+                        }
+                    }
+                    const sourceUnits = userKeyed ? [
+                        ...userUnits
+                    ].map(([unitId, unit])=>({
+                            unitId,
+                            firstExposureTs: unit.firstExposureTs
                         })) : [
                         ...units
                     ].map(([unitId, unit])=>({
                             unitId,
-                            firstExposureTs: unit.firstTs
+                            firstExposureTs: new Date(timestampMs(unit.firstTs))
                         }));
                     const pre = await raceDeadline(deadline, ()=>source.covariate({
                             units: sourceUnits,
                             lookbackDays: 14
                         }));
-                    if (pre.some((row)=>!Number.isFinite(row.value))) throw new Error('Covariates must be finite');
-                    const credited = credit(pre.map((row)=>({
-                            ...row,
-                            ts: now
-                        })), userKeyed);
-                    covariates = new Map(credited.map((row)=>[
-                            row.unitId,
-                            row.value
-                        ]));
+                    if (pre.some((row)=>!Number.isFinite(row.value))) throw new XpAnalysisError('non-finite-covariates');
+                    covariates = new Map(pre.flatMap((row)=>{
+                        const unitId = userKeyed ? userUnits.get(row.unitId)?.unitId : row.unitId;
+                        return unitId === undefined ? [] : [
+                            [
+                                unitId,
+                                row.value
+                            ]
+                        ];
+                    }));
                 }
             }
-            if (events.some((event)=>!Number.isFinite(event.value))) throw new Error('Metric values must be finite');
+            if (events.some((event)=>!Number.isFinite(event.value))) throw new XpAnalysisError('non-finite-values');
             metricData.push({
                 metricId: definition.metricId,
                 values: perUnitValues(units, events, {
@@ -182,7 +201,22 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
                 } : {}
             });
         } catch (error) {
-            const reason = error instanceof Error ? error.message : 'Metric source unavailable';
+            let reason = error instanceof ResultsBudgetError ? 'budget' : 'source-failed';
+            if (error instanceof XpAnalysisError) {
+                switch(error.code){
+                    case 'source-unavailable':
+                    case 'unit-type-unavailable':
+                    case 'non-finite-values':
+                    case 'non-finite-covariates':
+                        reason = error.code;
+                        break;
+                }
+            }
+            logger.error({
+                err: safeError(error),
+                experimentId: phase.experiment,
+                metricId: definition.metricId
+            }, 'Experiment metric source failed');
             metricData.push({
                 metricId: definition.metricId,
                 values: new Map(),
@@ -204,9 +238,14 @@ async function analyseCandidate(exec, candidate, options, now, deadline, unavail
         units,
         metricData,
         status,
+        onMetricError: (error, metricId)=>logger.error({
+                err: safeError(error),
+                experimentId: phase.experiment,
+                metricId
+            }, 'Experiment metric analysis failed'),
         excludedMultiArm: exposed.excludedMultiArm,
         armMismatch: await armMismatchCount(exec, query),
-        identityConflictShare: userIds.length ? diagnostics.conflicts / userIds.length : 0,
+        identityConflictShare: userIds.length ? identityConflicts.size / userIds.length : 0,
         ...phase.phaseKind === 'rollout' ? {
             winnerArm: phase.arms.find((arm)=>arm.kind !== 'holdout').key
         } : {}
@@ -247,12 +286,12 @@ export async function runResults(payload, { budgetMs = 20_000, experimentId, swe
         if (!(error instanceof ResultsBudgetError)) summary.failed++;
         summary.budgetExhausted = error instanceof ResultsBudgetError;
         payload.logger.error({
-            err: error,
+            err: safeError(error),
             experimentId
         }, 'Experiment scheduling failed');
     }
-    // Query order is oldest phase snapshot first; grouping keeps each experiment's
-    // phases together while preserving that scheduling priority.
+    // Analysis precedes health-only refreshes, then oldest phase snapshots first;
+    // grouping keeps each experiment's phases together with that priority.
     const experiments = new Map();
     for (const candidate of candidates){
         const id = candidate.phase.experiment;
@@ -271,10 +310,62 @@ export async function runResults(payload, { budgetMs = 20_000, experimentId, swe
             const snapshots = [];
             for (const phase of phases){
                 if (Date.now() >= analysisDeadline) throw new ResultsBudgetError();
-                snapshots.push(await analyseCandidate(exec, phase, options, now, analysisDeadline, summary.unavailableMetrics));
+                // Health refreshes must not reopen inference after the late-beacon grace.
+                snapshots.push(phase.frozenSnapshot ? {
+                    ...phase.frozenSnapshot,
+                    computedAt: now.toISOString()
+                } : await analyseCandidate(exec, phase, options, now, analysisDeadline, summary.unavailableMetrics, payload.logger));
+            }
+            if (Date.now() >= analysisDeadline) throw new ResultsBudgetError();
+            const current = phases.find((candidate)=>candidate.kind === 'page' && candidate.phase.phase === candidate.currentPhase && (candidate.status === 'running' || candidate.status === 'decided'));
+            if (current) {
+                const req = await raceDeadline(analysisDeadline, ()=>createLocalReq({}, payload));
+                const health = [];
+                // Decided tests serve only the winner and Original, including rollouts.
+                const arms = current.phase.phaseKind === 'rollout' ? [
+                    ...current.phase.arms.filter((arm)=>arm.kind !== 'holdout'),
+                    ...current.testArms.filter((arm)=>arm.kind === 'control')
+                ] : current.testArms.filter((arm)=>arm.kind !== 'holdout' && (current.status !== 'decided' || arm.kind === 'control' || arm.key === current.winnerArm));
+                const targets = new Set(arms.flatMap((arm)=>arm.pageTarget ? [
+                        arm.pageTarget
+                    ] : []));
+                for (const path of targets){
+                    let published = false, found = false, unchecked = false;
+                    for (const collection of options.pages?.collections ?? []){
+                        try {
+                            const page = await raceDeadline(analysisDeadline, ()=>collection.findByPath(path, req));
+                            found ||= page != null;
+                            published ||= page?.published === true;
+                        } catch (error) {
+                            if (error instanceof ResultsBudgetError) throw error;
+                            payload.logger.error({
+                                err: safeError(error),
+                                experimentId: id
+                            }, 'Experiment version page lookup failed');
+                            unchecked = true;
+                        }
+                    }
+                    if (!published) health.push({
+                        code: !found && (unchecked || !options.pages?.collections.length) ? 'version-page-unchecked' : 'version-page-unavailable',
+                        path
+                    });
+                }
+                for (const snapshot of snapshots)snapshot.health = health;
             }
             if (Date.now() >= analysisDeadline) throw new ResultsBudgetError();
-            await writeSnapshots(exec, snapshots);
+            // Order and optional empty health are semantically identical. Frozen
+            // inference gets a new row only when its page availability changes.
+            const canonicalHealth = (snapshot)=>JSON.stringify((snapshot.health ?? []).map(({ code, path })=>[
+                        code,
+                        path
+                    ]).map((entry)=>JSON.stringify(entry)).sort((a, b)=>a < b ? -1 : a > b ? 1 : 0));
+            const changed = snapshots.filter((snapshot, index)=>!phases[index].frozenSnapshot || canonicalHealth(snapshot) !== canonicalHealth(phases[index].frozenSnapshot));
+            // Unchanged health is a successful refresh with nothing to write.
+            if (!changed.length) {
+                summary.ran++;
+                continue;
+            }
+            await writeSnapshots(exec, changed);
             summary.ran++;
             if (summary.processedIds.length < 100) summary.processedIds.push(id);
         } catch (error) {
@@ -282,7 +373,7 @@ export async function runResults(payload, { budgetMs = 20_000, experimentId, swe
             if (!(error instanceof ResultsBudgetError)) summary.failed++;
             summary.budgetExhausted ||= error instanceof ResultsBudgetError;
             payload.logger.error({
-                err: error,
+                err: safeError(error),
                 experimentId: id
             }, 'Experiment results failed');
         }
@@ -302,7 +393,7 @@ export async function runResults(payload, { budgetMs = 20_000, experimentId, swe
             if (!(error instanceof ResultsBudgetError)) summary.failed++;
             summary.budgetExhausted ||= error instanceof ResultsBudgetError;
             payload.logger.error({
-                err: error
+                err: safeError(error)
             }, 'Experiment retention sweep failed');
         }
     }

package/dist/server/trackConversion.js

@@ -1,3 +1,4 @@
+import { safeError } from '../log.js';
 import { NextRequest } from 'next/server.js';
 import { pooledExecutor } from '../db/executor.js';
 import { insertEvents } from '../db/events.js';
@@ -39,9 +40,8 @@ export async function trackConversion(serverRuntime, event) {
             } catch (error) {
                 try {
                     payload.logger.error({
-                        err: error,
-                        msg: 'Experiments: trackConversion getUser failed'
-                    });
+                        err: safeError(error)
+                    }, 'Experiments: trackConversion getUser failed');
                 } catch  {}
             }
         }
@@ -61,9 +61,8 @@ export async function trackConversion(serverRuntime, event) {
     } catch (error) {
         try {
             payload?.logger.error({
-                err: error,
-                msg: 'Experiments: trackConversion failed'
-            });
+                err: safeError(error)
+            }, 'Experiments: trackConversion failed');
         } catch  {}
     }
 }

package/dist/targeting/values.d.ts

@@ -0,0 +1,4 @@
+/** Trim and deduplicate list inputs while preserving commas inside array items. */
+export declare function coerceListValue(raw: unknown): string[];
+/** Only the read boundary accepts legacy comma-separated document values. */
+export declare function readListValue(raw: unknown): string[];

package/dist/targeting/values.js

@@ -0,0 +1,10 @@
+/** Trim and deduplicate list inputs while preserving commas inside array items. */ export function coerceListValue(raw) {
+    return [
+        ...new Set((Array.isArray(raw) ? raw.map(String) : [
+            String(raw ?? '')
+        ]).map((value)=>value.trim()).filter(Boolean))
+    ];
+}
+/** Only the read boundary accepts legacy comma-separated document values. */ export function readListValue(raw) {
+    return coerceListValue(typeof raw === 'string' ? raw.split(',') : raw);
+}

package/dist/transitions/addMetric.js

@@ -1,3 +1,4 @@
+import { lockMetricsForFreeze } from '../db/metricUsage.js';
 import { readState } from '../db/state.js';
 import { XpRefusal } from '../errors.js';
 import { relationshipId } from './checkStart.js';
@@ -44,7 +45,14 @@ export async function addMetric(req, { experimentId, metric, role, options }) {
         if (ids.some((id)=>id !== undefined && String(id) === String(metric))) refuse('duplicate-metric', {
             message: 'This metric is already part of the experiment.'
         });
+        const lockedMetrics = await lockMetricsForFreeze(exec, caps.definitions.map((metric)=>metric.id));
+        if (!lockedMetrics) {
+            throw new XpRefusal('stale-draft', 'This goal was deleted. Choose another goal.', undefined, 409);
+        }
         const definition = caps.definitions[0];
+        if (lockedMetrics[0].slug !== definition.slug || lockedMetrics[0].source !== definition.source) {
+            throw new XpRefusal('stale-draft', 'This goal changed. Review it again before adding it.', undefined, 409);
+        }
         if (current.unitType === 'user' && definition.keyedBy === 'visitor' && !definition.source.startsWith('events:')) refuse('unit-source-mismatch');
         // §7.8: phase lookup serves the access-authorised transition write.
         const phases = await req.payload.find({

package/dist/transitions/archive.js

@@ -1,3 +1,4 @@
+import { contentDone } from '../contentDone.js';
 import { relationshipId } from './checkStart.js';
 import { expectedConfirm, matchesConfirm, storedWinnerLabel } from './confirmPhrases.js';
 import { withTransition } from './kernel.js';
@@ -14,9 +15,7 @@ export async function archive(req, { experimentId, mode, confirmation }) {
         if (mode === 'stopped' ? current.status !== 'stopped' : current.status !== 'decided') refuse('invalid-status');
         if (mode === 'hard-coded' && current.kind !== 'code') refuse('invalid-status');
         if (mode === 'after-content') {
-            const report = decision?.contentReport;
-            const docs = Array.isArray(report) ? report : report?.docs;
-            if (!Array.isArray(docs) || !docs.every((doc)=>doc?.ok === true)) refuse('invalid-status');
+            if (!contentDone(decision?.contentReport)) refuse('invalid-status');
         }
         if (mode === 'discard' && !matchesConfirm(expectedConfirm('discard', ''), confirmation)) refuse('confirmation-required');
         if (mode === 'hard-coded') {

package/dist/transitions/checkStart.d.ts

@@ -1,7 +1,7 @@
 import type { Arm, DocId, ExperimentKind, ExposurePolicy, FlagPoint, MetricSource, ResolvedOptions, Status, TargetingRule, UnitType } from '../types/contracts.js';
 import type { ArmIssueCode, PreflightResult } from '../types/endpoints.js';
 import type { BlockPlacement, FlagPlacement } from './placements.js';
-export type ReadinessCode = ArmIssueCode | 'invalid-status' | 'no-planned-duration' | 'no-primary-metric' | 'no-reach-per-day' | 'page-no-targets' | 'page-user-unit' | 'flag-no-point' | 'flag-params-invalid' | 'flag-point-busy' | 'flag-placement-missing' | 'no-placements' | 'empty-slot' | 'layer-unit-mismatch' | 'layer-full' | 'unknown-metric-source' | 'unit-source-mismatch' | 'undeclared-targeting-key' | 'invalid-targeting-rule';
+export type ReadinessCode = ArmIssueCode | 'invalid-status' | 'no-planned-duration' | 'no-primary-metric' | 'no-reach-per-day' | 'page-no-targets' | 'page-target-unpublished' | 'page-targets-unchecked' | 'version-page-unavailable' | 'version-page-unchecked' | 'page-user-unit' | 'flag-no-point' | 'flag-params-invalid' | 'flag-point-busy' | 'flag-placement-missing' | 'no-placements' | 'empty-slot' | 'make-content-unsupported' | 'layer-unit-mismatch' | 'layer-full' | 'unknown-metric-source' | 'unit-source-mismatch' | 'block-path-rule' | 'undeclared-targeting-key' | 'invalid-targeting-rule';
 export interface StartExperiment {
     id: DocId;
     slug: string;
@@ -38,6 +38,7 @@ export interface StartMetric {
     id: DocId;
     source: string;
 }
+export type PlacementFailure = 'placements-failed' | 'forbidden' | 'not-found';
 export interface CheckStartInput {
     experiment: StartExperiment;
     metrics: StartMetric[];
@@ -45,9 +46,11 @@ export interface CheckStartInput {
     flagPoints?: FlagPoint[];
     placements?: BlockPlacement[];
     flagPlacements?: FlagPlacement[];
-    placementError?: string;
-    flagPlacementError?: string;
+    placementError?: PlacementFailure;
+    flagPlacementError?: PlacementFailure;
     flagPointBusy?: boolean;
+    unpublishedPageTargets?: string[];
+    pageTargetsUnchecked?: boolean;
     layer?: {
         unitType: UnitType;
         usedSlices: number[];

package/dist/transitions/checkStart.js

@@ -56,6 +56,9 @@ function invalidParams(arms, point) {
         'viewport'
     ].includes(e.exposurePolicy) || positive(e.analysis?.reachPerDay));
     add('page-no-targets', e.kind !== 'page' || e.arms.filter((arm)=>arm.kind !== 'holdout').every((arm)=>typeof arm.pageTarget === 'string' && arm.pageTarget.trim().length > 0));
+    add('page-target-unpublished', !input.unpublishedPageTargets?.length, input.unpublishedPageTargets?.[0]);
+    add('page-targets-unchecked', true);
+    if (input.pageTargetsUnchecked) checks[checks.length - 1].warning = true;
     add('page-user-unit', e.kind !== 'page' || e.unitType === 'visitor');
     const point = input.flagPoints?.find((point)=>point.id === e.flagPoint);
     add('flag-no-point', e.kind !== 'flag' || !!point);
@@ -72,6 +75,12 @@ function invalidParams(arms, point) {
     add('no-placements', e.kind !== 'block' || !input.placementError && placements.length > 0, input.placementError);
     const empty = placements.filter((placement)=>e.arms.some((arm)=>arm.kind !== 'holdout' && (!arm.slot || !(placement.slots[arm.slot] > 0))));
     add('empty-slot', e.kind !== 'block' || empty.length === 0, empty);
+    add('make-content-unsupported', true);
+    const localized = placements.find((placement)=>placement.localized);
+    if (localized) Object.assign(checks[checks.length - 1], {
+        warning: true,
+        detail: localized.title
+    });
     add('layer-unit-mismatch', e.layer == null || input.layer?.unitType === e.unitType);
     const free = 100 - new Set(input.layer?.usedSlices).size;
     add('layer-full', e.layer == null || !!input.layer && free >= e.allocation, {
@@ -82,6 +91,12 @@ function invalidParams(arms, point) {
     add('unknown-metric-source', unknown.length === 0, unknown);
     const mismatches = input.metrics.filter((metric)=>!metric.source.startsWith('events:') && e.unitType === 'user' && input.metricSources?.some((source)=>source.id === metric.source && source.keyedBy === 'visitor'));
     add('unit-source-mismatch', mismatches.length === 0, mismatches);
+    const pathRules = (e.targeting ?? []).flatMap((rule, index)=>rule.attribute === 'path' ? [
+            index
+        ] : []);
+    add('block-path-rule', e.kind !== 'block' || pathRules.length === 0, {
+        rules: pathRules
+    });
     const undeclared = (e.targeting ?? []).filter((rule)=>!Object.hasOwn(input.attributeKeys ?? {}, rule.attribute));
     add('undeclared-targeting-key', undeclared.length === 0, {
         message: 'Targeting uses an undeclared attribute.',

package/dist/transitions/contentFields.d.ts

@@ -0,0 +1,7 @@
+import type { Block, Field, SanitizedConfig } from 'payload';
+/** Payload keeps both inline definitions and slug references in blockReferences. */
+export declare function contentBlocks(field: Extract<Field, {
+    type: 'blocks';
+}>, blocks?: Block[]): Block[];
+/** Any localized data makes a full-document publish unsafe in Payload 3.90. */
+export declare function hasLocalizedFields(fields: Field[], config: Pick<SanitizedConfig, 'localization' | 'blocks'>, seen?: Set<Field>): boolean;

package/dist/transitions/contentFields.js

@@ -0,0 +1,20 @@
+/** Payload keeps both inline definitions and slug references in blockReferences. */ export function contentBlocks(field, blocks = []) {
+    return [
+        ...field.blocks,
+        ...(field.blockReferences ?? []).flatMap((reference)=>typeof reference === 'string' ? blocks.filter((block)=>block.slug === reference) : [
+                reference
+            ])
+    ];
+}
+/** Any localized data makes a full-document publish unsafe in Payload 3.90. */ export function hasLocalizedFields(fields, config, seen = new Set()) {
+    if (!config.localization) return false;
+    const blocks = config.blocks ?? [];
+    return fields.some((field)=>{
+        if (seen.has(field)) return false;
+        const branch = new Set(seen).add(field);
+        if ('localized' in field && field.localized) return true;
+        if ('tabs' in field && field.tabs.some((tab)=>tab.localized || hasLocalizedFields(tab.fields, config, branch))) return true;
+        if ('fields' in field && hasLocalizedFields(field.fields, config, branch)) return true;
+        return field.type === 'blocks' && contentBlocks(field, blocks).some((block)=>hasLocalizedFields(block.fields, config, branch));
+    });
+}

package/dist/transitions/decide.js

@@ -1,3 +1,4 @@
+import { DEFAULT_SEQUENTIAL_TUNING_PARAMETER } from '../constants.js';
 import { reclaimSlices } from '../db/slices.js';
 import { decideGuard } from '../results/decideGuard.js';
 import { relationshipId } from './checkStart.js';
@@ -112,7 +113,11 @@ export async function decide(req, { experimentId, winnerArm, note, confirmation
                 allocationChanges: [],
                 targeting: test.targeting,
                 metricDefinitions: test.metricDefinitions,
-                analysis: test.analysis,
+                analysis: {
+                    ...test.analysis,
+                    // Older test phases may predate freezing the effective tuning value.
+                    sequentialTuningParameter: test.analysis?.sequentialTuningParameter ?? DEFAULT_SEQUENTIAL_TUNING_PARAMETER
+                },
                 contentChanges: []
             });
         }

package/dist/transitions/deleteExperiment.js

@@ -1,3 +1,4 @@
+import { safeError } from '../log.js';
 import { txExecutor } from '../db/executor.js';
 import { deleteExperimentSnapshots, serializeDelete } from '../db/delete.js';
 import { deleteExperimentEvents } from '../db/events.js';
@@ -45,7 +46,7 @@ import { readExperiment, refuse } from './start.js';
         } catch (error) {
             req.payload.logger.error({
                 experimentId,
-                err: error
+                err: safeError(error)
             }, 'Experiment cascade failed; aborting delete');
             throw error;
         }

package/dist/transitions/dismissContentEntry.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadRequest } from 'payload';
+import type { DocId } from '../types/contracts.js';
+import type { DismissContentEntryBody } from '../types/endpoints.js';
+export declare function dismissContentEntry(req: PayloadRequest, { experimentId, collection, id }: DismissContentEntryBody & {
+    experimentId: DocId;
+}): Promise<{
+    doc: import("payload").JsonObject & import("payload").TypeWithID;
+}>;

package/dist/transitions/dismissContentEntry.js

@@ -0,0 +1,45 @@
+import { relationshipId } from './checkStart.js';
+import { withTransition } from './kernel.js';
+import { readExperiment, refuse, updateExperiment } from './start.js';
+export async function dismissContentEntry(req, { experimentId, collection, id }) {
+    const before = await readExperiment(req, experimentId);
+    // Only the audit report changes; assignment and the manifest stay the same.
+    const { result: doc } = await withTransition(req, {
+        experimentId,
+        layerId: relationshipId(before.layer),
+        flagPointId: before.kind === 'flag' ? before.flagPoint : undefined,
+        bump: false
+    }, async ({ req })=>{
+        const current = await readExperiment(req, experimentId);
+        const decision = current.decision;
+        const report = decision?.contentReport;
+        const index = Array.isArray(report?.docs) ? report.docs.findIndex((entry)=>entry.collection === collection && String(entry.id) === String(id)) : -1;
+        const entry = report?.docs?.[index];
+        if (current.status !== 'decided' || !decision?.winnerArm || decision.discardedAt) refuse('not-decided');
+        if (!entry) refuse('entry-not-found');
+        if (entry.ok !== false) refuse('entry-ok');
+        if (entry.dismissedAt) refuse('entry-dismissed');
+        const docs = report.docs.map((entry, i)=>i === index ? {
+                ...entry,
+                dismissedAt: new Date().toISOString(),
+                dismissedBy: req.user?.id == null ? null : String(req.user.id)
+            } : entry);
+        return updateExperiment(req, experimentId, {
+            decision: {
+                ...decision,
+                contentReport: {
+                    ...report,
+                    docs
+                }
+            }
+        });
+    });
+    req.payload.logger.info({
+        experimentId,
+        collection,
+        id
+    }, 'Experiment content entry dismissed');
+    return {
+        doc
+    };
+}

package/dist/transitions/makeContent.d.ts

@@ -1,11 +1,14 @@
 import { type PayloadRequest } from 'payload';
+import type { ContentReportReason } from '../types/reasons.js';
 import type { DocId, ResolvedOptions } from '../types/contracts.js';
 type ContentDoc = {
     collection: string;
     id: DocId;
     ok: boolean;
-    detail?: string;
-    error?: string;
+    detail?: ContentReportReason;
+    error?: ContentReportReason;
+    dismissedAt?: string;
+    dismissedBy?: string | null;
 };
 export declare function makeContent<TUser extends {
     id: DocId;