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

package/dist/db/pageOccupancy.js

@@ -0,0 +1,45 @@
+import { COLUMNS, TABLES } from './names.js';
+import { qualifiedTable, quoteIdentifier as q } from './sql.js';
+/** Page tests that occupy paths, with the arms the runtime routes on (`compileManifest`):
+ * - running or decided: the latest round's arms, or for a rollout the latest test round's;
+ * - archived with a standing result (winner, not discarded, pages not released): the latest test
+ *   round's arms whose paths are rewritten to the winner (archivedPages), so a new test cannot
+ *   silently take them over.
+ * Documents' arms may have been edited while stopped, so occupancy never reads them. */ export async function routedPageTests(exec) {
+    const e = COLUMNS.experiments, p = COLUMNS.phases;
+    const experiments = qualifiedTable(exec, TABLES.experiments), phases = qualifiedTable(exec, TABLES.phases);
+    const testRound = `LEFT JOIN LATERAL (SELECT ${q(p.arms)} AS arms FROM ${phases}
+      WHERE ${q(p.experimentId)} = x.${q(e.id)} AND ${q(p.phaseKind)} = 'test' ORDER BY ${q(p.phase)} DESC LIMIT 1) test ON true`;
+    const { rows } = await exec.query(`
+    SELECT x.${q(e.id)} AS "id", CASE WHEN latest.kind = 'rollout' THEN test.arms ELSE latest.arms END AS "arms", NULL::text AS "winnerArm"
+    FROM ${experiments} x
+    JOIN LATERAL (SELECT ${q(p.phaseKind)} AS kind, ${q(p.arms)} AS arms FROM ${phases}
+      WHERE ${q(p.experimentId)} = x.${q(e.id)} ORDER BY ${q(p.phase)} DESC LIMIT 1) latest ON true
+    ${testRound}
+    WHERE x.${q(e.kind)} = 'page' AND x.${q(e.status)} IN ('running', 'decided')
+    UNION ALL
+    SELECT x.${q(e.id)} AS "id", test.arms AS "arms", x.${q(e.decisionWinnerArm)} AS "winnerArm"
+    FROM ${experiments} x
+    ${testRound}
+    WHERE x.${q(e.kind)} = 'page' AND x.${q(e.status)} = 'archived' AND x.${q(e.decisionWinnerArm)} IS NOT NULL
+      AND x.${q(e.decisionDiscardedAt)} IS NULL AND x.${q(e.decisionPagesReleasedAt)} IS NULL
+    ORDER BY "id"`, []);
+    const occupied = [];
+    for (const row of rows){
+        const arms = Array.isArray(row.arms) ? row.arms : [];
+        if (row.winnerArm == null) {
+            occupied.push({
+                id: row.id,
+                arms
+            });
+            continue;
+        }
+        // compileManifest's archivedPages rule: every arm path other than the winner's.
+        const winnerPath = arms.find((arm)=>arm.key === row.winnerArm)?.pageTarget;
+        if (winnerPath) occupied.push({
+            id: row.id,
+            arms: arms.filter((arm)=>arm.pageTarget && arm.pageTarget !== winnerPath)
+        });
+    }
+    return occupied;
+}

package/dist/db/publishedContent.d.ts

@@ -0,0 +1,10 @@
+import type { PayloadRequest } from 'payload';
+import type { DocId } from '../types/contracts.js';
+/** §7.8 make-content: the published main row, so Payload's draft baseline never fills a field (KI-1). */
+export declare function publishedContent(req: PayloadRequest, collection: string, id: DocId): Promise<(Record<string, unknown> & {
+    id: DocId;
+}) | null>;
+/** §7.8 make-content: the latest draft version, so restoring the draft never drops fields the manager cannot read (KI-1). */
+export declare function latestDraftContent(req: PayloadRequest, collection: string, id: DocId): Promise<(Record<string, unknown> & {
+    id: DocId;
+}) | undefined>;

package/dist/db/publishedContent.js

@@ -0,0 +1,43 @@
+// Keep this module adapter-only: the §7.8 exception does not permit Local API calls.
+/** §7.8 make-content: the published main row, so Payload's draft baseline never fills a field (KI-1). */ export async function publishedContent(req, collection, id) {
+    return req.payload.db.findOne({
+        collection,
+        req,
+        where: {
+            id: {
+                equals: id
+            }
+        },
+        // Static allow-list marker only; adapter reads have no access layer.
+        overrideAccess: true
+    });
+}
+/** §7.8 make-content: the latest draft version, so restoring the draft never drops fields the manager cannot read (KI-1). */ export async function latestDraftContent(req, collection, id) {
+    const { docs } = await req.payload.db.findVersions({
+        collection,
+        req,
+        limit: 1,
+        pagination: false,
+        sort: '-updatedAt',
+        where: {
+            and: [
+                {
+                    parent: {
+                        equals: id
+                    }
+                },
+                {
+                    latest: {
+                        equals: true
+                    }
+                }
+            ]
+        },
+        // Static allow-list marker only; adapter reads have no access layer.
+        overrideAccess: true
+    });
+    return docs[0] ? {
+        ...docs[0].version,
+        id
+    } : undefined;
+}

package/dist/db/results.d.ts

@@ -20,6 +20,8 @@ export interface MetricEventRow {
 export interface IdentityRow {
     anonymousId: string;
     userId: string;
+    verifiedAt: number | null;
+    ownedAt: number | null;
 }
 type PhaseQuery = {
     experimentId: DocId;

package/dist/db/results.js

@@ -91,12 +91,16 @@ function phaseFilter({ experimentId, phase, endedAt }, type) {
     const i = COLUMNS.identities;
     const rows = [];
     for(let offset = 0; offset < ids.length; offset += batchSize){
-        const result = await exec.query(`SELECT ${q(i.anonymousId)} AS "anonymousId", ${q(i.userId)} AS "userId" FROM ${qualifiedTable(exec, TABLES.identities)} WHERE ${q(i.anonymousId)} = ANY($1::text[]) ORDER BY ${q(i.anonymousId)}`, [
+        // Ownership is global to the user, including browsers outside these exposure batches.
+        const table = qualifiedTable(exec, TABLES.identities);
+        const result = await exec.query(`SELECT link.${q(i.anonymousId)} AS "anonymousId", link.${q(i.userId)} AS "userId", round(extract(epoch from link.${q(i.verifiedAt)}) * 1000)::bigint AS "verifiedAt", (SELECT round(extract(epoch from min(owner.${q(i.verifiedAt)})) * 1000)::bigint FROM ${table} owner WHERE owner.${q(i.userId)} = link.${q(i.userId)}) AS "ownedAt" FROM ${table} link WHERE link.${q(i.anonymousId)} = ANY($1::text[]) ORDER BY link.${q(i.anonymousId)}`, [
             ids.slice(offset, offset + batchSize)
         ]);
         rows.push(...result.rows.map((row)=>({
                 anonymousId: row.anonymousId,
-                userId: String(row.userId)
+                userId: String(row.userId),
+                verifiedAt: row.verifiedAt == null ? null : Number(row.verifiedAt),
+                ownedAt: row.ownedAt == null ? null : Number(row.ownedAt)
             })));
     }
     return rows;

package/dist/db/snapshots.d.ts

@@ -1,9 +1,10 @@
 import type { Payload } from 'payload';
-import type { DocId, UnitType } from '../types/contracts.js';
+import type { Arm, DocId, ExperimentKind, Status, UnitType } from '../types/contracts.js';
 import type { Snapshot } from '../types/snapshot.js';
 import type { AnalysisPhase, FrozenMetric } from '../results/analyse.js';
 import { type Executor } from './executor.js';
 export interface ResultsPhase extends AnalysisPhase {
+    arms: Array<AnalysisPhase['arms'][number] & Pick<Arm, 'pageTarget'>>;
     seed: string;
     allocation: number;
     metricDefinitions: Array<FrozenMetric & {
@@ -14,11 +15,18 @@ export interface ResultsPhase extends AnalysisPhase {
 }
 export interface ResultsCandidate {
     phase: ResultsPhase;
+    frozenSnapshot?: Snapshot | null;
+    kind?: ExperimentKind;
+    currentPhase?: number;
+    winnerArm?: string | null;
     unitType: UnitType;
     status: 'running' | 'stopped' | 'decided' | 'archived';
     latestComputedAt: string | null;
     testArms: Array<{
+        key: string;
         weight: number;
+        kind?: string;
+        pageTarget?: string;
     }>;
     layerSlug: string | null;
     layerSlices: number[] | null;
@@ -39,10 +47,14 @@ export declare function writeSnapshots(exec: Executor, snapshots: Snapshot[]): P
 /** Fetch pointers only, then the endpoint reads the bounded set through Payload
  * with req/overrideAccess:false. Called behind the readResults/manage gate. */
 export declare function newestSnapshotIds(exec: Executor, ids: DocId[], per: 'phase' | 'experiment'): Promise<DocId[]>;
-/** Called only behind the endpoint's readResults gate. Experiment collection
- * reads require manage, so read only the decision metadata needed by results. */
-export declare function resultsMetadata(exec: Executor, id: DocId): Promise<{
-    status: string;
+type ResultsMetadata = {
+    name: string | null;
+    kind: ExperimentKind;
+    status: Status;
     snapshotId: DocId | null;
     winnerArm: string | null;
-} | null>;
+};
+/** Called only behind the endpoint's readResults gate. Experiment collection
+ * reads require manage, so read only the identity and decision metadata needed by results. */
+export declare function resultsMetadata(exec: Executor, id: DocId): Promise<ResultsMetadata | null>;
+export {};

package/dist/db/snapshots.js

@@ -31,16 +31,33 @@ const LATE_BEACON_GRACE_MS = 24 * 60 * 60 * 1000;
       'startedAt', p.${q(p.startedAt)}, 'endedAt', p.${q(p.endedAt)}, 'seed', p.${q(p.seed)},
       'arms', p.${q(p.arms)}, 'allocation', p.${q(p.allocation)}, 'metricDefinitions', p.${q(p.metricDefinitions)},
       'analysis', p.${q(p.analysis)}, 'contentChanges', p.${q(p.contentChanges)}) AS "phase",
-    e.${q(e.unitType)} AS "unitType", e.${q(e.status)} AS "status",
-    (SELECT max(s.${q(s.computedAt)}) FROM ${snapshots} s WHERE s.${q(s.experimentId)} = p.${q(p.experimentId)} AND s.${q(s.phase)} = p.${q(p.phase)}) AS "latestComputedAt",
+    e.${q(e.kind)} AS "kind", e.${q(e.phase)} AS "currentPhase", e.${q(e.unitType)} AS "unitType", e.${q(e.status)} AS "status", e.${q(e.decisionWinnerArm)} AS "winnerArm",
+    latest."computedAt" AS "latestComputedAt",
     (SELECT t.${q(p.arms)} FROM ${phases} t WHERE t.${q(p.experimentId)} = p.${q(p.experimentId)} AND t.${q(p.phaseKind)} = 'test' AND t.${q(p.phase)} <= p.${q(p.phase)} ORDER BY t.${q(p.phase)} DESC LIMIT 1) AS "testArms",
+    frozen."snapshot" AS "frozenSnapshot",
     l.${q(l.slug)} AS "layerSlug", e.${q(e.layerSlices)} AS "layerSlices"
     FROM ${phases} p JOIN ${qualifiedTable(exec, TABLES.experiments)} e ON e.${q(e.id)} = p.${q(p.experimentId)}
     LEFT JOIN ${qualifiedTable(exec, TABLES.layers)} l ON l.${q(l.id)} = e.${q(e.layerId)}
-    WHERE (p.${q(p.endedAt)} IS NULL OR p.${q(p.endedAt)} >= $1)
-    AND NOT EXISTS (SELECT 1 FROM ${snapshots} frozen WHERE frozen.${q(s.experimentId)} = p.${q(p.experimentId)} AND frozen.${q(s.phase)} = p.${q(p.phase)}
-      AND frozen.${q(s.computedAt)} > p.${q(p.endedAt)} + $2 * interval '1 millisecond')${experimentId === undefined ? '' : ` AND p.${q(p.experimentId)} = $3`}
-    ORDER BY "latestComputedAt" NULLS FIRST, p.${q(p.experimentId)}, p.${q(p.phase)}`, params);
+    LEFT JOIN LATERAL (SELECT max(s.${q(s.computedAt)}) AS "computedAt" FROM ${snapshots} s
+      WHERE s.${q(s.experimentId)} = p.${q(p.experimentId)} AND s.${q(s.phase)} = p.${q(p.phase)}) latest ON true
+    LEFT JOIN LATERAL (SELECT s.${q(s.snapshot)} AS "snapshot" FROM ${snapshots} s
+      WHERE s.${q(s.experimentId)} = p.${q(p.experimentId)} AND s.${q(s.phase)} = p.${q(p.phase)}
+        AND p.${q(p.endedAt)} IS NOT NULL
+        AND (s.${q(s.computedAt)} > p.${q(p.endedAt)} + $2 * interval '1 millisecond' OR p.${q(p.endedAt)} < $1)
+      ORDER BY s.${q(s.computedAt)} DESC, s.${q(s.id)} DESC LIMIT 1) frozen ON true
+    WHERE ((e.${q(e.kind)} = 'page'
+        AND (p.${q(p.endedAt)} IS NULL OR p.${q(p.endedAt)} >= $1 OR EXISTS
+          (SELECT 1 FROM ${snapshots} existing WHERE existing.${q(s.experimentId)} = p.${q(p.experimentId)} AND existing.${q(s.phase)} = p.${q(p.phase)}))
+        AND e.${q(e.status)} IN ('running', 'decided') AND (p.${q(p.phase)} = e.${q(e.phase)}
+        OR p.${q(p.phase)} = (SELECT max(active.${q(p.phase)}) FROM ${phases} active WHERE active.${q(p.experimentId)} = e.${q(e.id)} AND active.${q(p.phaseKind)} = 'test')))
+      OR ((p.${q(p.endedAt)} IS NULL OR p.${q(p.endedAt)} >= $1)
+        AND NOT EXISTS (SELECT 1 FROM ${snapshots} done WHERE done.${q(s.experimentId)} = p.${q(p.experimentId)} AND done.${q(s.phase)} = p.${q(p.phase)}
+          AND done.${q(s.computedAt)} > p.${q(p.endedAt)} + $2 * interval '1 millisecond')))
+      ${experimentId === undefined ? '' : ` AND p.${q(p.experimentId)} = $3`}
+    ORDER BY (frozen."snapshot" IS NOT NULL),
+      CASE WHEN frozen."snapshot" IS NULL THEN latest."computedAt" END NULLS FIRST,
+      CASE WHEN frozen."snapshot" IS NOT NULL THEN random() END,
+      p.${q(p.experimentId)}, p.${q(p.phase)}`, params);
     return rows;
 }
 export async function writeSnapshot(exec, snapshot) {
@@ -80,9 +97,9 @@ export async function writeSnapshot(exec, snapshot) {
     return rows.map((row)=>row.id);
 }
 /** Called only behind the endpoint's readResults gate. Experiment collection
- * reads require manage, so read only the decision metadata needed by results. */ export async function resultsMetadata(exec, id) {
+ * reads require manage, so read only the identity and decision metadata needed by results. */ export async function resultsMetadata(exec, id) {
     const c = COLUMNS.experiments;
-    const { rows } = await exec.query(`SELECT ${q(c.status)} AS "status", ${q(c.decisionSnapshotId)} AS "snapshotId", ${q(c.decisionWinnerArm)} AS "winnerArm" FROM ${qualifiedTable(exec, TABLES.experiments)} WHERE ${q(c.id)} = $1`, [
+    const { rows } = await exec.query(`SELECT ${q(c.name)} AS "name", ${q(c.kind)} AS "kind", ${q(c.status)} AS "status", ${q(c.decisionSnapshotId)} AS "snapshotId", ${q(c.decisionWinnerArm)} AS "winnerArm" FROM ${qualifiedTable(exec, TABLES.experiments)} WHERE ${q(c.id)} = $1`, [
         id
     ]);
     return rows[0] ?? null;

package/dist/db/sweep.js

@@ -11,6 +11,13 @@ import { ResultsBudgetError } from './pgExecutor.js';
     const events = qualifiedTable(exec, TABLES.events), phases = qualifiedTable(exec, TABLES.phases);
     const revision = `(SELECT ${q(s.revision)} FROM ${qualifiedTable(exec, TABLES.state)} LIMIT 1)`;
     let swept = 0;
+    const warnNoProgress = ()=>logger?.warn('Experiment retention sweep made no progress before its budget expired; eligible rows may remain.');
+    // Every budget-limited exit with nothing swept is reported, whether the budget ran out mid-statement (the catch
+    // below) or before the next batch could start (here).
+    const finish = ()=>{
+        if (swept === 0 && !shouldContinue()) warnNoProgress();
+        return swept;
+    };
     // Each statement still uses the caller's budget/race-aware executor.
     async function batches(predicate, order, params = []) {
         while(shouldContinue()){
@@ -38,7 +45,7 @@ import { ResultsBudgetError } from './pgExecutor.js';
                 type
             ]);
         }
-        if (!shouldContinue()) return swept;
+        if (!shouldContinue()) return finish();
         // Final-endedAt retention protects every phase while any phase is open.
         const ended = await exec.query(`SELECT ${q(p.experimentId)} AS "experimentId" FROM ${phases}
       WHERE ${q(p.experimentId)} IS NOT NULL GROUP BY ${q(p.experimentId)}
@@ -54,7 +61,7 @@ import { ResultsBudgetError } from './pgExecutor.js';
                 cutoff
             ]);
         }
-        if (!shouldContinue()) return swept;
+        if (!shouldContinue()) return finish();
         // Every protected window ends at/after cutoff (or is open). For old
         // conversions their union therefore starts at the earliest lookback start;
         // everything before that single bound is safe. Compute it once, in the same
@@ -80,11 +87,9 @@ import { ResultsBudgetError } from './pgExecutor.js';
             before,
             frozen.revision
         ]);
-        return swept;
+        return finish();
     } catch (error) {
-        if (swept === 0 && error instanceof ResultsBudgetError) {
-            logger?.warn('Experiment retention sweep made no progress before its budget expired; eligible rows may remain.');
-        }
+        if (swept === 0 && error instanceof ResultsBudgetError) warnNoProgress();
         throw error;
     }
 }

package/dist/endpoints/index.js

@@ -4,7 +4,7 @@ import { XpNotImplemented, XpRefusal } from '../errors.js';
 import { readUnitCookie } from '../runtime/cookie.js';
 import { handleManifest } from './manifest.js';
 import { handleEvents } from './events.js';
-import { handleStart, handleAllocate, handleAddMetric, handleStop, handleDecide, handleReleaseHoldout, handleMakeContent, handleArchive } from './transitions.js';
+import { handleStart, handleAllocate, handleAddMetric, handleStop, handleDecide, handleReleaseHoldout, handleReleasePages, handleMakeContent, handleDismissContentEntry, handleRestoreContentEntry, handleArchive } from './transitions.js';
 import { handlePreflight } from './preflight.js';
 import { handlePreviewToken } from './previewToken.js';
 import { handleResults } from './results.js';
@@ -59,12 +59,30 @@ export const ROUTES = [
         access: 'manage',
         handler: handleReleaseHoldout
     },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/release-pages',
+        access: 'manage',
+        handler: handleReleasePages
+    },
     {
         method: 'post',
         path: '/xp/experiments/:id/make-content',
         access: 'manage',
         handler: handleMakeContent
     },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/content-report/dismiss',
+        access: 'manage',
+        handler: handleDismissContentEntry
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/content-report/restore',
+        access: 'manage',
+        handler: handleRestoreContentEntry
+    },
     {
         method: 'post',
         path: '/xp/experiments/:id/archive',

package/dist/endpoints/results.js

@@ -111,6 +111,11 @@ export async function handleResults(req, _ctx) {
     if (selected !== null && !records.some((record)=>record.phase === phase)) return resultsError(404, 'not-found', 'Round not found');
     const snapshot = snapshots.find((snapshot)=>snapshot.phase === phase)?.snapshot ?? null;
     const response = {
+        experiment: {
+            name: metadata.name ?? '',
+            kind: metadata.kind,
+            status: metadata.status
+        },
         phases,
         snapshot,
         ...decision ? {

package/dist/endpoints/sanitizeReadinessDetail.d.ts

@@ -0,0 +1 @@
+export { sanitizeReadinessDetail } from '../sanitizeReadinessDetail.js';

package/dist/endpoints/sanitizeReadinessDetail.js

@@ -0,0 +1,2 @@
+// Shared with the admin home; keep this server import path stable.
+export { sanitizeReadinessDetail } from '../sanitizeReadinessDetail.js';

package/dist/endpoints/summary.js

@@ -2,6 +2,7 @@ import { checkStart } from '../transitions/checkStart.js';
 import { loadStartInputsBatch } from '../transitions/preflightData.js';
 import { readSnapshots, resultsError } from './results.js';
 import { experimentId } from './routeId.js';
+import { sanitizeReadinessDetail } from './sanitizeReadinessDetail.js';
 export async function handleSummary(req, { options }) {
     let ids;
     try {
@@ -40,7 +41,13 @@ export async function handleSummary(req, { options }) {
             verdict: {
                 code: snapshot.verdict.code,
                 headline: snapshot.verdict.headline
-            }
+            },
+            ...snapshot.health ? {
+                health: snapshot.health.slice(0, 100).map(({ code, path })=>({
+                        code,
+                        path: path.slice(0, 128)
+                    }))
+            } : {}
         } : {
             exposures: 0,
             days: 0,
@@ -72,7 +79,18 @@ export async function handleSummary(req, { options }) {
                 if (!experiment) continue;
                 const input = inputs.get(String(experiment.id));
                 try {
-                    response[key].ready = !!input && checkStart(input).every((check)=>check.ok);
+                    const checks = input ? checkStart(input) : [];
+                    response[key].ready = !!input && checks.every((check)=>check.ok);
+                    const next = checks.find((check)=>!check.ok && !check.warning);
+                    if (next) {
+                        const detail = sanitizeReadinessDetail(next.code, next.detail);
+                        response[key].next = {
+                            code: next.code,
+                            ...detail === undefined ? {} : {
+                                detail
+                            }
+                        };
+                    }
                 } catch  {
                     response[key].ready = false;
                 }

package/dist/endpoints/transitions.d.ts

@@ -35,6 +35,21 @@ export declare function handleMakeContent<TUser extends {
 } = {
     id: string | number;
 }>(req: PayloadRequest, ctx: EndpointContext<TUser>): Promise<Response>;
+export declare function handleReleasePages<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, _ctx: EndpointContext<TUser>): Promise<Response>;
+export declare function handleDismissContentEntry<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, _ctx: EndpointContext<TUser>): Promise<Response>;
+export declare function handleRestoreContentEntry<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, _ctx: EndpointContext<TUser>): Promise<Response>;
 export declare function handleArchive<TUser extends {
     id: string | number;
 } = {

package/dist/endpoints/transitions.js

@@ -5,6 +5,9 @@ import { addMetric } from '../transitions/addMetric.js';
 import { stop } from '../transitions/stop.js';
 import { decide } from '../transitions/decide.js';
 import { releaseHoldout } from '../transitions/releaseHoldout.js';
+import { releasePages } from '../transitions/releasePages.js';
+import { dismissContentEntry } from '../transitions/dismissContentEntry.js';
+import { restoreContentEntry } from '../transitions/restoreContentEntry.js';
 import { makeContent } from '../transitions/makeContent.js';
 import { archive } from '../transitions/archive.js';
 import { routeId } from './routeId.js';
@@ -135,6 +138,39 @@ export async function handleMakeContent(req, ctx) {
             options: ctx.options
         }));
 }
+export async function handleReleasePages(req, _ctx) {
+    const value = await body(req);
+    if (!value || !only(value, [])) return invalidBody();
+    return respond(req, (id)=>releasePages(req, {
+            experimentId: id
+        }));
+}
+export async function handleDismissContentEntry(req, _ctx) {
+    const value = await body(req);
+    if (!value || !only(value, [
+        'collection',
+        'id'
+    ]) || typeof value.collection !== 'string' || !value.collection.trim() || !(typeof value.id === 'string' && value.id.trim() || typeof value.id === 'number' && Number.isSafeInteger(value.id))) return invalidBody();
+    const collection = value.collection, id = value.id;
+    return respond(req, (experimentId)=>dismissContentEntry(req, {
+            experimentId,
+            collection,
+            id
+        }));
+}
+export async function handleRestoreContentEntry(req, _ctx) {
+    const value = await body(req);
+    if (!value || !only(value, [
+        'collection',
+        'id'
+    ]) || typeof value.collection !== 'string' || !value.collection.trim() || !(typeof value.id === 'string' && value.id.trim() || typeof value.id === 'number' && Number.isSafeInteger(value.id))) return invalidBody();
+    const collection = value.collection, id = value.id;
+    return respond(req, (experimentId)=>restoreContentEntry(req, {
+            experimentId,
+            collection,
+            id
+        }));
+}
 export async function handleArchive(req, _ctx) {
     const value = await body(req);
     if (!value || !only(value, [

package/dist/errors.d.ts

@@ -25,3 +25,11 @@ export declare class XpRefusal extends Error {
     readonly isPublic = true;
     constructor(code: RefusalCode, message: string, detail: unknown | undefined, status: 409 | 422 | 500 | 404);
 }
+/** Fixed analysis diagnostics: callers can choose a code, never supply log text. */
+export type AnalysisErrorCode = 'no-baseline' | 'primary-metric-count' | 'duplicate-metric' | 'invalid-timestamp' | 'window-hours' | 'window-before-start' | 'unknown-arm' | 'metric-not-supplied' | 'non-finite-values' | 'non-finite-covariates' | 'source-unavailable' | 'unit-type-unavailable' | 'srm-weights' | 'cuped-non-finite' | 'cuped-binomial' | 'seed-format' | 'snapshot-shape' | 'snapshot-invariants';
+export declare const ANALYSIS_ERROR_MESSAGES: Readonly<Record<AnalysisErrorCode, string>>;
+export declare class XpAnalysisError extends Error {
+    name: string;
+    readonly code: AnalysisErrorCode;
+    constructor(code: AnalysisErrorCode);
+}

package/dist/errors.js

@@ -31,3 +31,31 @@ export class XpRefusal extends Error {
         super(message), this.code = code, this.detail = detail, this.status = status;
     }
 }
+export const ANALYSIS_ERROR_MESSAGES = Object.freeze({
+    'no-baseline': 'Phase comparison baseline or shipped arm is missing',
+    'primary-metric-count': 'Phase must have exactly one primary metric',
+    'duplicate-metric': 'Duplicate metric id',
+    'invalid-timestamp': 'Event or exposure timestamp is invalid',
+    'window-hours': 'Attribution window must be a finite number of hours greater than 0',
+    'window-before-start': 'Analysis window ends before the phase starts',
+    'unknown-arm': 'Exposed unit has an unknown arm',
+    'metric-not-supplied': 'Metric data was not supplied',
+    'non-finite-values': 'Metric values must be finite',
+    'non-finite-covariates': 'Covariates must be finite',
+    'source-unavailable': 'Metric source unavailable',
+    'unit-type-unavailable': 'Metric unit type unavailable',
+    'srm-weights': 'SRM requires positive weights',
+    'cuped-non-finite': 'Metric values and covariates must be finite',
+    'cuped-binomial': 'Binomial values and covariates must be 0 or 1',
+    'seed-format': 'Assignment seed must end in |',
+    'snapshot-shape': 'Invalid Snapshot shape (all numbers must be finite)',
+    'snapshot-invariants': 'Invalid Snapshot invariants'
+});
+export class XpAnalysisError extends Error {
+    name = 'XpAnalysisError';
+    code;
+    constructor(code){
+        super(ANALYSIS_ERROR_MESSAGES[code]);
+        this.code = code;
+    }
+}

package/dist/exports/adminRsc.d.ts

@@ -1,3 +1,4 @@
 export { ExperimentsRootView } from '../admin/views/ExperimentsRootView.js';
 export { CollectionListRedirect } from '../admin/views/CollectionListRedirect.js';
 export { CollectionEditRedirect } from '../admin/views/CollectionEditRedirect.js';
+export { TestsNavLinkServer } from '../admin/views/TestsNavLinkServer.js';

package/dist/exports/adminRsc.js

@@ -1,3 +1,4 @@
 export { ExperimentsRootView } from '../admin/views/ExperimentsRootView.js';
 export { CollectionListRedirect } from '../admin/views/CollectionListRedirect.js';
 export { CollectionEditRedirect } from '../admin/views/CollectionEditRedirect.js';
+export { TestsNavLinkServer } from '../admin/views/TestsNavLinkServer.js';

package/dist/exports/index.d.ts

@@ -1,4 +1,5 @@
 export { createExperimentsPlugin } from '../plugin.js';
 export { defineFlagPoint, defineMetricSource } from '../define.js';
+export { contentDone } from '../contentDone.js';
 export { createArmSelectField } from '../fields/armSelect.js';
-export type { SerializedFlagPoint, SerializedMetricSource, SerializedAttributeKeys, EditableField, Assignment, Assignments, FlagPointResult, ClientAssignments, RenderedExposure, DocId, Attributes, ExposurePolicy, ExperimentKind, Status, UnitType, ArmKey, ArmKind, TargetingRule, Arm, ParamField, MetricSource, FlagPoint, RateLimiter, ExperimentsAccess, ExperimentsPluginOptions, ArmIssueCode, RefusalCode, ReadinessCode, ErrorEnvelope, TransitionSuccess, AllocateBody, AddMetricBody, DecideBody, ArchiveBody, MakeContentResult, PreflightResult, PreviewTokenResult, PhaseSummary, ResultsResponse, SummaryResponse, EventBody, FlagDefault, Manifest, ManifestExperiment, ArmSlot, ExperimentRef, ExperimentSlotProps, ExperimentsProxyRuntimeOptions, ExperimentsProxyRuntime, ExperimentsServerRuntimeOptions, ExperimentsServerRuntime, VerdictCode, Snapshot, } from '../types/index.js';
+export type { SerializedFlagPoint, SerializedMetricSource, SerializedAttributeKeys, EditableField, Assignment, Assignments, FlagPointResult, ClientAssignments, RenderedExposure, DocId, PreviewPlacement, Attributes, ExposurePolicy, ExperimentKind, Status, UnitType, ArmKey, ArmKind, TargetingRule, Arm, ParamField, MetricSource, FlagPoint, RateLimiter, ExperimentsAccess, ExperimentsPluginOptions, ExperimentsPageCollection, ArmIssueCode, RefusalCode, ReadinessCode, ErrorEnvelope, TransitionSuccess, AllocateBody, AddMetricBody, DecideBody, ArchiveBody, MakeContentResult, DismissContentEntryBody, DismissContentEntryResult, RestoreContentEntryBody, RestoreContentEntryResult, ContentReport, PreflightResult, PreviewTokenResult, PhaseSummary, ResultsResponse, SummaryResponse, EventBody, FlagDefault, Manifest, ManifestExperiment, ArmSlot, ExperimentRef, ExperimentSlotProps, ExperimentsProxyRuntimeOptions, ExperimentsProxyRuntime, ExperimentsServerRuntimeOptions, ExperimentsServerRuntime, VerdictCode, Snapshot, MetricUnavailableReason, ContentReportReason, } from '../types/index.js';

package/dist/exports/index.js

@@ -1,3 +1,4 @@
 export { createExperimentsPlugin } from '../plugin.js';
 export { defineFlagPoint, defineMetricSource } from '../define.js';
+export { contentDone } from '../contentDone.js';
 export { createArmSelectField } from '../fields/armSelect.js';

package/dist/exports/puck.d.ts

@@ -1,4 +1,5 @@
-export { ExperimentSlot } from '../puck/ExperimentSlot.js';
+export { ExperimentSlot, createExperimentSlot } from '../puck/ExperimentSlot.js';
 export { createExperimentSlotField } from '../puck/experimentSlotField.js';
 export { EXPERIMENT_SLOT_TYPE } from '../types/puck.js';
 export type { ArmSlot, ExperimentRef, ExperimentSlotProps } from '../types/puck.js';
+export type { PuckRoutes } from '../puck/routes.js';

package/dist/exports/puck.js

@@ -1,3 +1,3 @@
-export { ExperimentSlot } from '../puck/ExperimentSlot.js';
+export { ExperimentSlot, createExperimentSlot } from '../puck/ExperimentSlot.js';
 export { createExperimentSlotField } from '../puck/experimentSlotField.js';
 export { EXPERIMENT_SLOT_TYPE } from '../types/puck.js';

package/dist/exports/puckEditor.d.ts

@@ -1 +1,4 @@
-export { ExperimentSlotEditor } from '../puck/editor/ExperimentSlotEditor.js';
+export { ExperimentSlotEditor, createExperimentSlotEditor } from '../puck/editor/ExperimentSlotEditor.js';
+export { experimentOutlinePlugin } from '../puck/editor/experimentOutlinePlugin.js';
+export { deriveAccent } from '../ui/accent.js';
+export type { PuckRoutes } from '../puck/routes.js';

package/dist/exports/puckEditor.js

@@ -1,2 +1,4 @@
 'use client';
-export { ExperimentSlotEditor } from '../puck/editor/ExperimentSlotEditor.js';
+export { ExperimentSlotEditor, createExperimentSlotEditor } from '../puck/editor/ExperimentSlotEditor.js';
+export { experimentOutlinePlugin } from '../puck/editor/experimentOutlinePlugin.js';
+export { deriveAccent } from '../ui/accent.js';

package/dist/exports/rsc.d.ts

@@ -2,12 +2,17 @@ export { getAssignments } from '../server/getAssignments.js';
 export { resolveExperimentData } from '../server/resolveExperimentData.js';
 export { recordExposures } from '../server/recordExposures.js';
 export { getFlagPoint } from '../server/getFlagPoint.js';
-export { linkIdentity } from '../server/linkIdentity.js';
+export { linkIdentity, type LinkIdentityOutcome } from '../server/linkIdentity.js';
 export { trackConversion } from '../server/trackConversion.js';
 export { eraseUser } from '../server/eraseUser.js';
+export type { MetricUnavailableReason, ContentReportReason } from '../types/reasons.js';
+export type { PreviewPlacement } from '../types/contracts.js';
 export { runResults } from '../server/runResults.js';
 export { recordContentChange } from '../server/recordContentChange.js';
 export { experimentSitemapFilter } from '../server/sitemap.js';
 export { experimentMetadata } from '../server/metadata.js';
 export { toClientAssignments } from '../server/toClientAssignments.js';
+export { compileManifest } from '../manifest/compile.js';
+export type { ManifestInputs, ManifestInputExperiment, ManifestPhase, ManifestCompileOptions } from '../manifest/compile.js';
+export type { Manifest, ManifestExperiment } from '../types/manifest.js';
 export { contentChangesBeforeHook as captureContentBaseline } from '../hooks/contentChanges.js';

package/dist/exports/rsc.js

@@ -10,4 +10,6 @@ export { recordContentChange } from '../server/recordContentChange.js';
 export { experimentSitemapFilter } from '../server/sitemap.js';
 export { experimentMetadata } from '../server/metadata.js';
 export { toClientAssignments } from '../server/toClientAssignments.js';
+// Pure manifest builder for host tests (CORE-43): the same compile transitions run, with no database access.
+export { compileManifest } from '../manifest/compile.js';
 export { contentChangesBeforeHook as captureContentBaseline } from '../hooks/contentChanges.js';

package/dist/hooks/pageGuard.d.ts

@@ -0,0 +1,5 @@
+import type { CollectionAfterOperationHook, CollectionBeforeChangeHook, CollectionBeforeDeleteHook, CollectionBeforeOperationHook } from 'payload';
+export declare const pageGuardBeforeOperation: CollectionBeforeOperationHook;
+export declare const pageGuardAfterOperation: CollectionAfterOperationHook;
+export declare const pageGuardBeforeDelete: CollectionBeforeDeleteHook;
+export declare const pageGuardBeforeChange: CollectionBeforeChangeHook;