next-evolve 0.0.0-stage → 0.3.1

package/dist/proxy/index.d.ts

@@ -0,0 +1,2 @@
+import { EvolveProxyOptions, applyEvolve, createEvolveProxy, evolveReady } from "./proxy.js";
+export { type EvolveProxyOptions, applyEvolve, createEvolveProxy, evolveReady };

package/dist/proxy/index.js

@@ -0,0 +1 @@
+export { applyEvolve, createEvolveProxy, evolveReady } from "./proxy.js";

package/dist/proxy/proxy.d.ts

@@ -0,0 +1,24 @@
+import { EvolveConfig } from "../config/config.js";
+import { RuntimeOptions } from "../store/runtime.js";
+import { NextFetchEvent, NextRequest, NextResponse } from "next/server";
+export type EvolveProxyOptions = RuntimeOptions & {
+  /** Random source in [0, 1) (tests). */
+  random?: () => number;
+};
+/** Query parameter carrying a preview token from the dashboard. */
+export declare const PREVIEW_PARAM = "evolve_preview";
+/**
+ * Runs Evolve for one request. Returns a response for Evolve routes and
+ * `/ev_*` paths, or null for everything else (so it composes with an existing
+ * proxy: `return applyEvolve(config, req, event) ?? NextResponse.next()`).
+ * Never throws and never makes a network call on the request path.
+ */
+export declare function applyEvolve(config: EvolveConfig, req: NextRequest, event?: Pick<NextFetchEvent, "waitUntil">, opts?: EvolveProxyOptions): NextResponse | null;
+/** Builds the `proxy` export for `proxy.ts` (Next 16) or `middleware.ts` (Next 15.5, Node runtime). */
+export declare function createEvolveProxy(config: EvolveConfig, opts?: EvolveProxyOptions): (req: NextRequest, event: NextFetchEvent) => NextResponse | Promise<NextResponse>;
+/**
+ * With Global Config, an instance's first request waits ≤ 20 ms for one read
+ * (spec §7.8). Returns null when there's nothing to wait for. With an existing
+ * proxy: `await evolveReady(config)` before `applyEvolve(...)`.
+ */
+export declare function evolveReady(config: EvolveConfig, opts?: RuntimeOptions): Promise<void> | null;

package/dist/proxy/proxy.js

@@ -0,0 +1,120 @@
+import { normalizePath, resolveConfig } from "../config/config.js";
+import { assign, visitorDraw } from "../core/assign.js";
+import { createBotDetector } from "../core/bots.js";
+import { HEADER_CODE, HEADER_PATH } from "../core/constants.js";
+import { ANON_COOKIE, ASSIGN_COOKIE, PREVIEW_COOKIE, parseAssignments, serializeAssignments } from "../core/cookies.js";
+import { logRateLimited } from "../core/log.js";
+import { coldStart, getBundleStore, getSiteIdentity } from "../store/runtime.js";
+import { CONTROL_CODE, encodeCode, newAnonId, verifyPreview } from "@next-evolve/protocol";
+import { NextResponse } from "next/server";
+// src/proxy/proxy.ts
+/** Query parameter carrying a preview token from the dashboard. */
+const PREVIEW_PARAM = "evolve_preview";
+const detectors = /* @__PURE__ */ new WeakMap();
+/**
+* Runs Evolve for one request. Returns a response for Evolve routes and
+* `/ev_*` paths, or null for everything else (so it composes with an existing
+* proxy: `return applyEvolve(config, req, event) ?? NextResponse.next()`).
+* Never throws and never makes a network call on the request path.
+*/
+function applyEvolve(config, req, event, opts = {}) {
+	const t0 = performance.now();
+	const pathname = req.nextUrl.pathname;
+	if (pathname.split("/")[1]?.startsWith("ev_")) return new NextResponse(null, { status: 404 });
+	let cfg;
+	try {
+		cfg = resolveConfig(config);
+	} catch (e) {
+		logRateLimited("config", "invalid evolve config", e);
+		return null;
+	}
+	const path = normalizePath(pathname);
+	const route = cfg.routes.get(path);
+	if (!route) return null;
+	const isStatic = route.mode === "static";
+	let res;
+	try {
+		let isBot = detectors.get(config);
+		if (!isBot) {
+			isBot = createBotDetector(cfg.botPatterns);
+			detectors.set(config, isBot);
+		}
+		const bundle = getBundleStore(cfg, opts)?.peek(event ? (p) => event.waitUntil(p) : void 0) ?? null;
+		let code = CONTROL_CODE;
+		const setCookies = [];
+		const fromQuery = req.nextUrl.searchParams.get(PREVIEW_PARAM);
+		const previewToken = fromQuery ?? req.cookies.get("evolve_pv")?.value;
+		const identity = previewToken ? getSiteIdentity(opts) : null;
+		const preview = previewToken && identity ? verifyPreview(previewToken, identity) : null;
+		if (preview) {
+			code = preview.code;
+			if (fromQuery) setCookies.push([
+				PREVIEW_COOKIE,
+				fromQuery,
+				true
+			]);
+		} else if (bundle && !isBot(req.headers.get("user-agent")) && cfg.consent?.(req) !== false) {
+			const cookie = parseAssignments(req.cookies.get(ASSIGN_COOKIE)?.value);
+			const known = req.cookies.get(ANON_COOKIE)?.value;
+			const anon = known || newAnonId();
+			const a = assign(bundle, path, cookie, opts.random ?? visitorDraw(anon));
+			code = encodeCode(a.pairs);
+			if ((bundle.routing.routes[path] ?? []).some((e) => bundle.routing.experiments[e]?.status === "running")) {
+				if (!known) setCookies.push([ANON_COOKIE, anon]);
+				if (a.changed) setCookies.push([ASSIGN_COOKIE, serializeAssignments(a.assigned)]);
+			}
+		}
+		res = isStatic ? rewrite(req, code, path) : passThrough(req, code, path);
+		if (setCookies.length) {
+			const secure = (req.headers.get("x-forwarded-proto") ?? req.nextUrl.protocol.replace(":", "")) === "https";
+			const maxAge = cfg.cookies.maxAgeDays * 86400;
+			for (const [name, value, session] of setCookies) res.cookies.set(name, value, {
+				path: "/",
+				...session ? {} : { maxAge },
+				sameSite: "lax",
+				httpOnly: true,
+				secure,
+				...cfg.cookies.domain ? { domain: cfg.cookies.domain } : {}
+			});
+		}
+	} catch (e) {
+		logRateLimited("proxy", "proxy error; serving control", e);
+		res = isStatic ? rewrite(req, CONTROL_CODE, path) : passThrough(req, CONTROL_CODE, path);
+	}
+	if ((opts.env ?? process.env).VERCEL !== "1") res.headers.set("cache-control", "private, no-store");
+	res.headers.set("server-timing", `evolve;dur=${(performance.now() - t0).toFixed(3)}`);
+	return res;
+}
+function rewrite(req, code, path) {
+	const target = path === "/" ? `/${code}` : `/${code}${path}`;
+	return NextResponse.rewrite(new URL(target + req.nextUrl.search, req.url));
+}
+function passThrough(req, code, path) {
+	const headers = new Headers(req.headers);
+	headers.set(HEADER_CODE, code);
+	headers.set(HEADER_PATH, path);
+	return NextResponse.next({ request: { headers } });
+}
+/** Builds the `proxy` export for `proxy.ts` (Next 16) or `middleware.ts` (Next 15.5, Node runtime). */
+function createEvolveProxy(config, opts = {}) {
+	resolveConfig(config);
+	return function proxy(req, event) {
+		const ready = evolveReady(config, opts);
+		const run = () => applyEvolve(config, req, event, opts) ?? NextResponse.next();
+		return ready ? ready.then(run) : run();
+	};
+}
+/**
+* With Global Config, an instance's first request waits ≤ 20 ms for one read
+* (spec §7.8). Returns null when there's nothing to wait for. With an existing
+* proxy: `await evolveReady(config)` before `applyEvolve(...)`.
+*/
+function evolveReady(config, opts = {}) {
+	try {
+		const store = getBundleStore(resolveConfig(config), opts);
+		return store ? coldStart(store) : null;
+	} catch {
+		return null;
+	}
+}
+export { PREVIEW_PARAM, applyEvolve, createEvolveProxy, evolveReady };

package/dist/react/context.d.ts

@@ -0,0 +1,6 @@
+export type EvolveRequestContext = {
+  code: string | null;
+  path: string | null;
+};
+/** Per-request store (React `cache()`), filled by `withEvolve` before the page body renders. */
+export declare const requestContext: () => EvolveRequestContext;

package/dist/react/context.js

@@ -0,0 +1,8 @@
+import { cache } from "react";
+// src/react/context.ts
+/** Per-request store (React `cache()`), filled by `withEvolve` before the page body renders. */
+const requestContext = cache(() => ({
+	code: null,
+	path: null
+}));
+export { requestContext };

package/dist/react/optimizable.d.ts

@@ -0,0 +1,37 @@
+import { ComponentType } from "react";
+import { z } from "zod";
+declare const META: unique symbol;
+export type OptimizableMeta<S extends z.ZodObject = z.ZodObject> = {
+  schema: S;
+  /** JSON Schema of the editable props (dashboard forms; later the AI). Includes `.meta()`. */
+  jsonSchema: Record<string, unknown>;
+  /** sha256 of the canonical JSON Schema; changes when the schema changes. */
+  schemaHash: string;
+  keys: readonly string[];
+};
+export type OptimizableComponent<P extends object, S extends z.ZodObject = z.ZodObject> = ComponentType<P> & {
+  readonly [META]: OptimizableMeta<S>;
+};
+/**
+ * Compile-time check that the schema fits the component: every schema key is a
+ * prop the component accepts, with a compatible type.
+ */
+type SchemaFits<P, O> = [Exclude<keyof O, keyof P>] extends [never] ? O extends Pick<P, keyof O & keyof P> ? unknown : {
+  "schema error": "schema prop types don't match the component's props";
+} : {
+  "schema error": "schema has props the component doesn't accept";
+  keys: Exclude<keyof O, keyof P>;
+};
+/**
+ * Marks a component as optimizable with a Zod schema for the props Evolve may
+ * change. A schema that doesn't fit the component's props fails to compile.
+ * Server-only (the component renders inside `<Optimizable>`).
+ *
+ * ```ts
+ * export default optimizable(Hero, heroSchema);
+ * ```
+ */
+export declare function optimizable<P extends object, S extends z.ZodObject>(component: ComponentType<P>, schema: S & SchemaFits<P, z.output<S>>): OptimizableComponent<P, S>;
+export declare function getOptimizableMeta(c: unknown): OptimizableMeta | null;
+export declare function isRegionId(id: string): boolean;
+export {};

package/dist/react/optimizable.js

@@ -0,0 +1,38 @@
+import { REGION_ID_RE, canonicalJson, sha256Hex } from "@next-evolve/protocol";
+import { createElement } from "react";
+import { z } from "zod";
+// src/react/optimizable.ts
+const META = Symbol.for("next-evolve.optimizable");
+/**
+* Marks a component as optimizable with a Zod schema for the props Evolve may
+* change. A schema that doesn't fit the component's props fails to compile.
+* Server-only (the component renders inside `<Optimizable>`).
+*
+* ```ts
+* export default optimizable(Hero, heroSchema);
+* ```
+*/
+function optimizable(component, schema) {
+	const jsonSchema = z.toJSONSchema(schema, {
+		io: "input",
+		unrepresentable: "any"
+	});
+	const meta = {
+		schema,
+		jsonSchema,
+		schemaHash: sha256Hex(canonicalJson(jsonSchema)),
+		keys: Object.keys(schema.shape)
+	};
+	const Wrapped = ((props) => createElement(component, props));
+	Object.defineProperty(Wrapped, META, { value: meta });
+	Object.defineProperty(Wrapped, "displayName", { value: `Optimizable(${component.displayName ?? component.name ?? "Component"})` });
+	Object.defineProperty(Wrapped, "inner", { value: component });
+	return Wrapped;
+}
+function getOptimizableMeta(c) {
+	return c?.[META] ?? null;
+}
+function isRegionId(id) {
+	return REGION_ID_RE.test(id);
+}
+export { getOptimizableMeta, isRegionId, optimizable };

package/dist/react/region.d.ts

@@ -0,0 +1,17 @@
+import { OptimizableComponent } from "./optimizable.js";
+import { ReactElement } from "react";
+import { z } from "zod";
+/** Control props: the schema's input type (defaults optional) plus the component's other props. */
+export type ControlProps<P extends object, S extends z.ZodObject> = Omit<P, keyof z.output<S>> & z.input<S>;
+export type OptimizableProps<P extends object, S extends z.ZodObject> = {
+  /** Region id, unique per site: /^[a-z0-9][a-z0-9-]{0,39}$/. */
+  id: string;
+  component: OptimizableComponent<P, S>;
+  /** Control props. Variant props are merged over these; schema defaults apply. */
+  props: ControlProps<P, S>;
+};
+/**
+ * Renders the variant of a region chosen by the proxy, or control. Never throws
+ * because of Evolve: any problem renders control. Server component.
+ */
+export declare function Optimizable<P extends object, S extends z.ZodObject>({ id, component, props }: OptimizableProps<P, S>): Promise<ReactElement>;

package/dist/react/region.js

@@ -0,0 +1,127 @@
+import { registerRegion } from "../cloud/regions.js";
+import { HEADER_CODE, HEADER_PATH } from "../core/constants.js";
+import { logRateLimited } from "../core/log.js";
+import { requestContext } from "./context.js";
+import { getOptimizableMeta } from "./optimizable.js";
+import { getRenderBundle } from "./render-bundle.js";
+import { CONTROL_CODE, decodeCode } from "@next-evolve/protocol";
+import { createElement } from "react";
+import { headers } from "next/headers";
+import { unstable_rethrow } from "next/navigation";
+import { after } from "next/server";
+// src/react/region.tsx
+let warnedNoContext = false;
+async function currentCode() {
+	const ctx = requestContext();
+	if (ctx.code) return ctx.code;
+	try {
+		return (await headers()).get(HEADER_CODE);
+	} catch (e) {
+		unstable_rethrow(e);
+		return null;
+	}
+}
+/** The page path this region renders on (static: withEvolve; dynamic: the proxy header). */
+async function currentPath() {
+	const ctx = requestContext();
+	if (ctx.path) return ctx.path;
+	try {
+		return (await headers()).get(HEADER_PATH);
+	} catch (e) {
+		unstable_rethrow(e);
+		return null;
+	}
+}
+/** Region registration (spec §5.2): after the response, deduped per process, errors swallowed. */
+function scheduleRegistration(id, meta, controlProps, path) {
+	if (!path) return;
+	try {
+		after(() => registerRegion({
+			id,
+			jsonSchema: meta.jsonSchema,
+			schemaHash: meta.schemaHash,
+			controlProps,
+			path
+		}));
+	} catch {}
+}
+function findPair(bundle, pairs, region) {
+	for (const p of pairs) {
+		const v = bundle?.variants[p.var];
+		if (v && v.exp === p.exp && v.region === region) return {
+			pair: p,
+			variant: v
+		};
+	}
+	return null;
+}
+/**
+* Renders the variant of a region chosen by the proxy, or control. Never throws
+* because of Evolve: any problem renders control. Server component.
+*/
+async function Optimizable({ id, component, props }) {
+	const meta = getOptimizableMeta(component);
+	if (!meta) {
+		logRateLimited(`optimizable:${id}`, `<Optimizable id="${id}">: component isn't wrapped with optimizable()`);
+		return createElement(component, props);
+	}
+	const editableOf = (o) => {
+		const out = {};
+		for (const k of meta.keys) if (k in o) out[k] = o[k];
+		return out;
+	};
+	const parsedControl = meta.schema.safeParse(editableOf(props));
+	const controlProps = {
+		...props,
+		...parsedControl.success ? parsedControl.data : {}
+	};
+	const control = () => createElement(component, controlProps);
+	const code = await currentCode();
+	scheduleRegistration(id, meta, parsedControl.success ? parsedControl.data : editableOf(props), await currentPath());
+	if (!code) {
+		if (!warnedNoContext && process.env.NODE_ENV !== "production") {
+			warnedNoContext = true;
+			console.warn(`[evolve] <Optimizable id="${id}"> rendered without Evolve context; serving control. Wrap the page with withEvolve() under app/[evolve]/, or use a dynamic route.`);
+		}
+		return control();
+	}
+	if (code === CONTROL_CODE) return control();
+	const pairs = decodeCode(code);
+	if (!pairs || pairs.length === 0) return control();
+	let bundle = await getRenderBundle();
+	let hit = findPair(bundle, pairs, id);
+	const unknown = () => pairs.some((p) => !bundle?.variants[p.var]);
+	if (!hit && unknown()) {
+		bundle = await getRenderBundle({ fresh: true });
+		hit = findPair(bundle, pairs, id);
+	}
+	const marker = (attrs, child) => createElement("div", {
+		style: { display: "contents" },
+		"data-evolve-r": id,
+		...attrs
+	}, child);
+	if (!hit) return unknown() ? marker({ "data-evolve-x": "" }, control()) : control();
+	const { pair, variant } = hit;
+	const attrs = {
+		"data-evolve-e": pair.exp,
+		"data-evolve-v": pair.var
+	};
+	if (!pair.counted) attrs["data-evolve-x"] = "";
+	if (variant.ctrl || Object.keys(variant.props).length === 0) return marker(attrs, control());
+	const parsed = meta.schema.safeParse(editableOf({
+		...props,
+		...variant.props
+	}));
+	if (!parsed.success) {
+		logRateLimited(`variant:${pair.var}`, `variant ${pair.var} of region "${id}" failed its schema; serving control`, parsed.error.issues);
+		return marker({
+			...attrs,
+			"data-evolve-x": ""
+		}, control());
+	}
+	return marker(attrs, createElement(component, {
+		...props,
+		...parsed.data
+	}));
+}
+export { Optimizable };

package/dist/react/render-bundle.d.ts

@@ -0,0 +1,15 @@
+import { BundlePayload } from "@next-evolve/protocol";
+type Env = Record<string, string | undefined>;
+/**
+ * Bundle for rendering (spec §7.7). Warm: the process-wide store (shared with
+ * the proxy where they run in one process). Cold (empty store, e.g. a fresh
+ * serverless render function): `GET /v1/bundle` through Next's data cache,
+ * tagged `evolve-bundle`, so instances share it and the sync route's
+ * `revalidateTag` drops it. `fresh` pulls uncached, for a variant code the
+ * cached bundle doesn't know yet (a new or preview-only variant).
+ */
+export declare function getRenderBundle(opts?: {
+  fresh?: boolean;
+  env?: Env;
+}): Promise<BundlePayload | null>;
+export {};

package/dist/react/render-bundle.js

@@ -0,0 +1,43 @@
+import { BUNDLE_TAG } from "../server/sync-route.js";
+import { getBundleStore } from "../store/runtime.js";
+// src/react/render-bundle.ts
+/**
+* Bundle for rendering (spec §7.7). Warm: the process-wide store (shared with
+* the proxy where they run in one process). Cold (empty store, e.g. a fresh
+* serverless render function): `GET /v1/bundle` through Next's data cache,
+* tagged `evolve-bundle`, so instances share it and the sync route's
+* `revalidateTag` drops it. `fresh` pulls uncached, for a variant code the
+* cached bundle doesn't know yet (a new or preview-only variant).
+*/
+async function getRenderBundle(opts = {}) {
+	const env = opts.env ?? process.env;
+	const store = getBundleStore({}, { env });
+	if (!store) return null;
+	if (opts.fresh) {
+		await store.refresh({ force: true });
+		return store.peek();
+	}
+	const warm = store.peek();
+	if (warm) return warm;
+	const token = await taggedFetch(env);
+	if (token) store.load(token);
+	return store.peek();
+}
+async function taggedFetch(env) {
+	const cloudUrl = env.EVOLVE_CLOUD_URL ?? "https://api.evolveab.com";
+	const key = env.EVOLVE_SECRET_KEY;
+	if (!cloudUrl || !key) return null;
+	try {
+		const res = await fetch(new URL("/v1/bundle", cloudUrl), {
+			headers: { authorization: `Bearer ${key}` },
+			cache: "force-cache",
+			next: { tags: [BUNDLE_TAG] },
+			signal: AbortSignal.timeout(5e3)
+		});
+		if (!res.ok) return null;
+		return (await res.text()).trim() || null;
+	} catch {
+		return null;
+	}
+}
+export { getRenderBundle };

package/dist/react/with-evolve.d.ts

@@ -0,0 +1,29 @@
+import { ComponentType, ReactElement } from "react";
+import { Metadata } from "next";
+/** Props Next passes to a page under `app/[evolve]/`. */
+export type EvolvePageProps = {
+  params: Promise<{
+    evolve: string;
+  } & Record<string, string | string[] | undefined>>;
+  searchParams?: Promise<Record<string, string | string[] | undefined>>;
+};
+/**
+ * Wraps a static-mode page under `app/[evolve]/<route>/page.tsx`. Decodes the
+ * variant code from `params.evolve` and makes it available to every
+ * `<Optimizable>` on the page before the body renders.
+ */
+export declare function withEvolve<P extends object>(Page: ComponentType<P>, opts: {
+  path: string;
+}): (props: P & EvolvePageProps) => Promise<ReactElement>;
+/** `generateStaticParams` for `app/[evolve]/`: prerenders control only, so builds need no network. */
+export declare function evolveStaticParams(): {
+  evolve: string;
+}[];
+type MetadataInput = Metadata | ((props: EvolvePageProps) => Metadata | Promise<Metadata>);
+/**
+ * `generateMetadata` for a static-mode page: canonical is the original path
+ * for every variant, and variant renders are `noindex` (bots only ever get
+ * control anyway).
+ */
+export declare function evolveMetadata(path: string, base?: MetadataInput): (props: EvolvePageProps) => Promise<Metadata>;
+export {};

package/dist/react/with-evolve.js

@@ -0,0 +1,57 @@
+import { normalizePath } from "../config/config.js";
+import { requestContext } from "./context.js";
+import { CODE_RE, CONTROL_CODE } from "@next-evolve/protocol";
+import { createElement } from "react";
+import { notFound } from "next/navigation";
+// src/react/with-evolve.ts
+/** Validates the `[evolve]` segment; malformed codes are a 404. */
+async function readCode(params) {
+	const { evolve } = await params;
+	if (typeof evolve !== "string" || !CODE_RE.test(evolve)) notFound();
+	return evolve;
+}
+/**
+* Wraps a static-mode page under `app/[evolve]/<route>/page.tsx`. Decodes the
+* variant code from `params.evolve` and makes it available to every
+* `<Optimizable>` on the page before the body renders.
+*/
+function withEvolve(Page, opts) {
+	const path = normalizePath(opts.path);
+	async function EvolvePage(props) {
+		const code = await readCode(props.params);
+		const ctx = requestContext();
+		ctx.code = code;
+		ctx.path = path;
+		return createElement(Page, props);
+	}
+	Object.defineProperty(EvolvePage, "name", { value: `withEvolve(${Page.displayName ?? Page.name ?? "Page"})` });
+	return EvolvePage;
+}
+/** `generateStaticParams` for `app/[evolve]/`: prerenders control only, so builds need no network. */
+function evolveStaticParams() {
+	return [{ evolve: CONTROL_CODE }];
+}
+/**
+* `generateMetadata` for a static-mode page: canonical is the original path
+* for every variant, and variant renders are `noindex` (bots only ever get
+* control anyway).
+*/
+function evolveMetadata(path, base = {}) {
+	const canonical = normalizePath(path);
+	return async function generateMetadata(props) {
+		const code = await readCode(props.params);
+		const m = typeof base === "function" ? await base(props) : base;
+		return {
+			...m,
+			alternates: {
+				...m.alternates,
+				canonical
+			},
+			...code === CONTROL_CODE ? {} : { robots: {
+				index: false,
+				follow: true
+			} }
+		};
+	};
+}
+export { evolveMetadata, evolveStaticParams, withEvolve };

package/dist/server/aggregate-route.d.ts

@@ -0,0 +1,16 @@
+import { ResolvedConfig } from "../config/config.js";
+import { Sql } from "../db/client.js";
+import { ReplayGuard } from "@next-evolve/protocol";
+type Env = Record<string, string | undefined>;
+export type AggregateRouteDeps = {
+  config: ResolvedConfig;
+  env: Env;
+  sql: () => Sql | null;
+  sdkVersion: string;
+  replay?: ReplayGuard;
+  now?: () => number;
+};
+/** Delivery ids seen in the last 10 minutes, shared by every signed cloud → app route. */
+export declare function sharedReplayGuard(): ReplayGuard;
+export declare function handleAggregate(req: Request, deps: AggregateRouteDeps): Promise<Response>;
+export {};

package/dist/server/aggregate-route.js

@@ -0,0 +1,68 @@
+import { runAggregate } from "../aggregate/run.js";
+import { DELIVERY_HEADER, SIGNATURE_HEADER, aggregateRequestSchema, createReplayGuard, isSupportedProtocol, parseSecretKey, signBody, unsupportedProtocolBody, verifyBody } from "@next-evolve/protocol";
+// src/server/aggregate-route.ts
+const MAX_BODY_BYTES = 262144;
+const KEY = Symbol.for("next-evolve.replay");
+/** Delivery ids seen in the last 10 minutes, shared by every signed cloud → app route. */
+function sharedReplayGuard() {
+	const g = globalThis;
+	g[KEY] ??= createReplayGuard();
+	return g[KEY];
+}
+const json = (status, body, headers = {}) => Response.json(body, {
+	status,
+	headers
+});
+async function handleAggregate(req, deps) {
+	const secret = deps.env.EVOLVE_WEBHOOK_SECRET;
+	const site = parseSecretKey(deps.env.EVOLVE_SECRET_KEY ?? "")?.siteId;
+	if (!secret || !site) return json(503, { error: "not_configured" });
+	const body = await req.text();
+	if (Buffer.byteLength(body) > MAX_BODY_BYTES) return json(413, { error: "too_large" });
+	const now = deps.now ?? Date.now;
+	const sig = verifyBody(req.headers.get(SIGNATURE_HEADER), body, secret, { now: Math.floor(now() / 1e3) });
+	if (!sig.ok) return json(401, {
+		error: "invalid_signature",
+		reason: sig.reason
+	});
+	const delivery = req.headers.get(DELIVERY_HEADER) ?? "";
+	if (!(deps.replay ?? sharedReplayGuard()).check(delivery)) return json(409, { error: "replayed" });
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		return json(400, { error: "invalid_json" });
+	}
+	if (!isSupportedProtocol(parsed?.pv)) return json(400, unsupportedProtocolBody());
+	const r = aggregateRequestSchema.safeParse(parsed);
+	if (!r.success) return json(400, { error: "invalid" });
+	if (r.data.site !== site) return json(403, { error: "site_mismatch" });
+	const sql = deps.sql();
+	if (!sql) return json(503, { error: "no_database" });
+	let result;
+	try {
+		result = await runAggregate(sql, r.data, {
+			maxMs: deps.config.aggregate.maxMs,
+			statementTimeoutMs: deps.config.aggregate.statementTimeoutMs,
+			sdkVersion: deps.sdkVersion,
+			now
+		});
+	} catch (e) {
+		console.error("[evolve] aggregate failed", e);
+		return json(503, { error: "database_error" });
+	}
+	if (result.kind === "busy") return json(429, {
+		busy: true,
+		retryAfter: result.retryAfter
+	}, { "retry-after": String(result.retryAfter) });
+	const out = JSON.stringify(result.response);
+	return new Response(out, {
+		status: 200,
+		headers: {
+			"content-type": "application/json",
+			"cache-control": "no-store",
+			[SIGNATURE_HEADER]: signBody(secret, out, Math.floor(now() / 1e3))
+		}
+	});
+}
+export { handleAggregate, sharedReplayGuard };