next-evolve 0.1.0 → 0.3.1

package/dist/cli/pages.js

@@ -0,0 +1,304 @@
+import { addImport } from "./files.js";
+import { readdirSync, statSync } from "node:fs";
+import { join, posix } from "node:path";
+import { createRequire } from "node:module";
+// src/cli/pages.ts
+const PAGE_EXTS = [
+	"tsx",
+	"jsx",
+	"ts",
+	"js"
+];
+const SPECIAL = /^(layout|template|loading|error|not-found|default)\.(tsx|jsx|ts|js)$/;
+const ROUTE_FILE = /^(page|route)\.(tsx|jsx|ts|js|mdx)$/;
+/** The app's typescript, else the one next to next-evolve; null when neither exists. */
+function loadTypescript(root) {
+	for (const from of [join(root, "package.json"), import.meta.url]) try {
+		return createRequire(from)("typescript");
+	} catch {}
+	return null;
+}
+function list(root, dir) {
+	try {
+		const entries = readdirSync(join(root, dir));
+		const files = [];
+		const dirs = [];
+		for (const e of entries) {
+			const full = join(root, dir, e);
+			(statSync(full).isDirectory() ? dirs : files).push(e);
+		}
+		return {
+			files,
+			dirs
+		};
+	} catch {
+		return {
+			files: [],
+			dirs: []
+		};
+	}
+}
+/** Whether any folder below `dir` holds a page or route handler. */
+function hasChildRoutes(root, dir) {
+	for (const sub of list(root, dir).dirs) {
+		const p = `${dir}/${sub}`;
+		if (list(root, p).files.some((f) => ROUTE_FILE.test(f)) || hasChildRoutes(root, p)) return true;
+	}
+	return false;
+}
+/** Finds `seg/page.*` inside some route group, for the note. */
+function findInGroup(root, dir, seg) {
+	for (const sub of list(root, dir).dirs) {
+		if (!/^\(.+\)$/.test(sub)) continue;
+		const p = `${dir}/${sub}`;
+		if (PAGE_EXTS.map((e) => `${p}/${seg ? `${seg}/` : ""}page.${e}`).find((f) => list(root, posix.dirname(f)).files.includes(posix.basename(f)))) return sub;
+		const deeper = findInGroup(root, p, seg);
+		if (deeper) return deeper;
+	}
+	return null;
+}
+function planPages(plan, d, routes) {
+	const app = d.appDir;
+	if (!app || !routes.some((r) => r.mode === "static")) return routes;
+	const dynamicRoot = list(plan.root, app).dirs.find((x) => /^\[.+\]$/.test(x) && x !== "[evolve]");
+	const ts = loadTypescript(plan.root);
+	return routes.map((r) => {
+		if (r.mode !== "static") return r;
+		const keep = (why) => {
+			plan.notes.push(`${r.path}: kept dynamic, ${why}`);
+			return {
+				...r,
+				mode: "dynamic"
+			};
+		};
+		if (dynamicRoot) return keep(`${app}/${dynamicRoot} conflicts with ${app}/[evolve] (static mode needs the top-level dynamic segment); "dynamic" mode works`);
+		const seg = r.path.replace(/^\/|\/$/g, "");
+		const from = seg ? `${app}/${seg}` : app;
+		const to = seg ? `${app}/[evolve]/${seg}` : `${app}/[evolve]`;
+		const pageName = PAGE_EXTS.map((e) => `page.${e}`).find((f) => plan.exists(`${from}/${f}`));
+		const moved = PAGE_EXTS.map((e) => `${to}/page.${e}`).find((f) => plan.exists(f));
+		if (!pageName) {
+			if (moved && plan.read(moved).includes("withEvolve")) return r;
+			const group = findInGroup(plan.root, app, seg);
+			return keep(group ? `the page is inside the route group ${group}; move it under ${app}/[evolve]/ by hand for static mode` : `no page found at ${from}/page.*`);
+		}
+		if (moved) return keep(`${moved} already exists`);
+		if (!ts) return keep(`typescript isn't installed, so the page can't be moved safely`);
+		const src = plan.read(`${from}/${pageName}`);
+		const rewritten = wrapPage(ts, src, pageName, r.path);
+		if (!rewritten.ok) return keep(rewritten.why);
+		const files = list(plan.root, from).files;
+		let movers = [pageName];
+		if (seg) {
+			if (hasChildRoutes(plan.root, from)) {
+				const special = files.find((f) => SPECIAL.test(f));
+				if (special) return keep(`${from}/${special} also wraps its child routes`);
+			} else movers = files;
+		}
+		const map = new Map(movers.map((f) => [`${from}/${f}`, `${to}/${f}`]));
+		for (const [oldPath, newPath] of map) {
+			const content = oldPath.endsWith(`/${pageName}`) ? rewritten.code : plan.read(oldPath);
+			const code = /\.(tsx?|jsx?|mjs|cjs)$/.test(oldPath) ? rewriteImports(ts, content, oldPath, newPath, map) : content;
+			plan.write(newPath, code);
+			plan.remove(oldPath);
+		}
+		plan.notes.push(`${r.path}: moved ${from}/${pageName} → ${to}/${pageName} (static mode)`);
+		return r;
+	});
+}
+const applyEdits = (src, edits) => [...edits].sort((a, b) => b.start - a.start).reduce((s, e) => s.slice(0, e.start) + e.text + s.slice(e.end), src);
+const kindFor = (ts, file) => file.endsWith(".tsx") ? ts.ScriptKind.TSX : file.endsWith(".ts") ? ts.ScriptKind.TS : file.endsWith(".jsx") ? ts.ScriptKind.JSX : ts.ScriptKind.JS;
+const parse = (ts, src, file) => ts.createSourceFile(file, src, ts.ScriptTarget.Latest, true, kindFor(ts, file));
+const hasMod = (ts, n, k) => (ts.canHaveModifiers(n) ? ts.getModifiers(n) : void 0)?.some((m) => m.kind === k) ?? false;
+/** Removes `export` (and `default`) modifiers from a declaration. */
+function stripExport(ts, n, sf) {
+	return ((ts.canHaveModifiers(n) ? ts.getModifiers(n) : void 0) ?? []).filter((m) => m.kind === ts.SyntaxKind.ExportKeyword || m.kind === ts.SyntaxKind.DefaultKeyword).map((m) => {
+		let end = m.getEnd();
+		while (/\s/.test(sf.text[end] ?? "")) end++;
+		return {
+			start: m.getStart(sf),
+			end,
+			text: ""
+		};
+	});
+}
+function exportedConst(ts, s, name) {
+	if (!ts.isVariableStatement(s) || !hasMod(ts, s, ts.SyntaxKind.ExportKeyword)) return null;
+	return s.declarationList.declarations.find((d) => ts.isIdentifier(d.name) && d.name.text === name) ?? null;
+}
+/** Wraps the page module: default export → withEvolve, metadata → evolveMetadata. */
+function wrapPage(ts, src, file, path) {
+	const sf = parse(ts, src, file);
+	const first = sf.statements[0];
+	if (first && ts.isExpressionStatement(first) && ts.isStringLiteral(first.expression) && first.expression.text === "use client") return {
+		ok: false,
+		why: `the page is "use client" (withEvolve needs a server page)`
+	};
+	const edits = [];
+	let component = null;
+	let metadata = null;
+	const has = {
+		revalidate: false,
+		dynamicParams: false
+	};
+	for (const s of sf.statements) {
+		const dyn = exportedConst(ts, s, "dynamic");
+		if (dyn?.initializer && ts.isStringLiteral(dyn.initializer) && dyn.initializer.text === "force-dynamic") return {
+			ok: false,
+			why: `the page sets dynamic = "force-dynamic"`
+		};
+		const dp = exportedConst(ts, s, "dynamicParams");
+		if (dp) {
+			if (dp.initializer?.kind === ts.SyntaxKind.FalseKeyword) return {
+				ok: false,
+				why: "the page sets dynamicParams = false"
+			};
+			has.dynamicParams = true;
+		}
+		if (exportedConst(ts, s, "revalidate")) has.revalidate = true;
+		if (exportedConst(ts, s, "generateStaticParams")) return {
+			ok: false,
+			why: "the page has its own generateStaticParams"
+		};
+		if (ts.isFunctionDeclaration(s) && hasMod(ts, s, ts.SyntaxKind.ExportKeyword) && !hasMod(ts, s, ts.SyntaxKind.DefaultKeyword)) {
+			if (s.name?.text === "generateStaticParams") return {
+				ok: false,
+				why: "the page has its own generateStaticParams"
+			};
+			if (s.name?.text === "generateMetadata") {
+				edits.push(...stripExport(ts, s, sf));
+				edits.push({
+					start: s.name.getStart(sf),
+					end: s.name.getEnd(),
+					text: "baseMetadata"
+				});
+				metadata = "baseMetadata";
+			}
+		}
+		if (exportedConst(ts, s, "generateMetadata") && ts.isVariableStatement(s)) {
+			const decl = exportedConst(ts, s, "generateMetadata");
+			edits.push(...stripExport(ts, s, sf));
+			edits.push({
+				start: decl.name.getStart(sf),
+				end: decl.name.getEnd(),
+				text: "baseMetadata"
+			});
+			metadata = "baseMetadata";
+		}
+		if (exportedConst(ts, s, "metadata") && ts.isVariableStatement(s)) {
+			edits.push(...stripExport(ts, s, sf));
+			metadata = "metadata";
+		}
+		if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && hasMod(ts, s, ts.SyntaxKind.DefaultKeyword)) {
+			edits.push(...stripExport(ts, s, sf));
+			if (s.name) component = s.name.text;
+			else {
+				component = "Page";
+				const kw = s.getChildren(sf).find((c) => c.kind === ts.SyntaxKind.FunctionKeyword || c.kind === ts.SyntaxKind.ClassKeyword);
+				const star = ts.isFunctionDeclaration(s) ? s.asteriskToken : void 0;
+				const at = star ? star.getEnd() : kw.getEnd();
+				let end = at;
+				while (/\s/.test(sf.text[end] ?? "")) end++;
+				edits.push({
+					start: at,
+					end,
+					text: " Page"
+				});
+			}
+		} else if (ts.isExportAssignment(s) && !s.isExportEquals) {
+			if (ts.isIdentifier(s.expression)) {
+				component = s.expression.text;
+				let end = s.getEnd();
+				if (sf.text[end] === "\n") end++;
+				edits.push({
+					start: s.getStart(sf),
+					end,
+					text: ""
+				});
+			} else {
+				component = "Page";
+				edits.push({
+					start: s.getStart(sf),
+					end: s.expression.getStart(sf),
+					text: "const Page = "
+				});
+			}
+		} else if (ts.isExportDeclaration(s) && s.exportClause && ts.isNamedExports(s.exportClause)) {
+			if (s.exportClause.elements.some((e) => e.name.text === "default")) return {
+				ok: false,
+				why: "the default export is re-exported by name; wrap it by hand"
+			};
+		}
+	}
+	if (!component) return {
+		ok: false,
+		why: "the page has no default export"
+	};
+	const want = [
+		"evolveMetadata",
+		"evolveStaticParams",
+		"withEvolve"
+	];
+	const existing = sf.statements.find((s) => ts.isImportDeclaration(s) && ts.isStringLiteral(s.moduleSpecifier) && s.moduleSpecifier.text === "next-evolve" && !s.importClause?.isTypeOnly && !!s.importClause?.namedBindings && ts.isNamedImports(s.importClause.namedBindings));
+	let addLine = null;
+	if (existing) {
+		const named = existing.importClause.namedBindings;
+		const have = named.elements.map((e) => e.name.text);
+		const add = want.filter((n) => !have.includes(n));
+		if (add.length) {
+			const last = named.elements[named.elements.length - 1];
+			const at = last ? last.getEnd() : named.getStart(sf) + 1;
+			edits.push({
+				start: at,
+				end: at,
+				text: `${last ? ", " : " "}${add.join(", ")}`
+			});
+		}
+	} else addLine = `import { ${want.join(", ")} } from "next-evolve";`;
+	let code = applyEdits(src, edits);
+	if (addLine) code = addImport(code, addLine);
+	const p = JSON.stringify(path);
+	const tail = [
+		"",
+		"// Static mode (next-evolve): one cached render per variant under [evolve].",
+		...has.dynamicParams ? [] : ["export const dynamicParams = true;"],
+		"export const generateStaticParams = evolveStaticParams;",
+		...has.revalidate ? [] : ["export const revalidate = 3600;"],
+		`export const generateMetadata = evolveMetadata(${p}${metadata ? `, ${metadata}` : ""});`,
+		`export default withEvolve(${component}, { path: ${p} });`,
+		""
+	];
+	return {
+		ok: true,
+		code: `${code.replace(/\s*$/, "\n")}${tail.join("\n")}`
+	};
+}
+/** Rewrites relative specifiers for a file that moved; files moving together keep pointing at each other. */
+function rewriteImports(ts, src, oldPath, newPath, moves) {
+	const sf = parse(ts, src, oldPath);
+	const edits = [];
+	const stripExt = (p) => p.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+	const movedNoExt = new Map([...moves].map(([o, n]) => [stripExt(o), stripExt(n)]));
+	const fix = (lit) => {
+		const spec = lit.text;
+		if (!spec.startsWith("./") && !spec.startsWith("../")) return;
+		let target = posix.normalize(posix.join(posix.dirname(oldPath), spec));
+		target = moves.get(target) ?? movedNoExt.get(target) ?? target;
+		let rel = posix.relative(posix.dirname(newPath), target);
+		if (!rel.startsWith(".")) rel = `./${rel}`;
+		if (rel !== spec) edits.push({
+			start: lit.getStart(sf) + 1,
+			end: lit.getEnd() - 1,
+			text: rel
+		});
+	};
+	const visit = (n) => {
+		if ((ts.isImportDeclaration(n) || ts.isExportDeclaration(n)) && n.moduleSpecifier && ts.isStringLiteral(n.moduleSpecifier)) fix(n.moduleSpecifier);
+		else if (ts.isCallExpression(n) && (n.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(n.expression) && n.expression.text === "require") && n.arguments[0] && ts.isStringLiteralLike(n.arguments[0])) fix(n.arguments[0]);
+		else if (ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument) && ts.isStringLiteral(n.argument.literal)) fix(n.argument.literal);
+		ts.forEachChild(n, visit);
+	};
+	visit(sf);
+	return applyEdits(src, edits);
+}
+export { loadTypescript, planPages, rewriteImports, wrapPage };

package/dist/cli/plan.d.ts

@@ -0,0 +1,27 @@
+export type FileChange = {
+  path: string;
+  before: string | null;
+  after: string | null;
+};
+export declare class Plan {
+  readonly root: string;
+  private readonly files;
+  /** Things the developer must do by hand (printed at the end). */
+  readonly manual: string[];
+  readonly notes: string[];
+  constructor(root: string);
+  private disk;
+  /** Current content, including planned changes. */
+  read(path: string): string | null;
+  exists(path: string): boolean;
+  write(path: string, content: string): void;
+  /** Writes only if the file doesn't exist yet. Returns whether it will be created. */
+  create(path: string, content: string): boolean;
+  remove(path: string): void;
+  move(from: string, to: string): void;
+  /** Changes that differ from disk, sorted by path. */
+  changes(): FileChange[];
+  apply(): void;
+}
+/** A readable diff of the plan: whole new files, line diffs for changed ones. */
+export declare function renderDiff(changes: FileChange[]): string;

package/dist/cli/plan.js

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+// src/cli/plan.ts
+var Plan = class {
+	root;
+	files = /* @__PURE__ */ new Map();
+	/** Things the developer must do by hand (printed at the end). */
+	manual = [];
+	notes = [];
+	constructor(root) {
+		this.root = root;
+	}
+	disk(path) {
+		const p = join(this.root, path);
+		try {
+			return existsSync(p) ? readFileSync(p, "utf8") : null;
+		} catch {
+			return null;
+		}
+	}
+	/** Current content, including planned changes. */
+	read(path) {
+		return this.files.has(path) ? this.files.get(path) : this.disk(path);
+	}
+	exists(path) {
+		return this.read(path) !== null;
+	}
+	write(path, content) {
+		this.files.set(path, content);
+	}
+	/** Writes only if the file doesn't exist yet. Returns whether it will be created. */
+	create(path, content) {
+		if (this.exists(path)) return false;
+		this.write(path, content);
+		return true;
+	}
+	remove(path) {
+		this.files.set(path, null);
+	}
+	move(from, to) {
+		const c = this.read(from);
+		if (c === null) return;
+		this.write(to, c);
+		this.remove(from);
+	}
+	/** Changes that differ from disk, sorted by path. */
+	changes() {
+		const out = [];
+		for (const [path, after] of this.files) {
+			const before = this.disk(path);
+			if (before !== after) out.push({
+				path,
+				before,
+				after
+			});
+		}
+		return out.sort((a, b) => a.path.localeCompare(b.path));
+	}
+	apply() {
+		for (const c of this.changes()) {
+			const p = join(this.root, c.path);
+			if (c.after === null) rmSync(p, { force: true });
+			else {
+				mkdirSync(dirname(p), { recursive: true });
+				writeFileSync(p, c.after);
+			}
+		}
+	}
+};
+/** A readable diff of the plan: whole new files, line diffs for changed ones. */
+function renderDiff(changes) {
+	const out = [];
+	for (const raw of changes) {
+		const c = /(^|\/)\.env/.test(raw.path) ? maskEnv(raw) : raw;
+		if (c.before === null) {
+			out.push(`+++ ${c.path} (new)`);
+			for (const l of c.after.replace(/\n$/, "").split("\n")) out.push(`+ ${l}`);
+		} else if (c.after === null) out.push(`--- ${c.path} (removed)`);
+		else {
+			out.push(`*** ${c.path}`);
+			out.push(...lineDiff(c.before, c.after));
+		}
+		out.push("");
+	}
+	return out.join("\n");
+}
+/** Line diff via LCS, with 1 line of context around changes. */
+function lineDiff(a, b) {
+	const x = a.replace(/\n$/, "").split("\n");
+	const y = b.replace(/\n$/, "").split("\n");
+	const n = x.length;
+	const m = y.length;
+	const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) lcs[i][j] = x[i] === y[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const ops = [];
+	let i = 0;
+	let j = 0;
+	while (i < n && j < m) if (x[i] === y[j]) {
+		ops.push([" ", x[i]]);
+		i++;
+		j++;
+	} else if (lcs[i + 1][j] >= lcs[i][j + 1]) ops.push(["-", x[i++]]);
+	else ops.push(["+", y[j++]]);
+	while (i < n) ops.push(["-", x[i++]]);
+	while (j < m) ops.push(["+", y[j++]]);
+	const changed = (k) => ops[k] !== void 0 && ops[k][0] !== " ";
+	const lines = [];
+	let skipped = false;
+	ops.forEach((o, k) => {
+		if (changed(k) || changed(k - 1) || changed(k + 1)) {
+			lines.push(`${o[0]} ${o[1]}`);
+			skipped = false;
+		} else if (!skipped) {
+			lines.push("  …");
+			skipped = true;
+		}
+	});
+	return lines;
+}
+/** Never print secrets: `KEY=value` → `KEY=…` in env files. */
+function maskEnv(c) {
+	const mask = (s) => s?.replace(/^(\s*[A-Z0-9_]+\s*=).+$/gm, "$1…") ?? null;
+	return {
+		...c,
+		before: mask(c.before),
+		after: mask(c.after)
+	};
+}
+export { Plan, renderDiff };

package/dist/cli/pull.d.ts

@@ -0,0 +1,13 @@
+type Env = Record<string, string | undefined>;
+export declare const BUILD_BUNDLE_PATH = ".evolve/bundle.generated.ts";
+export type PullDeps = {
+  env: Env;
+  cwd?: string;
+  out?: (s: string) => void;
+  err?: (s: string) => void;
+};
+export declare const renderBuildBundle: (token: string | null) => string;
+/** The token inside a generated module, or null. */
+export declare function readBuildBundle(source: string): string | null;
+export declare function pullCommand(_args: string[], deps: PullDeps): Promise<number>;
+export {};

package/dist/cli/pull.js

@@ -0,0 +1,62 @@
+import { trustedKeys } from "../core/keys.js";
+import { fetchBundle } from "../store/fetch.js";
+import "../store/runtime.js";
+import { parseSecretKey, verifyBundle } from "@next-evolve/protocol";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+// src/cli/pull.ts
+const BUILD_BUNDLE_PATH = ".evolve/bundle.generated.ts";
+const HEADER = "// Generated by next-evolve pull. Do not edit; do not commit.\n";
+const renderBuildBundle = (token) => `${HEADER}const bundle: string | null = ${JSON.stringify(token)};\nexport default bundle;\n`;
+/** The token inside a generated module, or null. */
+function readBuildBundle(source) {
+	const m = /const bundle: string \| null = ("[A-Za-z0-9_.-]+");/.exec(source);
+	return m ? JSON.parse(m[1]) : null;
+}
+async function pullCommand(_args, deps) {
+	const { env } = deps;
+	const out = deps.out ?? ((s) => console.warn(s));
+	const err = deps.err ?? ((s) => console.error(s));
+	const file = join(deps.cwd ?? process.cwd(), BUILD_BUNDLE_PATH);
+	mkdirSync(dirname(file), { recursive: true });
+	const key = env.EVOLVE_SECRET_KEY;
+	const site = parseSecretKey(key ?? "")?.siteId;
+	const keys = trustedKeys(env);
+	const now = Math.floor(Date.now() / 1e3);
+	const valid = (token) => token && site ? verifyBundle(token, {
+		keys,
+		site,
+		now
+	}) : null;
+	let current = null;
+	try {
+		current = readFileSync(file, "utf8");
+	} catch {}
+	const previous = current === null ? null : readBuildBundle(current);
+	const write = (token) => {
+		const next = renderBuildBundle(token);
+		if (next !== current) writeFileSync(file, next);
+	};
+	const keep = (why) => {
+		const token = valid(previous)?.ok ? previous : null;
+		write(token);
+		err(`next-evolve pull: ${why}; ${token ? "kept the previous bundle" : "wrote an empty build bundle (control until the first fetch)"}`);
+		return 0;
+	};
+	if (!key || !site) return keep("EVOLVE_SECRET_KEY is not set");
+	const cloudUrl = env.EVOLVE_CLOUD_URL ?? "https://api.evolveab.com";
+	if (!cloudUrl) return keep("no cloud URL");
+	const res = await fetchBundle({
+		cloudUrl,
+		secretKey: key,
+		timeoutMs: 1e4
+	});
+	if (res.status === "error") return keep(`bundle fetch failed (${res.code})`);
+	if (res.status !== "ok") return keep("unexpected 304");
+	const v = valid(res.token);
+	if (!v?.ok) return keep(`bundle rejected (${v?.reason ?? "invalid"})`);
+	write(res.token);
+	out(`next-evolve pull: wrote ${BUILD_BUNDLE_PATH} (ver ${v.payload.ver})`);
+	return 0;
+}
+export { BUILD_BUNDLE_PATH, pullCommand, readBuildBundle, renderBuildBundle };

package/dist/cli/push.d.ts

@@ -0,0 +1,14 @@
+import { AppModules } from "./load-app.js";
+type Env = Record<string, string | undefined>;
+export type PushDeps = {
+  env: Env;
+  cwd?: string;
+  out?: (s: string) => void;
+  err?: (s: string) => void;
+  /** No success output (init prints its own). */
+  quiet?: boolean;
+  /** Inject the app's modules (tests). */
+  load?: () => Promise<AppModules>;
+};
+export declare function pushCommand(_args: string[], deps: PushDeps): Promise<number>;
+export {};

package/dist/cli/push.js

@@ -0,0 +1,33 @@
+import { buildManifest, detectAppUrl } from "../cloud/manifest.js";
+import { pushToCloud } from "../cloud/push.js";
+import { loadAppModules, reexecWithTypes } from "./load-app.js";
+// src/cli/push.ts
+async function pushCommand(_args, deps) {
+	const out = deps.out ?? ((s) => console.warn(s));
+	const err = deps.err ?? ((s) => console.error(s));
+	const cwd = deps.cwd ?? process.cwd();
+	if (!deps.env.EVOLVE_SECRET_KEY) {
+		err("next-evolve push: set EVOLVE_SECRET_KEY");
+		return 1;
+	}
+	let mods;
+	if (deps.load) mods = await deps.load();
+	else {
+		const r = await loadAppModules(cwd);
+		if (!r.ok) {
+			if (r.needsTs && process.argv[1] && !deps.load) return reexecWithTypes("push", [], cwd, deps.env, deps.quiet);
+			err(`next-evolve push: ${r.error}. The manifest is also sent when your app starts.`);
+			return 1;
+		}
+		mods = r.mods;
+	}
+	const manifest = buildManifest(mods.config, mods.goals, { appUrl: detectAppUrl(deps.env) });
+	const res = await pushToCloud("/v1/manifest", manifest, { env: deps.env });
+	if (!res.ok) {
+		err(`next-evolve push: the cloud refused the manifest (${res.status})`);
+		return 1;
+	}
+	out(`next-evolve push: sent ${Object.keys(manifest.routes).length} route(s) and ${Object.keys(manifest.goals).length} goal(s)`);
+	return 0;
+}
+export { pushCommand };

package/dist/cloud/manifest.d.ts

@@ -1,6 +1,8 @@
 import { EvolveConfig } from "../config/config.js";
 import { Goals } from "../config/goals.js";
 import { Manifest } from "@next-evolve/protocol";
+/** This package's version (`0.0.0` if unknown). */
+export declare function sdkVersion(): string;
 /** The manifest this app sends to the cloud (spec §8.4). Configuration only. */
 export declare function buildManifest(config: EvolveConfig, goals: Goals | undefined, opts?: {
   appUrl?: string | null;

package/dist/cloud/manifest.js

@@ -11,6 +11,10 @@ const versionOf = (load) => {
 		return null;
 	}
 };
+/** This package's version (`0.0.0` if unknown). */
+function sdkVersion() {
+	return versionOf(() => require("next-evolve/package.json")) ?? "0.0.0";
+}
 /** The manifest this app sends to the cloud (spec §8.4). Configuration only. */
 function buildManifest(config, goals, opts = {}) {
 	const routes = {};
@@ -18,7 +22,7 @@ function buildManifest(config, goals, opts = {}) {
 	const serialized = goals ? serializeGoals(goals) : {};
 	return {
 		pv: PROTOCOL_VERSION,
-		sdkVersion: versionOf(() => require("next-evolve/package.json")) ?? "0.0.0",
+		sdkVersion: sdkVersion(),
 		protocol: { supported: [...SUPPORTED_PROTOCOLS] },
 		nextVersion: versionOf(() => require("next/package.json")),
 		routes,
@@ -39,4 +43,4 @@ function detectAppUrl(env = process.env) {
 	if (env.VERCEL_ENV === "production" && env.VERCEL_PROJECT_PRODUCTION_URL) return `https://${env.VERCEL_PROJECT_PRODUCTION_URL}`;
 	return null;
 }
-export { buildManifest, detectAppUrl };
+export { buildManifest, detectAppUrl, sdkVersion };

package/dist/core/assign.d.ts

@@ -5,6 +5,18 @@ type Variant = {
 };
 /** Picks a variant id for r ∈ [0, 1) proportionally to weight (w > 0 only). */
 export declare function weightedPick(variants: readonly Variant[], r: number): string;
+/**
+ * A draw in [0, 1) for a key, e.g. `<exp>:t` (traffic) and `<exp>:v` (variant).
+ * `Math.random` fits too (it ignores the key).
+ */
+export type Draw = (key: string) => number;
+/**
+ * Deterministic draws for one visitor: the same `evolve_id` and experiment give
+ * the same assignment on every request, so concurrent first requests (a link
+ * prefetch and the click that follows) can't assign different variants.
+ * FNV-1a with a murmur3 finalizer; uniform enough for traffic splits, not crypto.
+ */
+export declare function visitorDraw(anonId: string): Draw;
 export type Assignment = {
   /** Pairs for the variant code (unsorted; `encodeCode` sorts). */
   pairs: CodePair[];
@@ -19,5 +31,5 @@ export type Assignment = {
  * winner and aren't counted. Cookie entries for experiments no longer in the
  * bundle are pruned.
  */
-export declare function assign(bundle: BundlePayload, path: string, cookie: ReadonlyMap<string, string>, rand: () => number): Assignment;
+export declare function assign(bundle: BundlePayload, path: string, cookie: ReadonlyMap<string, string>, rand: Draw): Assignment;
 export {};