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

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

@@ -1,4 +1,4 @@
-import { XpNoTransactionError, XpNotImplemented, XpRefusal } from './errors.js';
+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 {
@@ -10,7 +10,8 @@ import { ResultsBudgetError } from './db/pgExecutor.js';
             name: typeof name === 'string' ? name : 'Error'
         };
         const code = 'code' in err ? err.code : undefined;
-        if (typeof code === 'string' && (/^[0-9A-Z]{5}$/.test(code) || err instanceof XpRefusal)) result.code = code;
+        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.
@@ -22,7 +23,9 @@ import { ResultsBudgetError } from './db/pgExecutor.js';
         }
         // XpRefusal includes stored slugs; XpLockedFieldError includes request keys
         // and stored status. Neither class's message is safe to send to host logs.
-        if (err instanceof XpNoTransactionError || err instanceof XpNotImplemented || err instanceof ResultsBudgetError) {
+        // 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;

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);

package/dist/options.js

@@ -1,3 +1,4 @@
+import { contrast, deriveAccent } from './ui/accent.js';
 import { DEFAULT_MAX_BODY_BYTES } from './constants.js';
 const normalisedCollections = new WeakMap();
 /** Resolve once per registration list; every consumer shares the same field defaults. */ export function puckCollections(options) {
@@ -54,6 +55,28 @@ export function resolveOptions(input) {
             }
         }
     }
+    if (input.pages !== undefined) {
+        if (!input.pages || !Array.isArray(input.pages.collections) || input.pages.collections.length === 0) throw new Error('Experiments pages.collections must be a non-empty array');
+        const slugs = new Set();
+        for (const entry of input.pages.collections){
+            if (!entry || typeof entry.slug !== 'string' || !entry.slug.trim() || slugs.has(entry.slug) || typeof entry.pathOf !== 'function' || typeof entry.findByPath !== 'function') {
+                throw new Error('Experiments pages.collections requires unique slugs, pathOf and findByPath functions');
+            }
+            slugs.add(entry.slug);
+        }
+    }
+    if (input.theme !== undefined) {
+        if (!input.theme || typeof input.theme !== 'object' || Array.isArray(input.theme)) throw new Error('Experiments theme must be an object');
+        for (const key of Object.keys(input.theme))if (key !== 'accent') throw new Error(`Unknown experiments theme option: ${key}`);
+        const accent = input.theme.accent;
+        if (accent !== undefined && accent !== '') {
+            if (typeof accent !== 'string' || !/^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test(accent)) throw new Error('Experiments theme.accent must be a CSS hex colour (#rgb or #rrggbb)');
+            for (const [mode, set] of Object.entries(deriveAccent(accent))){
+                const ratio = contrast(set.accent, set.fg);
+                if (ratio < 4.5) throw new Error(`Experiments theme.accent ${accent}: ${mode} foreground contrast ${ratio.toFixed(2)}:1 is below 4.5:1`);
+            }
+        }
+    }
     const ids = new Set();
     for (const point of input.flagPoints ?? []){
         if (typeof point.id !== 'string' || !point.id || ids.has(point.id)) throw new Error('Experiments flag point ids must be unique nonempty strings');

package/dist/plugin.js

@@ -1,6 +1,7 @@
 import { buildCollections } from './collections/index.js';
 import { buildEndpoints } from './endpoints/index.js';
 import { contentChangesBeforeHook, contentChangesHook } from './hooks/contentChanges.js';
+import { pageGuardAfterOperation, pageGuardBeforeChange, pageGuardBeforeDelete, pageGuardBeforeOperation } from './hooks/pageGuard.js';
 import { createOnInit } from './onInit.js';
 import { puckCollections, resolveOptions } from './options.js';
 import * as paths from './admin/paths.js';
@@ -11,6 +12,9 @@ export function createExperimentsPlugin(input) {
         for (const { slug } of registrations){
             if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments puck collection: ${slug}`);
         }
+        for (const { slug } of options.pages?.collections ?? []){
+            if (!config.collections?.some((collection)=>collection.slug === slug)) throw new Error(`Unknown experiments page collection: ${slug}`);
+        }
         // The frozen factories consume registration/access metadata, never TUser callbacks.
         // Erase the user subtype only at this non-generic factory boundary.
         const { collections, globals } = buildCollections(options);
@@ -50,15 +54,35 @@ export function createExperimentsPlugin(input) {
             collections: [
                 ...(config.collections ?? []).map((collection)=>{
                     const puck = options.puck?.enabled && registrations.some((entry)=>entry.slug === collection.slug);
-                    if (!puck) return collection;
+                    const page = options.pages?.collections.some((entry)=>entry.slug === collection.slug);
+                    if (!puck && !page) return collection;
                     return {
                         ...collection,
                         hooks: {
                             ...collection.hooks,
                             beforeChange: [
                                 ...collection.hooks?.beforeChange ?? [],
-                                contentChangesBeforeHook
+                                ...page ? [
+                                    pageGuardBeforeChange
+                                ] : [],
+                                ...puck ? [
+                                    contentChangesBeforeHook
+                                ] : []
                             ],
+                            ...page ? {
+                                beforeOperation: [
+                                    ...collection.hooks?.beforeOperation ?? [],
+                                    pageGuardBeforeOperation
+                                ],
+                                beforeDelete: [
+                                    ...collection.hooks?.beforeDelete ?? [],
+                                    pageGuardBeforeDelete
+                                ],
+                                afterOperation: [
+                                    pageGuardAfterOperation,
+                                    ...collection.hooks?.afterOperation ?? []
+                                ]
+                            } : {},
                             ...puck ? {
                                 afterChange: [
                                     ...collection.hooks?.afterChange ?? [],

package/dist/puck/copy.d.ts

@@ -9,7 +9,7 @@ export declare const pickerCopy: {
     readonly none: "No experiment";
     readonly loading: "Loading experiments…";
     readonly error: "Couldn't load experiments.";
-    readonly forbidden: "You can't see experiments. Ask an admin.";
+    readonly forbidden: "You can't see tests. Ask an admin.";
     readonly statuses: {
         readonly draft: "Draft";
         readonly running: "Running";

package/dist/puck/copy.js

@@ -10,7 +10,7 @@ export const pickerCopy = {
     none: 'No experiment',
     loading: 'Loading experiments…',
     error: "Couldn't load experiments.",
-    forbidden: "You can't see experiments. Ask an admin.",
+    forbidden: "You can't see tests. Ask an admin.",
     statuses: {
         draft: 'Draft',
         running: 'Running',