@delmaredigital/payload-experiments 0.0.0-stage → 0.1.0-rc.6

package/dist/db/state.js

@@ -0,0 +1,27 @@
+import { COLUMNS, TABLES } from './names.js';
+const columns = COLUMNS.state;
+const quote = (name)=>`"${name.replaceAll('"', '""')}"`;
+function table(exec, options = {}) {
+    const schemaName = options.schemaName ?? exec.schemaName;
+    return `${schemaName ? `${quote(schemaName)}.` : ''}${quote(TABLES.state)}`;
+}
+/** Always take this lock last: layer → flag point → experiment → state. */ export async function bumpRevision(exec) {
+    await exec.query("SELECT pg_advisory_xact_lock(hashtext('xp:state'), 0)");
+    const updated = await exec.query(`UPDATE ${table(exec)} SET ${quote(columns.revision)} = COALESCE(${quote(columns.revision)}, 0) + 1, ${quote(columns.updatedAt)} = now() RETURNING ${quote(columns.revision)}`);
+    if (updated.rows[0]) return updated.rows[0].revision;
+    const inserted = await exec.query(`INSERT INTO ${table(exec)} (${quote(columns.revision)}, ${quote(columns.createdAt)}, ${quote(columns.updatedAt)}) VALUES (1, now(), now()) RETURNING ${quote(columns.revision)}`);
+    return inserted.rows[0].revision;
+}
+export async function writeManifest(exec, manifest) {
+    await exec.query(`UPDATE ${table(exec)} SET ${quote(columns.manifest)} = $1::jsonb, ${quote(columns.updatedAt)} = now()`, [
+        JSON.stringify(manifest)
+    ]);
+}
+export async function readState(exec, options = {}) {
+    const result = await exec.query(`SELECT ${quote(columns.revision)}, ${quote(columns.manifest)}, ${quote(columns.flagDefaults)} AS "flagDefaults" FROM ${table(exec, options)} LIMIT 1`);
+    const row = result.rows[0];
+    return row ? {
+        ...row,
+        flagDefaults: row.flagDefaults ?? {}
+    } : null;
+}

package/dist/db/sweep.d.ts

@@ -0,0 +1,13 @@
+import type { Executor } from './executor.js';
+/** §5.5 / §7.8: privileged retention sweep. Deleted experiments' FKs become
+ * NULL; their exposure and arm-mismatch rows are handled by the two NULL branches. Global
+ * conversions stay while an open/recent experiment could still need them. */
+export declare function sweepEvents(exec: Executor, { now, retentionDays, batchSize, shouldContinue, logger }: {
+    now: Date;
+    retentionDays?: number;
+    batchSize?: number;
+    shouldContinue?: () => boolean;
+    logger?: {
+        warn(message: string): void;
+    };
+}): Promise<number>;

package/dist/db/sweep.js

@@ -0,0 +1,90 @@
+import { COLUMNS, TABLES } from './names.js';
+import { qualifiedTable, quoteIdentifier as q } from './sql.js';
+import { ResultsBudgetError } from './pgExecutor.js';
+/** §5.5 / §7.8: privileged retention sweep. Deleted experiments' FKs become
+ * NULL; their exposure and arm-mismatch rows are handled by the two NULL branches. Global
+ * conversions stay while an open/recent experiment could still need them. */ export async function sweepEvents(exec, { now, retentionDays = 180, batchSize = 1000, shouldContinue = ()=>true, logger }) {
+    if (!Number.isSafeInteger(retentionDays) || retentionDays < 1 || !Number.isSafeInteger(batchSize) || batchSize < 1) throw new RangeError('Invalid retention settings');
+    const cutoffMs = now.getTime() - retentionDays * 86_400_000;
+    const cutoff = new Date(cutoffMs).toISOString();
+    const c = COLUMNS.events, p = COLUMNS.phases, s = COLUMNS.state;
+    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;
+    // Each statement still uses the caller's budget/race-aware executor.
+    async function batches(predicate, order, params = []) {
+        while(shouldContinue()){
+            const result = await exec.query(`DELETE FROM ${events} WHERE ${q(c.id)} IN (
+        SELECT v.${q(c.id)} FROM ${events} v WHERE ${predicate}
+        ORDER BY ${order} LIMIT $${params.length + 1})`, [
+                ...params,
+                batchSize
+            ]);
+            swept += result.rowCount;
+            if (result.rowCount < batchSize) break;
+        }
+    }
+    try {
+        // Keep the leading NULL key in ORDER BY too: PostgreSQL does not infer
+        // its ordering equivalence from IS NULL when choosing a bounded index scan.
+        const byEventType = `v.${q(c.experimentId)}, v.${q(c.type)}, v.${q(c.ts)}`;
+        // Drain the two allow-listed diagnostic types with equality probes. An
+        // ordered IN scan can otherwise read conversion entries and filter them.
+        for (const type of [
+            'exposure',
+            'arm-mismatch'
+        ]){
+            await batches(`v.${q(c.experimentId)} IS NULL AND v.${q(c.type)} IN ($1)`, byEventType, [
+                type
+            ]);
+        }
+        if (!shouldContinue()) return swept;
+        // 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)}
+      HAVING NOT bool_or(${q(p.endedAt)} IS NULL) AND max(${q(p.endedAt)}) < $1`, [
+            cutoff
+        ]);
+        if (ended.rows.length) {
+            // Recheck in every batch in case a new phase started after the id read.
+            await batches(`v.${q(c.experimentId)} = ANY($1) AND NOT EXISTS (
+        SELECT 1 FROM ${phases} p WHERE p.${q(p.experimentId)} = v.${q(c.experimentId)}
+          AND (p.${q(p.endedAt)} IS NULL OR p.${q(p.endedAt)} >= $2))`, byEventType, [
+                ended.rows.map((row)=>row.experimentId),
+                cutoff
+            ]);
+        }
+        if (!shouldContinue()) return swept;
+        // 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
+        // snapshot as the state revision. Epoch milliseconds avoid timestamp parsing.
+        const protectedRows = await exec.query(`SELECT
+      ${revision} AS revision, min(w."from") AS "before" FROM (
+        SELECT extract(epoch FROM min(${q(p.startedAt)}) - interval '14 days') * 1000 AS "from"
+        FROM ${phases} WHERE ${q(p.experimentId)} IS NOT NULL GROUP BY ${q(p.experimentId)}
+        HAVING bool_or(${q(p.endedAt)} IS NULL) OR max(${q(p.endedAt)}) >= $1
+      ) w`, [
+            cutoff
+        ]);
+        const frozen = protectedRows.rows[0] ?? {
+            revision: null,
+            before: null
+        };
+        const before = new Date(Math.min(cutoffMs, frozen.before ?? cutoffMs)).toISOString();
+        // Transitions bump revision in the same transaction as phase writes. This
+        // uncorrelated initplan checks it once per statement, not per candidate. If a
+        // phase starts mid-sweep, stale windows can delete no further conversions.
+        await batches(`v.${q(c.experimentId)} IS NULL AND v.${q(c.type)} = 'conversion' AND v.${q(c.ts)} < $1
+      AND ${revision} IS NOT DISTINCT FROM $2`, byEventType, [
+            before,
+            frozen.revision
+        ]);
+        return swept;
+    } catch (error) {
+        if (swept === 0 && error instanceof ResultsBudgetError) {
+            logger?.warn('Experiment retention sweep made no progress before its budget expired; eligible rows may remain.');
+        }
+        throw error;
+    }
+}

package/dist/db/txid.d.ts

@@ -0,0 +1,7 @@
+import type { Executor } from './executor.js';
+/** Capture on the transaction executor before committing; keep the bigint as text. */
+export declare function currentTxid(exec: Executor): Promise<string>;
+/** Verify on the pool after commit, so another transaction's revision cannot
+ * masquerade as this transaction's success. Null means its status is unavailable.
+ */
+export declare function txidStatus(exec: Executor, xid: string): Promise<'committed' | 'aborted' | 'in progress' | null>;

package/dist/db/txid.js

@@ -0,0 +1,12 @@
+/** Capture on the transaction executor before committing; keep the bigint as text. */ export async function currentTxid(exec) {
+    const { rows } = await exec.query('SELECT txid_current()::text AS xid');
+    return rows[0].xid;
+}
+/** Verify on the pool after commit, so another transaction's revision cannot
+ * masquerade as this transaction's success. Null means its status is unavailable.
+ */ export async function txidStatus(exec, xid) {
+    const { rows } = await exec.query('SELECT txid_status($1::bigint) AS status', [
+        xid
+    ]);
+    return rows[0]?.status ?? null;
+}

package/dist/define.d.ts

@@ -0,0 +1,3 @@
+import type { FlagPoint, MetricSource } from './types/contracts.js';
+export declare function defineFlagPoint<T extends FlagPoint>(p: T): T;
+export declare function defineMetricSource<T extends MetricSource>(s: T): T;

package/dist/define.js

@@ -0,0 +1,6 @@
+export function defineFlagPoint(p) {
+    return p;
+}
+export function defineMetricSource(s) {
+    return s;
+}

package/dist/endpoints/events.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+export declare function handleEvents<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, { options }: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/events.js

@@ -0,0 +1,98 @@
+import { NextRequest } from 'next/server.js';
+import { DEFAULT_MAX_BODY_BYTES } from '../constants.js';
+import { pooledExecutor } from '../db/executor.js';
+import { insertEvents } from '../db/events.js';
+import { EventsBodyError, readEvents } from '../events/body.js';
+import { isPreview } from '../events/preview.js';
+import { sourceRequest } from '../events/request.js';
+import { eventRows } from '../events/rows.js';
+import { assign } from '../runtime/assign.js';
+import { isBot } from '../runtime/bot.js';
+import { readUnitCookie } from '../runtime/cookie.js';
+import { requestAttributes } from '../runtime/normalisePath.js';
+import { serverManifest } from '../server/context.js';
+const accepted = ()=>Response.json({}, {
+        status: 202
+    });
+export async function handleEvents(req, { options }) {
+    const runtime = options.runtime, proxy = runtime.proxyRuntime;
+    const visitorId = readUnitCookie(req.headers, proxy);
+    if (!visitorId) return Response.json({
+        errors: [
+            {
+                code: 'unauthenticated',
+                message: 'Invalid unit cookie'
+            }
+        ]
+    }, {
+        status: 401
+    });
+    let events;
+    try {
+        events = await readEvents(req.body, options.events?.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES);
+    } catch (error) {
+        if (error instanceof EventsBodyError) return Response.json({
+            errors: [
+                {
+                    code: error.code,
+                    message: error.message
+                }
+            ]
+        }, {
+            status: error.status
+        });
+        throw error;
+    }
+    try {
+        const request = new NextRequest(req.url ?? 'https://xp.invalid/', {
+            headers: req.headers,
+            method: req.method
+        });
+        // API paths bypass the proxy: re-check consent even when a stale signed cookie exists.
+        try {
+            if (proxy.cookie.consent?.(request) === false) return accepted();
+        } catch  {
+            return accepted();
+        }
+        if (options.events?.rateLimit && await options.events.rateLimit({
+            req,
+            unitId: visitorId
+        }) !== true) return accepted();
+        const manifest = await serverManifest(proxy);
+        if (!manifest) return accepted();
+        const source = sourceRequest(request);
+        const unit = await proxy.getUnit?.(source ?? request);
+        const user = req.user ?? null;
+        const userId = user ? runtime.userIdOf(user) : undefined;
+        // The beacon URL is an API route, not the page whose content was rendered.
+        // A referrer supplies page context only, never an identity or an assigned arm.
+        const attributes = requestAttributes({
+            ...unit?.attributes,
+            ...runtime.attributesOf(user)
+        }, source?.nextUrl.pathname);
+        const unresolvedStaff = Boolean(options.attributeKeys?.staff && unit?.sessionUnknown && !user);
+        const assignments = assign(manifest, {
+            visitorId,
+            userId
+        }, attributes, {
+            now: Math.floor(Date.now() / 1000),
+            method: req.method,
+            staff: unit?.attributes.staff === true || attributes.staff === true,
+            bot: isBot(req.headers.get('user-agent')),
+            preview: isPreview(request)
+        });
+        if (unresolvedStaff) for (const assignment of Object.values(assignments.bySlug))assignment.exposable = false;
+        const rows = eventRows(events, manifest, assignments, options, visitorId, userId, new Date().toISOString(), attributes);
+        // §7.8 events insert / assignment lookup exception: pooled SQL and cached manifest,
+        // no Local API calls (and hence no implicit overrideAccess defaults).
+        if (rows.length) await insertEvents(pooledExecutor(req.payload), rows, (message)=>req.payload.logger.error(message));
+    } catch (error) {
+        try {
+            req.payload.logger.error({
+                err: error,
+                msg: 'Experiments: events endpoint failed'
+            });
+        } catch  {}
+    }
+    return accepted();
+}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,18 @@
+import type { Endpoint, PayloadRequest } from 'payload';
+import type { ResolvedOptions } from '../types/contracts.js';
+import type { AccessKind, EndpointContext } from '../types/endpoints.js';
+export declare const ROUTES: Array<{
+    method: Endpoint['method'];
+    path: string;
+    access: AccessKind;
+    handler: <TUser extends {
+        id: string | number;
+    }>(req: PayloadRequest, ctx: EndpointContext<TUser>) => Promise<Response>;
+}>;
+export declare function buildEndpoints<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(ctx: {
+    options: ResolvedOptions<TUser>;
+}): Endpoint[];

package/dist/endpoints/index.js

@@ -0,0 +1,160 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { XP_MANIFEST_KEY_HEADER } from '../constants.js';
+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 { handlePreflight } from './preflight.js';
+import { handlePreviewToken } from './previewToken.js';
+import { handleResults } from './results.js';
+import { handleRecompute } from './recompute.js';
+import { handleSummary } from './summary.js';
+export const ROUTES = [
+    {
+        method: 'get',
+        path: '/xp/manifest',
+        access: 'manifestKey',
+        handler: handleManifest
+    },
+    {
+        method: 'post',
+        path: '/xp/events',
+        access: 'signedCookie',
+        handler: handleEvents
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/start',
+        access: 'manage',
+        handler: handleStart
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/allocate',
+        access: 'manage',
+        handler: handleAllocate
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/add-metric',
+        access: 'manage',
+        handler: handleAddMetric
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/stop',
+        access: 'manage',
+        handler: handleStop
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/decide',
+        access: 'manage',
+        handler: handleDecide
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/release-holdout',
+        access: 'manage',
+        handler: handleReleaseHoldout
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/make-content',
+        access: 'manage',
+        handler: handleMakeContent
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/archive',
+        access: 'manage',
+        handler: handleArchive
+    },
+    {
+        method: 'get',
+        path: '/xp/experiments/:id/preflight',
+        access: 'manage',
+        handler: handlePreflight
+    },
+    {
+        method: 'get',
+        path: '/xp/experiments/:id/preview-token',
+        access: 'manage',
+        handler: handlePreviewToken
+    },
+    {
+        method: 'get',
+        path: '/xp/experiments/:id/results',
+        access: 'readResults',
+        handler: handleResults
+    },
+    {
+        method: 'post',
+        path: '/xp/experiments/:id/recompute',
+        access: 'manage',
+        handler: handleRecompute
+    },
+    {
+        method: 'get',
+        path: '/xp/experiments/summary',
+        access: 'readResults',
+        handler: handleSummary
+    }
+];
+function error(status, code, message, detail) {
+    return Response.json({
+        errors: [
+            {
+                code,
+                message,
+                ...detail === undefined ? {} : {
+                    detail
+                }
+            }
+        ]
+    }, {
+        status
+    });
+}
+export function buildEndpoints(ctx) {
+    return ROUTES.map((route)=>({
+            method: route.method,
+            path: route.path,
+            handler: async (req)=>{
+                const { options } = ctx;
+                const handlerContext = {
+                    options
+                };
+                try {
+                    if (route.access === 'manage' || route.access === 'readResults') {
+                        if (!req.user) return error(401, 'unauthenticated', 'Authentication required');
+                        const access = route.access === 'readResults' ? options.access.readResults ?? options.access.manage : options.access.manage;
+                        if (await access({
+                            req
+                        }) !== true) return error(403, 'forbidden', 'Access denied');
+                    } else if (route.access === 'manifestKey') {
+                        const secret = options.runtime.proxyRuntime.secrets[0];
+                        if (!secret) return error(401, 'unauthenticated', 'Invalid manifest key');
+                        const expected = createHmac('sha256', secret).update('xp:manifest-key').digest('hex');
+                        const supplied = req.headers.get(XP_MANIFEST_KEY_HEADER);
+                        // Compare the wire hex bytes, including length and case, rather than permissive hex decoding.
+                        if (!supplied || Buffer.byteLength(supplied) !== Buffer.byteLength(expected) || !timingSafeEqual(Buffer.from(supplied), Buffer.from(expected))) {
+                            return error(401, 'unauthenticated', 'Invalid manifest key');
+                        }
+                    } else {
+                        const visitorId = readUnitCookie(req.headers, options.runtime.proxyRuntime);
+                        if (!visitorId) return error(401, 'unauthenticated', 'Invalid unit cookie');
+                        handlerContext.unit = {
+                            visitorId
+                        };
+                    }
+                    return await route.handler(req, handlerContext);
+                } catch (cause) {
+                    if (cause instanceof XpRefusal) return error(cause.status, cause.code, cause.message, cause.detail);
+                    if (cause instanceof XpNotImplemented) return error(501, 'not-implemented', cause.lane);
+                    throw cause;
+                }
+            }
+        }));
+}

package/dist/endpoints/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+export declare function handleManifest<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, _ctx: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/manifest.js

@@ -0,0 +1,30 @@
+import { pooledExecutor } from '../db/executor.js';
+import { readManifestRow } from '../db/manifest.js';
+export async function handleManifest(req, _ctx) {
+    const row = await readManifestRow(pooledExecutor(req.payload));
+    if (!row) return Response.json({
+        errors: [
+            {
+                code: 'not-found',
+                message: 'Manifest not found'
+            }
+        ]
+    }, {
+        status: 404,
+        headers: {
+            'Cache-Control': 'no-store'
+        }
+    });
+    const headers = {
+        ETag: `"${row.revision}"`,
+        'Cache-Control': 'no-store'
+    };
+    const ifRevision = req.headers.get('if-none-match');
+    if (ifRevision === String(row.revision) || ifRevision === headers.ETag) return new Response(null, {
+        status: 304,
+        headers
+    });
+    return Response.json(row.manifest, {
+        headers
+    });
+}

package/dist/endpoints/preflight.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+import type { PreflightDependencies } from '../transitions/preflightData.js';
+export declare function handlePreflight<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, ctx: EndpointContext<TUser>, dependencies?: PreflightDependencies): Promise<Response>;

package/dist/endpoints/preflight.js

@@ -0,0 +1,25 @@
+import { preflightData } from '../transitions/preflightData.js';
+export async function handlePreflight(req, ctx, dependencies) {
+    const id = req.routeParams?.id;
+    const result = typeof id === 'string' || typeof id === 'number' ? await preflightData(req, {
+        experimentId: id,
+        options: ctx.options
+    }, dependencies) : null;
+    const headers = {
+        'Cache-Control': 'no-store'
+    };
+    if (!result) return Response.json({
+        errors: [
+            {
+                code: 'not-found',
+                message: 'Experiment not found'
+            }
+        ]
+    }, {
+        status: 404,
+        headers
+    });
+    return Response.json(result, {
+        headers
+    });
+}

package/dist/endpoints/previewToken.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+export declare function handlePreviewToken<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, { options }: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/previewToken.js

@@ -0,0 +1,54 @@
+import { signPreviewToken } from '../runtime/previewToken.js';
+export async function handlePreviewToken(req, { options }) {
+    const headers = {
+        'Cache-Control': 'no-store'
+    };
+    const refuse = (status, code, message)=>Response.json({
+            errors: [
+                {
+                    code,
+                    message
+                }
+            ]
+        }, {
+            status,
+            headers
+        });
+    const id = req.routeParams?.id;
+    if (typeof id !== 'string' && typeof id !== 'number') return refuse(404, 'not-found', 'Experiment not found');
+    const result = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: false,
+        depth: 0,
+        limit: 1,
+        where: {
+            id: {
+                equals: id
+            }
+        }
+    });
+    const experiment = result.docs[0];
+    if (!experiment) return refuse(404, 'not-found', 'Experiment not found');
+    if (![
+        'draft',
+        'running',
+        'stopped',
+        'decided'
+    ].includes(experiment.status)) return refuse(409, 'invalid-status', 'This experiment cannot be previewed');
+    const arm = req.searchParams?.get('arm') ?? (req.url ? new URL(req.url).searchParams.get('arm') : null);
+    const arms = experiment.arms;
+    if (!arm || !arms.some((candidate)=>candidate.key === arm)) return refuse(400, 'invalid-body', 'Unknown experiment arm');
+    const now = Math.floor(Date.now() / 1000);
+    const token = signPreviewToken({
+        e: experiment.id,
+        a: arm,
+        p: experiment.phase,
+        exp: now + 3600
+    }, options.runtime.proxyRuntime.secrets, now);
+    return Response.json({
+        token
+    }, {
+        headers
+    });
+}

package/dist/endpoints/recompute.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadRequest } from 'payload';
+import type { EndpointContext } from '../types/endpoints.js';
+export declare function handleRecompute<TUser extends {
+    id: string | number;
+} = {
+    id: string | number;
+}>(req: PayloadRequest, _ctx: EndpointContext<TUser>): Promise<Response>;

package/dist/endpoints/recompute.js

@@ -0,0 +1,41 @@
+import { runResults } from '../server/runResults.js';
+import { readSnapshots, resultsError } from './results.js';
+export async function handleRecompute(req, _ctx) {
+    const id = req.routeParams?.id;
+    if (typeof id !== 'string' && typeof id !== 'number') return resultsError(404, 'not-found', 'Experiment not found');
+    const { docs } = await req.payload.find({
+        collection: 'xp-experiments',
+        req,
+        overrideAccess: false,
+        depth: 0,
+        limit: 1,
+        where: {
+            id: {
+                equals: id
+            }
+        }
+    });
+    if (!docs[0]) return resultsError(404, 'not-found', 'Experiment not found');
+    try {
+        const result = await runResults(req.payload, {
+            experimentId: docs[0].id,
+            sweep: false
+        });
+        if (result.skipped || result.budgetExhausted) return resultsError(503, 'recompute-failed', 'Results could not be recomputed. Try again.');
+        const latest = (await readSnapshots(req, [
+            docs[0].id
+        ], {
+            per: 'experiment'
+        }))[0];
+        if (!latest) return resultsError(422, 'recompute-failed', 'There is no round to analyse yet.');
+        return Response.json({
+            snapshotId: latest.id
+        }, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+    } catch  {
+        return resultsError(503, 'recompute-failed', 'Results could not be recomputed. Try again.');
+    }
+}