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

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/events.js

@@ -1,3 +1,4 @@
+import { safeError } from '../log.js';
 import { NextRequest } from 'next/server.js';
 import { DEFAULT_MAX_BODY_BYTES } from '../constants.js';
 import { pooledExecutor } from '../db/executor.js';
@@ -89,9 +90,8 @@ export async function handleEvents(req, { options }) {
     } catch (error) {
         try {
             req.payload.logger.error({
-                err: error,
-                msg: 'Experiments: events endpoint failed'
-            });
+                err: safeError(error)
+            }, 'Experiments: events endpoint failed');
         } catch  {}
     }
     return accepted();

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/recompute.js

@@ -1,3 +1,4 @@
+import { safeError } from '../log.js';
 import { runResults } from '../server/runResults.js';
 import { readSnapshots, resultsError } from './results.js';
 import { routeId } from './routeId.js';
@@ -39,7 +40,7 @@ export async function handleRecompute(req, _ctx) {
         });
     } catch (error) {
         req.payload.logger.error({
-            err: error,
+            err: safeError(error),
             experimentId: docs[0].id
         }, 'Experiment recompute failed');
         return resultsError(503, 'recompute-failed', 'Results could not be recomputed. Try again.');

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/adminClient.d.ts

@@ -1,3 +1,4 @@
+export { XP_IF_UPDATED_AT_HEADER } from '../constants.js';
 export { LayerUsage } from '../admin/LayerUsage.js';
 export { MetricSourceSelect } from '../admin/MetricSourceSelect.js';
 export { ArmSelectField } from '../admin/armSelect/ArmSelectField.js';

package/dist/exports/adminClient.js

@@ -1,4 +1,5 @@
 'use client';
+export { XP_IF_UPDATED_AT_HEADER } from '../constants.js';
 export { LayerUsage } from '../admin/LayerUsage.js';
 export { MetricSourceSelect } from '../admin/MetricSourceSelect.js';
 export { ArmSelectField } from '../admin/armSelect/ArmSelectField.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, 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, 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/puckEditor.d.ts

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

package/dist/exports/puckEditor.js

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

package/dist/exports/rsc.d.ts

@@ -2,12 +2,16 @@ 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 { 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/hostHook.js

@@ -1,9 +1,10 @@
+import { safeError } from '../log.js';
 /** Host saves must survive synchronous and asynchronous plugin hook failures. */ export function neverThrow(name, hook) {
     return async (args)=>{
         try {
             return await hook(args);
         } catch (error) {
-            console.error(`[payload-experiments] ${name} failed; the document was saved without it`, error);
+            console.error(`[payload-experiments] ${name} failed; the document was saved without it`, safeError(error));
             return args.doc;
         }
     };
@@ -13,7 +14,7 @@
         try {
             return await hook(args);
         } catch (error) {
-            console.error(`[payload-experiments] ${name} failed; the document was saved without it`, error);
+            console.error(`[payload-experiments] ${name} failed; the document was saved without it`, safeError(error));
             return args.data;
         }
     };

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;

package/dist/hooks/pageGuard.js

@@ -0,0 +1,121 @@
+import { previousPublishedContent } from '../db/appends.js';
+import { XpRefusal } from '../errors.js';
+import { pageGuardCopy, READINESS_COPY } from '../admin/copy/readiness.js';
+// createLocalReq replaces context with a shallow copy on nested calls. Keep
+// the shared stack in that context so both the outer req and its proxies see it.
+const operations = (req)=>req.context.xpPageGuardOperations;
+export const pageGuardBeforeOperation = ({ args, operation })=>{
+    if (operation !== 'update' && operation !== 'restoreVersion') return;
+    const call = args;
+    let collections = operations(call.req);
+    if (!collections) call.req.context.xpPageGuardOperations = collections = new Map();
+    const slug = call.collection.config.slug;
+    const stack = collections.get(slug) ?? [];
+    stack.push({
+        draft: call.draft === true,
+        restore: operation === 'restoreVersion'
+    });
+    collections.set(slug, stack);
+};
+export const pageGuardAfterOperation = ({ req, collection, operation, result })=>{
+    // beforeOperation reports by-id updates as 'update'; afterOperation reports 'updateByID'.
+    if (operation === 'update' || operation === 'updateByID' || operation === 'restoreVersion') {
+        const collections = operations(req);
+        const stack = collections?.get(collection.slug);
+        stack?.pop();
+        if (!stack?.length) collections?.delete(collection.slug);
+    }
+    return result;
+};
+async function protect(req, path) {
+    // page guard: the hook must see test placements regardless of the editor's access
+    const tests = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: true,
+        depth: 0,
+        limit: 0,
+        where: {
+            and: [
+                {
+                    kind: {
+                        equals: 'page'
+                    }
+                },
+                {
+                    status: {
+                        in: [
+                            'running',
+                            'decided',
+                            'archived'
+                        ]
+                    }
+                }
+            ]
+        }
+    });
+    for (const test of tests.docs){
+        const decision = test.decision;
+        const archived = test.status === 'archived';
+        if (archived && (!decision?.winnerArm || decision.discardedAt || decision.pagesReleasedAt)) continue;
+        // page guard: the hook must see test placements regardless of the editor's access
+        const phases = await req.payload.find({
+            collection: 'xp-phases',
+            req,
+            overrideAccess: true,
+            depth: 0,
+            limit: 1,
+            sort: '-phase',
+            where: {
+                experiment: {
+                    equals: test.id
+                },
+                phaseKind: {
+                    equals: 'test'
+                }
+            }
+        });
+        const phase = phases.docs[0];
+        if (!phase) throw new XpRefusal('invalid-phase', READINESS_COPY.missingVersions, {
+            experimentId: test.id
+        }, 409);
+        const arms = phase.arms;
+        const protectedArms = archived ? arms.filter((arm)=>arm.kind === 'control' || arm.key === decision.winnerArm) : arms;
+        if (protectedArms.some((arm)=>arm.pageTarget === path)) {
+            throw new XpRefusal('locked-placement', pageGuardCopy(String(test.name), test.status), {
+                experimentId: test.id
+            }, 409);
+        }
+    }
+}
+function registration(req, slug) {
+    return (req.payload.config.custom?.xp).pages?.collections.find((entry)=>entry.slug === slug);
+}
+export const pageGuardBeforeDelete = async ({ req, id, collection })=>{
+    const page = registration(req, collection.slug);
+    if (!page) return;
+    const published = await previousPublishedContent(req, collection.slug, id);
+    if (!published || published._status === 'draft') return;
+    const path = page.pathOf(published);
+    if (path !== null) await protect(req, path);
+};
+export const pageGuardBeforeChange = async ({ req, collection, originalDoc, operation, data })=>{
+    if (operation !== 'update') return data;
+    const page = registration(req, collection.slug);
+    if (!page) return data;
+    const drafts = Boolean(collection.versions && collection.versions.drafts);
+    // updateDocument computes isSavingDraft from draftArg and _status before
+    // beforeChange, and writes the main row only when !isSavingDraft.
+    const call = operations(req)?.get(collection.slug)?.at(-1);
+    if (drafts && call?.draft && (call.restore || data._status !== 'published')) return data;
+    const published = await previousPublishedContent(req, collection.slug, originalDoc.id);
+    if (!published || published._status === 'draft') return data;
+    const path = page.pathOf(published);
+    const unpublishing = drafts && data._status === 'draft';
+    const trashing = collection.trash && data.deletedAt != null && !originalDoc.deletedAt;
+    if (path !== null && (trashing || unpublishing || page.pathOf({
+        ...originalDoc,
+        ...data
+    }) !== path)) await protect(req, path);
+    return data;
+};

package/dist/labels/arms.d.ts

@@ -0,0 +1,7 @@
+export declare const ARM_LABELS: {
+    readonly control: "Original";
+    readonly variantA: "Variant A";
+    readonly variantB: "Variant B";
+    readonly variantC: "Variant C";
+    readonly holdout: "Holdout";
+};

package/dist/labels/arms.js

@@ -0,0 +1,7 @@
+export const ARM_LABELS = {
+    control: 'Original',
+    variantA: 'Variant A',
+    variantB: 'Variant B',
+    variantC: 'Variant C',
+    holdout: 'Holdout'
+};

package/dist/log.d.ts

@@ -0,0 +1,7 @@
+/** Deliberately construct a plain object: host serializers must never see the error. */
+export declare function safeError(err: unknown): {
+    name: string;
+    code?: string;
+    stack?: string;
+    message?: string;
+};

package/dist/log.js

@@ -0,0 +1,38 @@
+import { ANALYSIS_ERROR_MESSAGES, XpAnalysisError, XpNoTransactionError, XpNotImplemented, XpRefusal } from './errors.js';
+import { ResultsBudgetError } from './db/pgExecutor.js';
+/** Deliberately construct a plain object: host serializers must never see the error. */ export function safeError(err) {
+    try {
+        if (!(err instanceof Error)) return {
+            name: typeof err
+        };
+        const name = err.name;
+        const result = {
+            name: typeof name === 'string' ? name : 'Error'
+        };
+        const code = 'code' in err ? err.code : undefined;
+        const analysisCode = err instanceof XpAnalysisError && typeof code === 'string' && Object.hasOwn(ANALYSIS_ERROR_MESSAGES, code) ? code : undefined;
+        if (typeof code === 'string' && (/^[0-9A-Z]{5}$/.test(code) || err instanceof XpRefusal || analysisCode)) result.code = code;
+        const message = err.message;
+        const stack = err.stack;
+        // Remove the entire V8 header first: message lines can impersonate frames.
+        // Unknown stack formats fail closed. Never traverse cause or database fields.
+        if (typeof name === 'string' && typeof message === 'string' && typeof stack === 'string') {
+            const header = message ? `${name}: ${message}` : name;
+            const frames = stack.startsWith(`${header}\n`) ? stack.slice(header.length + 1).split('\n').filter((line)=>/^\s+at /.test(line)) : [];
+            if (frames.length) result.stack = frames.join('\n');
+        }
+        // XpRefusal includes stored slugs; XpLockedFieldError includes request keys
+        // and stored status. Neither class's message is safe to send to host logs.
+        // An analysis error's logged text always comes from the fixed table by code, never from err.message.
+        if (analysisCode) result.message = ANALYSIS_ERROR_MESSAGES[analysisCode];
+        else if (err instanceof XpNoTransactionError || err instanceof XpNotImplemented || err instanceof ResultsBudgetError) {
+            if (typeof message === 'string') result.message = message;
+        }
+        return result;
+    } catch  {
+        // Even instanceof, property existence checks and getters can throw on hosts' errors.
+        return {
+            name: 'Error'
+        };
+    }
+}

package/dist/manifest/compile.d.ts

@@ -35,6 +35,7 @@ export interface ManifestInputExperiment {
         winnerArm?: string | null;
         discardedAt?: string | null;
         holdoutReleasedAt?: string | null;
+        pagesReleasedAt?: string | null;
     } | null;
     currentPhase: ManifestPhase | null;
     lastTestPhase?: ManifestPhase | null;
@@ -50,6 +51,10 @@ export declare function loadManifestInputs(req: PayloadRequest, { excludeIds, pr
     pruneFlagDefaultIds?: DocId[];
 }): Promise<ManifestInputs>;
 /** Pure compiler. Assignment config comes exclusively from the frozen phase. */
+/**
+ * Pure manifest builder (exported from `/rsc` for host tests). Pass the same `attributeKeys` as the plugin options,
+ * or legacy untyped targeting rules are dropped. Its input shape may change in a pre-1.0 minor.
+ */
 export declare function compileManifest(inputs: ManifestInputs, revision: number, { attributeKeys, onInvalid }?: ManifestCompileOptions): Manifest;
 /** Take the state lock before reading inputs. Under READ COMMITTED, a builder
  * waiting for another transition then sees that transition's committed changes,

package/dist/manifest/compile.js

@@ -107,7 +107,10 @@ export async function loadManifestInputs(req, { excludeIds = [], pruneFlagDefaul
     });
     inputs.flagDefaults = defaults;
 }
-/** Pure compiler. Assignment config comes exclusively from the frozen phase. */ export function compileManifest(inputs, revision, { attributeKeys, onInvalid } = {}) {
+/** Pure compiler. Assignment config comes exclusively from the frozen phase. */ /**
+ * Pure manifest builder (exported from `/rsc` for host tests). Pass the same `attributeKeys` as the plugin options,
+ * or legacy untyped targeting rules are dropped. Its input shape may change in a pre-1.0 minor.
+ */ export function compileManifest(inputs, revision, { attributeKeys, onInvalid } = {}) {
     const excluded = new Set(inputs.excludeIds?.map(String));
     const prunedDefaults = new Set(inputs.pruneFlagDefaultIds?.map(String));
     const manifest = {
@@ -126,6 +129,7 @@ export async function loadManifestInputs(req, { excludeIds = [], pruneFlagDefaul
         const { decision, currentPhase: phase } = experiment;
         if (experiment.status === 'archived') {
             if (!decision?.winnerArm || decision.discardedAt) continue;
+            if (experiment.kind === 'page' && decision.pagesReleasedAt) continue;
             const testPhase = experiment.lastTestPhase ?? (phase?.phaseKind === 'test' ? phase : null);
             if (!testPhase) throw new XpRefusal('invalid-status', `Missing last test phase for experiment ${experiment.slug}`, undefined, 409);
             const winner = testPhase.arms.find((arm)=>arm.key === decision.winnerArm);