@delmaredigital/payload-experiments 0.3.0-rc.1 → 0.4.0-rc.1

package/dist/endpoints/pages.js

@@ -0,0 +1,120 @@
+import { normalisePath } from '../runtime/normalisePath.js';
+import { XpRefusal } from '../errors.js';
+export async function handlePages(req, { options }) {
+    const query = new URL(req.url ?? 'http://xp.invalid').searchParams;
+    const collection = options.pages?.collections.find((entry)=>entry.slug === query.get('collection'));
+    if (!collection) throw new XpRefusal('unknown-collection', "That page type isn't set up for tests.", undefined, 422);
+    const path = query.get('path');
+    if (path !== null && (!path.length || path.length > 2048 || query.has('q'))) throw new XpRefusal('invalid-body', 'Enter a valid request body.', undefined, 422);
+    const page = Number(query.get('page') ?? 1);
+    if (!Number.isSafeInteger(page) || page < 1 || page > 1000) throw new XpRefusal('invalid-body', 'Choose a valid page.', undefined, 422);
+    const config = req.payload.config.collections.find((entry)=>entry.slug === collection.slug);
+    const titleField = config?.admin.useAsTitle ?? 'title';
+    const drafts = Boolean(config?.versions && config.versions.drafts);
+    const q = query.get('q')?.trim().slice(0, 100);
+    if (path !== null) {
+        const found = await collection.findByPath(path, req);
+        if (!found) return Response.json({
+            docs: [],
+            hasNextPage: false
+        }, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+        const main = await req.payload.findByID({
+            collection: collection.slug,
+            id: found.id,
+            req,
+            overrideAccess: false,
+            depth: 0,
+            draft: false,
+            disableErrors: true
+        });
+        if (!main) return Response.json({
+            docs: [],
+            hasNextPage: false
+        }, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+        const published = !drafts || main._status === 'published';
+        const doc = published ? main : await req.payload.findByID({
+            collection: collection.slug,
+            id: main.id,
+            req,
+            overrideAccess: false,
+            depth: 0,
+            draft: true,
+            disableErrors: true
+        });
+        if (!doc) return Response.json({
+            docs: [],
+            hasNextPage: false
+        }, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+        const rawPath = collection.pathOf(doc);
+        return Response.json({
+            docs: [
+                {
+                    id: main.id,
+                    title: titleField !== 'id' && typeof doc[titleField] === 'string' && String(doc[titleField]).trim() ? String(doc[titleField]) : '',
+                    path: rawPath,
+                    pathKey: rawPath === null ? null : normalisePath(rawPath),
+                    published
+                }
+            ],
+            hasNextPage: false
+        }, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+    }
+    const result = await req.payload.find({
+        collection: collection.slug,
+        req,
+        overrideAccess: false,
+        depth: 0,
+        draft: false,
+        sort: '-createdAt',
+        limit: 20,
+        page,
+        where: q && titleField !== 'id' ? {
+            [titleField]: {
+                like: q
+            }
+        } : undefined
+    });
+    const docs = await Promise.all(result.docs.map(async (main)=>{
+        const published = !drafts || main._status === 'published';
+        const doc = published ? main : await req.payload.findByID({
+            collection: collection.slug,
+            id: main.id,
+            req,
+            overrideAccess: false,
+            depth: 0,
+            draft: true
+        });
+        const path = collection.pathOf(doc);
+        return {
+            id: main.id,
+            title: String(doc[titleField] ?? main.id),
+            path,
+            pathKey: path === null ? null : normalisePath(path),
+            published
+        };
+    }));
+    return Response.json({
+        docs,
+        hasNextPage: result.hasNextPage
+    }, {
+        headers: {
+            'Cache-Control': 'no-store'
+        }
+    });
+}

package/dist/endpoints/placementStatus.d.ts

@@ -0,0 +1,6 @@
+import type { PayloadRequest } from 'payload';
+import type { DocId } from '../types/contracts.js';
+import type { EndpointContext } from '../types/endpoints.js';
+export declare function handlePlacementStatus<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, { options }: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/placementStatus.js

@@ -0,0 +1,238 @@
+import { readBody } from './readBody.js';
+import { safeError } from '../log.js';
+import { statusPageContent } from '../db/pageContent.js';
+import { normalisePath } from '../runtime/normalisePath.js';
+import { puckCollections } from '../options.js';
+import { resolvePageCollection } from '../transitions/pageCollection.js';
+const error = (status, code, message)=>Response.json({
+        errors: [
+            {
+                code,
+                message
+            }
+        ]
+    }, {
+        status
+    });
+const object = (v)=>!!v && typeof v === 'object' && !Array.isArray(v);
+const id = (v)=>typeof v === 'string' && !!v.trim() || typeof v === 'number' && Number.isSafeInteger(v);
+export async function handlePlacementStatus(req, { options }) {
+    let value;
+    try {
+        value = await readBody(req);
+    } catch (cause) {
+        return error(cause instanceof RangeError ? 413 : 422, cause instanceof RangeError ? 'body-too-large' : 'invalid-body', 'Enter a valid request body.');
+    }
+    if (!object(value) || Object.keys(value).some((key)=>key !== 'docs' && key !== 'slugs') || value.docs !== undefined && !Array.isArray(value.docs) || value.slugs !== undefined && !Array.isArray(value.slugs)) return error(422, 'invalid-body', 'Enter a valid request body.');
+    if ((value.docs?.length ?? 0) > 100 || (value.slugs?.length ?? 0) > 100) return error(422, 'too-many-ids', 'Choose at most 100 documents and slugs.');
+    if (value.docs?.some((doc)=>!object(doc) || typeof doc.collection !== 'string' || !id(doc.id)) || value.slugs?.some((slug)=>typeof slug !== 'string' || !slug || slug.length > 64)) return error(422, 'invalid-body', 'Enter valid documents and slugs.');
+    const body = value;
+    const registered = new Set([
+        ...options.pages?.collections.map((entry)=>entry.slug) ?? [],
+        ...options.blocks?.collections.map((entry)=>entry.slug) ?? [],
+        ...puckCollections(options).map((entry)=>entry.slug)
+    ]);
+    if (body.docs?.some((doc)=>!registered.has(doc.collection))) return error(422, 'unknown-collection', "That page type isn't set up for tests.");
+    const result = {
+        docs: Object.create(null),
+        slugs: Object.create(null)
+    };
+    const wanted = body.slugs ?? [];
+    const { docs } = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: false,
+        depth: 0,
+        pagination: false,
+        limit: 0,
+        where: !body.docs?.length ? {
+            slug: {
+                in: wanted
+            }
+        } : !wanted.length ? {
+            kind: {
+                equals: 'page'
+            }
+        } : undefined
+    });
+    const tests = docs;
+    const state = wanted.length ? await req.payload.findGlobal({
+        slug: 'xp-state',
+        req,
+        overrideAccess: false,
+        depth: 0
+    }) : null;
+    const retired = Array.isArray(state?.retiredSlugs) ? state.retiredSlugs : [];
+    const rounds = new Map();
+    for (const test of tests){
+        let arms = test.arms, rollout = false;
+        if ([
+            'running',
+            'decided',
+            'archived'
+        ].includes(test.status)) {
+            const phases = await req.payload.find({
+                collection: 'xp-phases',
+                req,
+                overrideAccess: false,
+                depth: 0,
+                limit: 1,
+                sort: '-phase',
+                where: {
+                    experiment: {
+                        equals: test.id
+                    }
+                }
+            });
+            const latest = phases.docs[0];
+            rollout = test.status === 'decided' && latest?.phaseKind === 'rollout' && !latest.endedAt && !test.decision?.holdoutReleasedAt;
+            if (latest?.phaseKind === 'test') arms = latest.arms;
+            else if (latest) {
+                const frozen = await req.payload.find({
+                    collection: 'xp-phases',
+                    req,
+                    overrideAccess: false,
+                    depth: 0,
+                    limit: 1,
+                    sort: '-phase',
+                    where: {
+                        and: [
+                            {
+                                experiment: {
+                                    equals: test.id
+                                }
+                            },
+                            {
+                                phaseKind: {
+                                    equals: 'test'
+                                }
+                            }
+                        ]
+                    }
+                });
+                arms = frozen.docs[0]?.arms ?? arms;
+            }
+        }
+        rounds.set(test.slug, {
+            arms,
+            rollout
+        });
+    }
+    for (const slug of wanted){
+        const test = tests.find((test)=>test.slug === slug);
+        if (!test) {
+            result.slugs[slug] = retired.includes(slug) ? {
+                deleted: true
+            } : {
+                missing: true
+            };
+            continue;
+        }
+        const round = rounds.get(slug);
+        result.slugs[slug] = {
+            name: test.name,
+            status: test.status,
+            kind: test.kind,
+            arms: round.arms.map(({ key, label, slot })=>({
+                    key,
+                    label,
+                    ...slot ? {
+                        slot
+                    } : {}
+                })),
+            ...test.decision?.winnerArm ? {
+                winnerArm: test.decision.winnerArm
+            } : {},
+            rollout: round.rollout
+        };
+    }
+    const collections = new Map();
+    const winnerTitles = new Map();
+    for (const { collection, id } of body.docs ?? []){
+        // Check document access before the raw path read. A refused read propagates.
+        await req.payload.findByID({
+            collection,
+            id,
+            req,
+            overrideAccess: false,
+            depth: 0,
+            draft: false
+        });
+        const registration = options.pages?.collections.find((entry)=>entry.slug === collection);
+        const raw = registration ? await statusPageContent(req, collection, id) : null;
+        const rawPath = raw && registration ? registration.pathOf(raw) : null;
+        const path = rawPath;
+        const pathKey = path === null ? null : normalisePath(path);
+        const status = {
+            path,
+            tests: []
+        };
+        for (const test of tests){
+            if (test.kind !== 'page' || path === null || test.decision?.pagesReleasedAt || test.decision?.discardedAt || test.status === 'archived' && !test.decision?.winnerArm) continue;
+            const round = rounds.get(test.slug);
+            if (!collections.has(test.slug)) collections.set(test.slug, await resolvePageCollection(req, options, {
+                ...test,
+                arms: round.arms
+            }));
+            const testCollection = collections.get(test.slug);
+            if (testCollection?.slug !== collection) continue;
+            const arm = round.arms.find((arm)=>arm.kind !== 'holdout' && arm.pageTarget && normalisePath(arm.pageTarget) === pathKey);
+            if (!arm) continue;
+            const winner = round.arms.find((arm)=>arm.key === test.decision?.winnerArm);
+            const original = round.arms.find((arm)=>arm.kind === 'control');
+            if (!winnerTitles.has(test.slug)) {
+                let title;
+                try {
+                    const winnerPage = winner?.pageTarget && registration ? await registration.findByPath(winner.pageTarget, req) : null;
+                    const winnerDoc = winnerPage ? await req.payload.findByID({
+                        collection,
+                        id: winnerPage.id,
+                        req,
+                        overrideAccess: false,
+                        depth: 0,
+                        draft: false,
+                        disableErrors: true
+                    }) : null;
+                    const titleField = req.payload.config.collections.find((entry)=>entry.slug === collection)?.admin.useAsTitle ?? 'title';
+                    if (winnerDoc) title = String(winnerDoc[titleField] ?? winnerDoc.id);
+                } catch (cause) {
+                    req.payload.logger.error({
+                        err: safeError(cause),
+                        experimentId: test.id
+                    }, 'Experiment winner title lookup failed');
+                }
+                winnerTitles.set(test.slug, title);
+            }
+            const winnerTitle = winnerTitles.get(test.slug);
+            status.tests.push({
+                slug: test.slug,
+                name: test.name,
+                status: test.status,
+                role: arm.kind === 'control' ? 'original' : 'version',
+                armLabel: arm.label,
+                winner: [
+                    'decided',
+                    'archived'
+                ].includes(test.status) && winner?.key === arm.key,
+                ...winner ? {
+                    winnerLabel: winner.label,
+                    winnerPath: winner.pageTarget
+                } : {},
+                ...winnerTitle ? {
+                    winnerTitle
+                } : {},
+                ...original?.pageTarget ? {
+                    originalPath: normalisePath(original.pageTarget)
+                } : {},
+                rollout: round.rollout,
+                pagesReleased: false
+            });
+        }
+        result.docs[`${collection}:${id}`] = status;
+    }
+    return Response.json(result, {
+        headers: {
+            'Cache-Control': 'no-store'
+        }
+    });
+}

package/dist/endpoints/readBody.d.ts

@@ -0,0 +1,2 @@
+import type { PayloadRequest } from 'payload';
+export declare function readBody(req: PayloadRequest): Promise<unknown>;

package/dist/endpoints/readBody.js

@@ -0,0 +1,24 @@
+export async function readBody(req) {
+    if (req.data !== undefined) {
+        if (Buffer.byteLength(JSON.stringify(req.data)) > 16 * 1024) throw new RangeError();
+        return req.data;
+    }
+    if (!req.body) return {};
+    const reader = req.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            size += value.byteLength;
+            if (size > 16 * 1024) {
+                void reader.cancel().catch(()=>{});
+                throw new RangeError();
+            }
+            chunks.push(value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    } finally{
+        reader.releaseLock();
+    }
+}

package/dist/endpoints/results.js

@@ -1,6 +1,7 @@
 import { resultsMetadata, newestSnapshotIds } from '../db/snapshots.js';
 import { pooledExecutor } from '../db/executor.js';
 import { routeId } from './routeId.js';
+import { isClickSource } from '../goals/key.js';
 const headers = {
     'Cache-Control': 'no-store'
 };
@@ -85,11 +86,14 @@ export async function handleResults(req, _ctx) {
                     label,
                     kind
                 })),
-            metrics: record.metricDefinitions.map(({ metricId, name, kind, role, resolvedCap, historyUnits, capNotice })=>({
+            metrics: record.metricDefinitions.map(({ metricId, name, kind, role, source, resolvedCap, historyUnits, capNotice })=>({
                     metricId,
                     name,
                     kind,
                     role,
+                    ...isClickSource(source) ? {
+                        clickGoal: true
+                    } : {},
                     ...resolvedCap === undefined ? {} : {
                         resolvedCap
                     },

package/dist/endpoints/summary.js

@@ -43,10 +43,17 @@ export async function handleSummary(req, { options }) {
                 headline: snapshot.verdict.headline
             },
             ...snapshot.health ? {
-                health: snapshot.health.slice(0, 100).map(({ code, path })=>({
-                        code,
-                        path: path.slice(0, 128)
-                    }))
+                health: snapshot.health.slice(0, 100).map((item)=>item.code === 'placement-unchecked' ? {
+                        code: item.code,
+                        detail: sanitizeReadinessDetail('placement-unchecked', item.detail)
+                    } : item.code === 'goal-in-some-versions' ? {
+                        code: item.code,
+                        metricId: item.metricId,
+                        name: item.name.slice(0, 128)
+                    } : {
+                        code: item.code,
+                        path: item.path.slice(0, 128)
+                    })
             } : {}
         } : {
             exposures: 0,

package/dist/endpoints/wrapBlock.d.ts

@@ -0,0 +1,6 @@
+import { type PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+import type { DocId } from '../types/contracts.js';
+export declare function handleWrapBlock<TUser extends {
+    id: DocId;
+}>(req: PayloadRequest, { options }: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/wrapBlock.js

@@ -0,0 +1,76 @@
+import { Locked } from 'payload';
+import { readBody } from './readBody.js';
+import { findRegisteredBlocksField, wrapExperimentBlock } from '../blocks/formState.js';
+import { EXPERIMENT_BLOCK_SLUG, hostBlocks, isObject } from '../blocks/model.js';
+import { XpRefusal } from '../errors.js';
+export async function handleWrapBlock(req, { options }) {
+    let value;
+    try {
+        value = await readBody(req);
+    } catch (cause) {
+        throw new XpRefusal(cause instanceof RangeError ? 'body-too-large' : 'invalid-body', 'Enter a valid request body.', undefined, cause instanceof RangeError ? 413 : 422);
+    }
+    if (!isObject(value) || Object.keys(value).some((k)=>![
+            'collection',
+            'id',
+            'field',
+            'blockId',
+            'experiment'
+        ].includes(k)) || ![
+        'collection',
+        'field',
+        'blockId',
+        'experiment'
+    ].every((k)=>typeof value[k] === 'string' && value[k].trim()) || !(typeof value.id === 'string' && value.id.trim() || typeof value.id === 'number' && Number.isSafeInteger(value.id))) throw new XpRefusal('invalid-body', 'Enter a valid request body.', undefined, 422);
+    const { collection, field, blockId, experiment } = value;
+    const id = value.id;
+    const registration = options.blocks?.collections.find((r)=>r.slug === collection && r.field === field);
+    if (!registration) throw new XpRefusal('unknown-collection', "That page type isn't set up for tests.", undefined, 422);
+    const tests = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: false,
+        depth: 0,
+        limit: 1,
+        where: {
+            slug: {
+                equals: experiment
+            }
+        }
+    });
+    const test = tests.docs[0];
+    if (test?.kind !== 'block') throw new XpRefusal('invalid-body', 'Choose a block test.', undefined, 422);
+    if (test.status !== 'draft') throw new XpRefusal('invalid-status', 'This action is not available in the current status.', undefined, 409);
+    const doc = await req.payload.findByID({
+        collection,
+        id,
+        req,
+        overrideAccess: false,
+        depth: 0,
+        draft: true,
+        includeLockStatus: true
+    });
+    const blocks = hostBlocks(doc[field]), blockSlug = registration.blockSlug ?? EXPERIMENT_BLOCK_SLUG;
+    const index = blocks.findIndex((block)=>block.id === blockId && block.blockType !== blockSlug);
+    if (index < 0) throw new XpRefusal('wrap-target-missing', 'Reload the page and try again.', undefined, 409);
+    const config = findRegisteredBlocksField(req.payload.config.collections.find((c)=>c.slug === collection)?.fields ?? [], field);
+    if (!config) throw new Error(`Experiments blocks field ${collection}.${field} is not configured.`);
+    blocks[index] = wrapExperimentBlock(blocks[index], experiment, config.field, req.payload.config, blockSlug);
+    try {
+        const result = await req.payload.update({
+            collection,
+            id,
+            req,
+            overrideAccess: false,
+            overrideLock: false,
+            draft: true,
+            data: {
+                [field]: blocks
+            }
+        });
+        return Response.json(result);
+    } catch (error) {
+        if (error instanceof Locked || error instanceof Error && error.name === 'Locked') throw new XpRefusal('locked-placement', 'Another editor has this page open. Try again when it is unlocked.', undefined, 409);
+        throw error;
+    }
+}

package/dist/errors.d.ts

@@ -15,15 +15,15 @@ export declare class XpLockedFieldError extends Error {
 }
 export declare class XpNoTransactionError extends Error {
     name: string;
-    constructor();
+    constructor(message?: string);
 }
 export declare class XpRefusal extends Error {
     readonly code: RefusalCode;
     readonly detail: unknown | undefined;
-    readonly status: 409 | 422 | 500 | 404;
+    readonly status: 409 | 413 | 422 | 500 | 404;
     name: string;
     readonly isPublic = true;
-    constructor(code: RefusalCode, message: string, detail: unknown | undefined, status: 409 | 422 | 500 | 404);
+    constructor(code: RefusalCode, message: string, detail: unknown | undefined, status: 409 | 413 | 422 | 500 | 404, options?: ErrorOptions);
 }
 /** 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';

package/dist/errors.js

@@ -17,8 +17,8 @@ export class XpLockedFieldError extends Error {
 }
 export class XpNoTransactionError extends Error {
     name = 'XpNoTransactionError';
-    constructor(){
-        super('An active transaction is required');
+    constructor(message = 'An active transaction is required'){
+        super(message);
     }
 }
 export class XpRefusal extends Error {
@@ -27,8 +27,8 @@ export class XpRefusal extends Error {
     status;
     name = 'XpRefusal';
     isPublic = true;
-    constructor(code, message, detail, status){
-        super(message), this.code = code, this.detail = detail, this.status = status;
+    constructor(code, message, detail, status, options){
+        super(message, options), this.code = code, this.detail = detail, this.status = status;
     }
 }
 export const ANALYSIS_ERROR_MESSAGES = Object.freeze({

package/dist/events/rows.d.ts

@@ -4,4 +4,4 @@ import type { ResolvedOptions } from '../types/contracts.js';
 import type { Manifest } from '../types/manifest.js';
 export declare function eventRows<TUser extends {
     id: string | number;
-}>(events: unknown[], manifest: Manifest, assignments: AssignmentResult, options: ResolvedOptions<TUser>, visitorId: string, userId: string | undefined, ts: string, requestAttributes?: Readonly<Record<string, unknown>>): EventRow[];
+}>(events: unknown[], manifest: Manifest, assignments: AssignmentResult, options: ResolvedOptions<TUser>, visitorId: string, userId: string | undefined, ts: string, requestAttributes?: Readonly<Record<string, unknown>>, clickKeys?: ReadonlySet<string>): EventRow[];

package/dist/events/rows.js

@@ -1,3 +1,4 @@
+import { validClickSource, isClickSource } from '../goals/key.js';
 import { exposureDimensions } from './dimensions.js';
 function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -9,7 +10,7 @@ function record(value) {
         return definition && typeof item === definition.type && (typeof item !== 'number' || Number.isFinite(item)) && (!definition.values || typeof item === 'string' && definition.values.includes(item));
     }));
 }
-export function eventRows(events, manifest, assignments, options, visitorId, userId, ts, requestAttributes = {}) {
+export function eventRows(events, manifest, assignments, options, visitorId, userId, ts, requestAttributes = {}, clickKeys) {
     const rows = new Map();
     for (const event of events){
         if (!record(event)) continue;
@@ -42,7 +43,8 @@ export function eventRows(events, manifest, assignments, options, visitorId, use
         } else if (event.type === 'conversion') {
             if (typeof event.eventName !== 'string' || typeof event.idempotencyKey !== 'string' || !event.idempotencyKey.trim() || event.value !== undefined && (typeof event.value !== 'number' || !Number.isFinite(event.value))) continue;
             const source = options.metricSources?.find((source)=>source.id === event.eventName);
-            if (source ? source.clientWritable !== true || source.kind === 'revenue' : !options.eventSources?.some((source)=>source.name === event.eventName && source.clientWritable)) continue;
+            const click = isClickSource(event.eventName);
+            if (click ? !validClickSource(event.eventName) || !clickKeys?.has(event.eventName.slice(6)) : source ? source.clientWritable !== true || source.kind === 'revenue' : !options.eventSources?.some((source)=>source.name === event.eventName && source.clientWritable)) continue;
             row = {
                 type: 'conversion',
                 eventName: event.eventName,
@@ -52,7 +54,7 @@ export function eventRows(events, manifest, assignments, options, visitorId, use
                 userId,
                 ts,
                 dimensions: null,
-                attributes: attributes(event.attributes, options.attributeKeys),
+                attributes: click ? undefined : attributes(event.attributes, options.attributeKeys),
                 // §5.5: scoped by unit and event so one client can never pre-claim another's key.
                 dedupeKey: `conversion:c:${visitorId}:${event.eventName}:${event.idempotencyKey}`
             };

package/dist/exports/adminClient.d.ts

@@ -5,3 +5,8 @@ export { ArmSelectField } from '../admin/armSelect/ArmSelectField.js';
 export { TestsNavLink } from '../admin/TestsNavLink.js';
 export { TestsSurface } from '../admin/surface/TestsSurface.js';
 export { TestsDashboardCards } from '../admin/TestsDashboardCards.js';
+export { PlacementStatus } from '../admin/PlacementStatus.js';
+export { wrapExperimentBlock, syncExperimentSlots, copyOriginalIntoVersion, unwrapExperimentBlock, findRegisteredBlocksField } from '../blocks/formState.js';
+export { TestBlockField } from '../admin/blocks/TestBlockField.js';
+export { BlockStatusField, BlockSlotRowLabel, CopyOriginalField } from '../admin/blocks/BlockPanel.js';
+export { XpGoalField } from '../admin/goals/XpGoalField.js';

package/dist/exports/adminClient.js

@@ -6,3 +6,8 @@ export { ArmSelectField } from '../admin/armSelect/ArmSelectField.js';
 export { TestsNavLink } from '../admin/TestsNavLink.js';
 export { TestsSurface } from '../admin/surface/TestsSurface.js';
 export { TestsDashboardCards } from '../admin/TestsDashboardCards.js';
+export { PlacementStatus } from '../admin/PlacementStatus.js';
+export { wrapExperimentBlock, syncExperimentSlots, copyOriginalIntoVersion, unwrapExperimentBlock, findRegisteredBlocksField } from '../blocks/formState.js';
+export { TestBlockField } from '../admin/blocks/TestBlockField.js';
+export { BlockStatusField, BlockSlotRowLabel, CopyOriginalField } from '../admin/blocks/BlockPanel.js';
+export { XpGoalField } from '../admin/goals/XpGoalField.js';

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

@@ -0,0 +1,2 @@
+export { controlOnlyBlocks, segmentExperimentBlocks, EXPERIMENT_BLOCK_SLUG } from '../blocks/model.js';
+export type { HostBlock, ExperimentBlock, ExperimentBlockGroup, ResolvedHostBlock, ResolvedExperimentBlocks } from '../blocks/model.js';

package/dist/exports/blocks.js

@@ -0,0 +1 @@
+export { controlOnlyBlocks, segmentExperimentBlocks, EXPERIMENT_BLOCK_SLUG } from '../blocks/model.js';

package/dist/exports/client.d.ts

@@ -5,3 +5,4 @@ export { ExperimentPageview } from '../client/ExperimentPageview.js';
 export { trackConversionBeacon } from '../client/trackConversionBeacon.js';
 export { MAX_EVENTS_PER_BODY, DEFAULT_MAX_BODY_BYTES } from '../constants.js';
 export type { ClientAssignments } from '../types/assignments.js';
+export { ExperimentGroup } from '../client/ExperimentGroup.js';