@saywright/studio 0.1.0 → 0.2.0

package/dist/cli.mjs

@@ -274,8 +274,323 @@ function speechDir(layout) {
 }
 //#endregion
 //#region ../../packages/vite/dist/protocol.js
+/**
+* What is never recorded: passwords, one-time codes, keys and tokens, card and bank numbers. The bridge's two
+* recorders (test sessions, and Write test), the studio (for what an older plugin still sends), the tests it writes
+* and what it sends an AI all go by these rules, so a secret is caught the same way wherever it would show.
+*
+* A field is secret by what it is (a password field, a field someone marked private) or by what it is called (its
+* name, id, autocomplete, label or placeholder: “Password”, “cc-number”, “API key”, “رمز التحقق”). A value is secret
+* by its look alone (a card number, a key or a token), whatever its field is called. A test types a secret from the
+* environment (SAYWRIGHT_SECRET_PASSWORD), never from its own file.
+*/
+/** Shown in place of a secret. */
+var MASK = "•••";
+/** A generated test reads the secret named PASSWORD from the environment variable SAYWRIGHT_SECRET_PASSWORD. */
+var SECRET_ENV_PREFIX = "SAYWRIGHT_SECRET_";
+/** A value as it may be shown: a dot for each character, at most twelve, so its length is a hint and nothing more. */
+function dots(value) {
+	return "•".repeat(Math.min(value.length, 12));
+}
+/** A name, id or label as plain words: “cardNumber”, “card_number”, “cc-number” → “card number”, “cc number”. */
+function words$1(text) {
+	return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^\p{L}\p{N}]+/gu, " ").trim().toLowerCase();
+}
+/** Words that make a field secret, whatever else it is called. */
+var SECRET_WORDS = new RegExp("\\b(?:" + [
+	"pass(?:word|wd|code|phrase|key)s?",
+	"pwd",
+	"pw",
+	"secrets?",
+	"tokens?",
+	"api ?keys?",
+	"access ?keys?",
+	"secret ?keys?",
+	"private ?keys?",
+	"client ?secrets?",
+	"licen[cs]e ?keys?",
+	"product ?keys?",
+	"activation ?(?:keys?|codes?)",
+	"recovery ?(?:keys?|codes?)",
+	"backup ?codes?",
+	"auth(?:entication|orization)? ?codes?",
+	"otp",
+	"totp",
+	"one ?time ?(?:codes?|passwords?|passcodes?|pins?)",
+	"(?:verification|security|confirmation|sms|2fa|mfa) ?codes?",
+	"2fa",
+	"mfa",
+	"cvv2?",
+	"cvc2?",
+	"csc",
+	"card ?(?:numbers?|num|no|codes?|verification|holder|security|expiry|expiration|exp|cvc|cvv)",
+	"name ?on ?card",
+	"credit ?cards?",
+	"debit ?cards?",
+	"cc ?(?:number|num|no|exp|expiry|csc|cvc|cvv|name|given|family|type)",
+	"iban",
+	"account ?(?:numbers?|num|no)",
+	"routing ?(?:numbers?|num|no)",
+	"sort ?codes?",
+	"ssn",
+	"social ?security",
+	"tax ?id",
+	"national ?id",
+	"passports?",
+	"pins?(?: ?codes?)?",
+	"(?:recovery|seed|secret|backup|mnemonic) ?(?:phrases?|words?)",
+	"mnemonics?",
+	"(?:security|secret) ?(?:questions?|answers?)",
+	"memorable ?(?:words?|information|info)",
+	"mother s maiden name"
+].join("|") + ")\\b");
+/** The same in Arabic (password, secret code, verification code, card number, account number). */
+var SECRET_WORDS_AR = /كلمة (?:ال)?(?:مرور|سر)|(?:ال)?رمز (?:ال)?(?:سري|تحقق|التحقق|أمان|الأمان|المرور)|رقم (?:ال)?(?:بطاقة|حساب|سري)|آيبان/;
+/** Whether a field described so (its type, name, id, autocomplete, label and placeholder, in one text) holds a secret. */
+function isSecretHint(hint) {
+	return SECRET_WORDS.test(words$1(hint)) || SECRET_WORDS_AR.test(hint);
+}
+/** Words a field's label adds that don't tell one secret from another. */
+var FILLER = /* @__PURE__ */ new Set([
+	"enter",
+	"your",
+	"the",
+	"a",
+	"an",
+	"please",
+	"type",
+	"confirm",
+	"confirmation",
+	"repeat",
+	"again",
+	"re",
+	"retype",
+	"field",
+	"here",
+	"of",
+	"required",
+	"optional"
+]);
+/** A word before a secret that does tell it from another: a new password isn't the current one. */
+var QUALIFIER = /* @__PURE__ */ new Set([
+	"new",
+	"old",
+	"current",
+	"previous",
+	"admin",
+	"master",
+	"root"
+]);
+/**
+* What a secret is called in a test, from its field's label (or name): “Enter your password” → PASSWORD, “Card
+* number” → CARD_NUMBER, “New password” → NEW_PASSWORD, “Password (8 characters or more)” → PASSWORD; “Confirm
+* password” is PASSWORD too, so one value fills both.
+*/
+function secretName(label) {
+	const w = words$1(label);
+	const m = SECRET_WORDS.exec(w);
+	let name;
+	if (m) {
+		const before = w.slice(0, m.index).trim().split(" ").pop() ?? "";
+		name = [...QUALIFIER.has(before) ? [before] : [], ...m[0].split(" ")];
+	} else name = w.split(" ").filter((x) => x && !FILLER.has(x) && /^[a-z0-9]+$/.test(x)).slice(0, 3);
+	if (name.length) return name.join("_").toUpperCase().slice(0, 40);
+	if (/كلمة (?:ال)?(?:مرور|سر)/.test(label)) return "PASSWORD";
+	if (/تحقق|التحقق/.test(label)) return "VERIFICATION_CODE";
+	if (/بطاقة/.test(label)) return "CARD_NUMBER";
+	return "SECRET";
+}
+/** A secret's name as an environment variable can take it: capitals, digits and underscores. */
+function secretEnvName(name) {
+	return SECRET_ENV_PREFIX + (name.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "SECRET");
+}
+/** What may be a card number: digits with spaces or dashes between them (isCard decides). */
+var CARD = /\b\d(?:[ -]?\d){12,22}\b/g;
+/** Keys and tokens by their shape. */
+var TOKENS = [
+	/\beyJ[\w-]{6,}\.eyJ[\w-]{6,}\.[\w-]{6,}/g,
+	/\b(?:sk|rk)-[\w-]{16,}/g,
+	/\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}/g,
+	/\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+	/\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+	/\bglpat-[\w-]{16,}/g,
+	/\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+	/\bnpm_[A-Za-z0-9]{30,}/g,
+	/\bAKIA[0-9A-Z]{16}\b/g,
+	/\bAIza[0-9A-Za-z_-]{35}/g,
+	/\bwhsec_[A-Za-z0-9]{16,}/g,
+	/\bSG\.[\w-]{16,}\.[\w-]{16,}/g,
+	/(?<=\b(?:aws_?secret_?access_?key|secret_?access_?key|client_?secret|api_?secret|private_?key|access_?token|refresh_?token|auth_?token|password|passwd)["']?\s*[:=]\s*["']?)[^\s"',;}{]{8,}/gi,
+	/\b[a-z]{2,8}_(?:(?:live|test)_)?(?=[A-Za-z0-9]{20,}\b)(?=[A-Za-z0-9]*\d)(?=[A-Za-z0-9]*[a-z])(?=[A-Za-z0-9]*[A-Z])[A-Za-z0-9]{20,}\b/g,
+	/\bBearer\s+[A-Za-z0-9._~+/-]{12,}=*/g,
+	/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g
+];
+function luhn(digits) {
+	let sum = 0;
+	for (let i = 0; i < digits.length; i++) {
+		let d = Number(digits[digits.length - 1 - i]);
+		if (i % 2) d = d * 2 > 9 ? d * 2 - 9 : d * 2;
+		sum += d;
+	}
+	return sum % 10 === 0;
+}
+/**
+* Whether digits are written as a card number is: 13 to 19 of them, starting with 2 to 6 (as cards of every network
+* do), passing the Luhn check, and either unbroken or in groups of 4 to 6 (the last one shorter) with one kind of
+* separator. Not a date with a number either side of it, an order row or a timestamp.
+*/
+function isCard(text) {
+	const d = text.replace(/\D/g, "");
+	if (d.length < 13 || d.length > 19 || !/^[2-6]/.test(d) || !luhn(d)) return false;
+	if (/^\d+$/.test(text)) return true;
+	if (text.includes(" ") && text.includes("-")) return false;
+	const groups = text.split(/[ -]/);
+	return groups.every((g) => /^\d+$/.test(g)) && groups.slice(0, -1).every((g) => g.length >= 4 && g.length <= 6) && groups[groups.length - 1].length <= 6;
+}
+/** A card number in `run` (digits with spaces or dashes), with what follows it kept: the longest first part that is one. */
+function maskCard(run) {
+	const parts = run.split(/(?<=\d)(?=[ -])/);
+	for (let k = parts.length; k > 0; k--) {
+		const head = parts.slice(0, k).join("");
+		if (isCard(head)) return `•••• ${head.replace(/\D/g, "").slice(-4)}${parts.slice(k).join("")}`;
+	}
+	return run;
+}
+/** Text with every card number (kept: its last four digits) and every key- or token-shaped string in it masked. */
+function maskSecrets(text) {
+	if (!text) return text;
+	let out = text.replace(CARD, maskCard);
+	out = out.replace(/\b([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:)([^\s@/]+)@/gi, (_m, head) => `${head}${MASK}@`);
+	for (const re of TOKENS) out = out.replace(re, (m) => m.startsWith("Bearer") ? `Bearer ${MASK}` : MASK);
+	return out;
+}
+/**
+* Whether a typed value is a secret by its look alone: a card number, a key or a token, or a long random string (of
+* letters in both cases and digits, as keys are; or 32 hexadecimal digits or more). A slug, a sentence, an email
+* address or a coupon code is not.
+*/
+function looksSecret(value) {
+	const v = value.trim();
+	if (v.length < 12) return false;
+	if (maskSecrets(v) !== v) return true;
+	if (/^[a-f0-9]{32,}$/i.test(v) && /\d/.test(v) && /[a-f]/i.test(v)) return true;
+	return /^[A-Za-z0-9+/_=-]{24,}$/.test(v) && /\d/.test(v) && /[a-z]/.test(v) && /[A-Z]/.test(v);
+}
+/** Query and hash parameters whose value is a secret by their name alone. */
+var SECRET_PARAM = /^(?:access_?token|refresh_?token|id_?token|auth_?token|token|auth|authorization|api_?key|apikey|key|secret|client_?secret|password|passwd|pwd|pass|otp|code_?verifier|jwt|session|session_?id|sessionid|sid|signature|sig|x-amz-signature|x-amz-credential|x-amz-security-token|x-goog-signature|x-goog-credential)$/i;
+/** Addresses of sign-in steps, where `code`, `state` and `nonce` carry what lets someone in. */
+var AUTH_PATH = /(?:^|\/)(?:callback|oauth2?|auth|authorize|sso|login|signin|sign-in|verify|magic|reset|confirm)(?:[/?#.]|$)/i;
+function decoded(s) {
+	try {
+		return decodeURIComponent(s.replace(/\+/g, " "));
+	} catch {
+		return s;
+	}
+}
+/** `a=1&b=2` with the values of secret parameters masked, and key- or token-shaped values too. */
+function maskParams(params, authPath) {
+	return params.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		if (eq < 0) return maskSecrets(pair);
+		const name = decoded(pair.slice(0, eq));
+		const value = pair.slice(eq + 1);
+		if (!value) return pair;
+		const secret = SECRET_PARAM.test(name) || isSecretHint(name) || authPath && /^(?:code|state|nonce)$/i.test(name) || looksSecret(decoded(value));
+		return `${pair.slice(0, eq)}=${secret ? MASK : maskSecrets(value)}`;
+	}).join("&");
+}
+/**
+* An address with the secrets in it masked: the values of parameters named like a token, key, password or session
+* (in its query, and in its hash: `#access_token=…`), sign-in codes, and key- or token-shaped parts of its path.
+* Works on whole and relative addresses, and never throws.
+*/
+function redactUrl(url) {
+	if (!url) return url;
+	const hashAt = url.indexOf("#");
+	const base = hashAt < 0 ? url : url.slice(0, hashAt);
+	const hash = hashAt < 0 ? null : url.slice(hashAt + 1);
+	const q = base.indexOf("?");
+	const path = q < 0 ? base : base.slice(0, q);
+	const authPath = AUTH_PATH.test(path);
+	let out = maskSecrets(path).replace(/(?<=\/)[A-Za-z0-9_-]{24,}(?=\/|$)/g, (part) => /\d/.test(part) && /[a-z]/.test(part) && /[A-Z]/.test(part) ? MASK : part);
+	if (q >= 0) out += `?${maskParams(base.slice(q + 1), authPath)}`;
+	if (hash !== null) {
+		const hq = hash.indexOf("?");
+		if (hq >= 0) out += `#${maskSecrets(hash.slice(0, hq))}?${maskParams(hash.slice(hq + 1), authPath || AUTH_PATH.test(hash.slice(0, hq)))}`;
+		else out += `#${hash.includes("=") ? maskParams(hash, authPath) : maskSecrets(hash)}`;
+	}
+	return out;
+}
+/** A recorded element's words, masked: text it showed may hold a card number or a key. */
+function scrubTarget(el) {
+	if (!el || typeof el !== "object") return;
+	const t = el;
+	if (typeof t.label === "string") t.label = maskSecrets(t.label);
+	if (typeof t.text === "string") t.text = maskSecrets(t.text);
+	if (typeof t.description === "string") t.description = maskSecrets(t.description);
+}
+/**
+* A session event as it may be kept: addresses with their secrets masked (see redactUrl), card numbers and keys
+* masked in every text it carries (errors, console lines, response bodies, what the screen said), and a typed value
+* that is a secret (by its field's name, or its look) as dots. The bridge records events so; the studio scrubs
+* what arrives again, for events an older plugin recorded. Changes the event in place, and returns it.
+*/
+function scrubEvent(event) {
+	const e = event;
+	const url = (k) => {
+		if (typeof e[k] === "string") e[k] = redactUrl(e[k]);
+	};
+	const text = (k) => {
+		if (typeof e[k] === "string") e[k] = maskSecrets(e[k]);
+	};
+	scrubTarget(e.el);
+	switch (e.type) {
+		case "page":
+			url("url");
+			url("referrer");
+			break;
+		case "nav":
+			url("url");
+			break;
+		case "net":
+			url("url");
+			text("body");
+			text("error");
+			break;
+		case "error":
+		case "console":
+			text("message");
+			text("text");
+			text("stack");
+			break;
+		case "dom":
+			url("url");
+			text("text");
+			if (Array.isArray(e.headings)) e.headings = e.headings.map((h) => typeof h === "string" ? maskSecrets(h) : h);
+			break;
+		case "input": {
+			const target = e.el ?? {};
+			const value = typeof e.value === "string" ? e.value : "";
+			if (!e.masked && (isSecretHint(`${target.label ?? ""} ${target.name ?? ""}`) || looksSecret(value))) {
+				e.value = dots(value);
+				e.masked = true;
+				e.secret ??= secretName(target.label || target.name || "");
+			} else if (!e.masked) text("value");
+			break;
+		}
+		case "change":
+			text("value");
+			if (Array.isArray(e.options)) e.options = e.options.map((o) => typeof o === "string" ? maskSecrets(o) : o);
+	}
+	return event;
+}
 /** Where the studio runs unless told otherwise. Not 5173: that is Vite's own default, where your app likely runs. */
 var STUDIO_PORT = 7357;
+/**
+* Through the studio's proxy, a page's XMLHttpRequest to another port of this computer says with this header that it
+* was sent with its credentials (withCredentials, set after open): the proxy then sends the site's cookies with it.
+*/
+var PROXY_CREDENTIALS_HEADER = "x-saywright-credentials";
 var STUDIO_URL = `http://localhost:${STUDIO_PORT}`;
 var JS_ESCAPES = {
 	"\\": "\\\\",
@@ -600,6 +915,31 @@ function safeDirs(dir) {
 		return [];
 	}
 }
+/** Where `connect` adds the studio's script tag (and where a person would): a root layout, a document, the page. */
+var SCRIPT_FILES = [
+	"src/app/layout.tsx",
+	"app/layout.tsx",
+	"src/app/layout.jsx",
+	"app/layout.jsx",
+	"src/app/layout.js",
+	"app/layout.js",
+	"src/pages/_document.tsx",
+	"pages/_document.tsx",
+	"src/pages/_document.jsx",
+	"pages/_document.jsx",
+	"src/pages/_document.js",
+	"pages/_document.js",
+	"public/index.html",
+	"index.html",
+	"src/index.html"
+];
+/** Whether the app's own pages load the studio's script (connected with its script tag): no proxy needed. */
+function hasScriptTag(dir) {
+	for (const rel of SCRIPT_FILES) try {
+		if (BRIDGE_SCRIPT.test(fs.readFileSync(path.join(dir, rel), "utf8").slice(0, 2e5))) return true;
+	} catch {}
+	return false;
+}
 /** Whether a Vite config already loads the studio's plugin. */
 function hasPlugin(dir) {
 	const config = first(dir, ...VITE_CONFIGS);
@@ -626,6 +966,7 @@ function probeFolder(input) {
 	const notes = [];
 	const { start, port, guessed } = devCommandOf(root, pkg, runs, framework);
 	const plugin = hasPlugin(root);
+	const script = !plugin && hasScriptTag(root);
 	const canAddPlugin = VITE_BASED.has(framework) && !plugin && !!declaredDeps(root).react;
 	const candidates = pkg ? workspaceApps(root, pkg) : void 0;
 	if (!pkg && framework === "static") notes.push("No package.json: the studio serves this folder as a static site.");
@@ -633,6 +974,7 @@ function probeFolder(input) {
 	if (pkg && !start && framework !== "static") notes.push("No dev, start or serve script: start the app yourself and give its address.");
 	if (candidates?.length && !start) notes.push(`A monorepo with ${candidates.length} app${candidates.length === 1 ? "" : "s"}: pick one.`);
 	if (canAddPlugin) notes.push("A Vite + React app: adding the Saywright plugin maps every element to its exact line of code.");
+	else if (script) notes.push("Its pages load the studio’s script: shown as it is, without the proxy.");
 	else if (!plugin && pkg) notes.push("Shown through the studio’s proxy: no change to your code needed.");
 	if (start && pmNote) notes.push(pmNote);
 	if (start && guessed) notes.push(portNote(guessed, framework, port));
@@ -648,7 +990,7 @@ function probeFolder(input) {
 		needsInstall,
 		plugin,
 		canAddPlugin,
-		connection: plugin ? "plugin" : "proxy",
+		connection: plugin ? "plugin" : script ? "script" : "proxy",
 		repo: fs.existsSync(path.join(root, ".git")) ? gitRemote(root) : void 0,
 		notes,
 		candidates: candidates?.length ? candidates : void 0
@@ -969,6 +1311,22 @@ ${c.bold("saywright connect")} <app folder> [options]: connect an app to the stu
   --studio <address>     where the studio runs, if not on ${STUDIO_URL} (the script tag loads from it)
   --dry-run              show what would change, change nothing
 `;
+/** Where the studio that runs now listens, as it wrote when it started: null when none runs. */
+function runningStudio(dataDir) {
+	let saved;
+	try {
+		saved = JSON.parse(fs.readFileSync(path.join(dataDir, "server.json"), "utf8"));
+	} catch {
+		return null;
+	}
+	if (typeof saved.url !== "string" || !/^https?:\/\//.test(saved.url) || typeof saved.pid !== "number") return null;
+	try {
+		process.kill(saved.pid, 0);
+	} catch (err) {
+		if (err.code !== "EPERM") return null;
+	}
+	return saved.url;
+}
 async function connect(argv, ctx) {
 	const noStart = argv.includes("--no-start");
 	const { values, positionals } = parseArgs({
@@ -991,7 +1349,7 @@ async function connect(argv, ctx) {
 		return values.help ? 0 : 1;
 	}
 	const dry = !!values["dry-run"];
-	const studio = (values.studio ?? STUDIO_URL).replace(/\/+$/, "");
+	const studio = (values.studio ?? runningStudio(ctx.layout.dataDir) ?? STUDIO_URL).replace(/\/+$/, "");
 	const scriptUrl = `${studio}/saywright.js`;
 	const root = path.resolve(positionals[0]);
 	const pkg = readPkg(root);
@@ -1224,15 +1582,11 @@ async function extractTarBz2(archive, dest) {
 /**
 * Models the studio's page runs itself, downloaded once into the data folder and served at /models/:
 *
-*   hand_landmarker.task      MediaPipe's hand model (7.8 MB), for hand control (Settings → Labs). Without it the
-*                             page loads the same file from Google's servers.
 *   moonshine/tiny/*.onnx     Moonshine tiny (English, MIT, 28 MB): voice commands understood in the browser,
 *                             without the browser's own recogniser. Without it, that recogniser alone.
 */
-var HAND_MODEL_URL = "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task";
 var MOONSHINE_TGZ = "https://registry.npmjs.org/@moonshine-ai/moonshine-js/-/moonshine-js-0.1.29.tgz";
 var MOONSHINE_SHA256 = "864e17a00ed494857c71693e835306fa038e0f82002c76e3056d67d574e1c2d8";
-var HAND_MODEL_SHA256 = "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1";
 var MOONSHINE_FILES = {
 	"package/dist/model/tiny/quantized/encoder_model.onnx": {
 		name: "encoder_model.onnx",
@@ -1244,40 +1598,10 @@ var MOONSHINE_FILES = {
 	}
 };
 var modelsDir = (dataDir) => path.join(dataDir, "models");
-var handModelFile = (dataDir) => path.join(modelsDir(dataDir), "hand_landmarker.task");
 var moonshineDir = (dataDir) => path.join(modelsDir(dataDir), "moonshine", "tiny");
-/** A .task file is a zip archive of TFLite models: check its size and the zip signature. */
-function isHandModel(file) {
-	try {
-		if (fs.statSync(file).size < 1e6) return false;
-		const head = Buffer.alloc(16);
-		const fd = fs.openSync(file, "r");
-		fs.readSync(fd, head, 0, 16, 0);
-		fs.closeSync(fd);
-		return head.includes(Buffer.from([
-			80,
-			75,
-			3,
-			4
-		]));
-	} catch {
-		return false;
-	}
-}
 function browserSpeechReady(dataDir) {
 	return Object.values(MOONSHINE_FILES).every((f) => fs.statSync(path.join(moonshineDir(dataDir), f.name), { throwIfNoEntry: false })?.size === f.size);
 }
-async function ensureHandModel(dataDir) {
-	const file = handModelFile(dataDir);
-	if (isHandModel(file)) return;
-	const tmp = `${file}.download`;
-	await download(HAND_MODEL_URL, tmp, void 0, HAND_MODEL_SHA256);
-	if (!isHandModel(tmp)) {
-		fs.rmSync(tmp, { force: true });
-		throw new Error("The hand model download was incomplete.");
-	}
-	fs.renameSync(tmp, file);
-}
 /** Pull the wanted files out of a .tar (ustar, regular files only). */
 function untar(buf, wanted) {
 	const out = {};
@@ -1954,7 +2278,6 @@ async function doctor(argv, ctx) {
 	if (ctx.clientDir && !fs.existsSync(path.join(ctx.clientDir, "index.html"))) bad("The studio’s interface isn’t built", "Reinstall Saywright (npx @saywright/studio@latest).");
 	if (browserSpeechReady(layout.dataDir)) ok("On-device voice model");
 	else warn("On-device voice model not downloaded: voice uses the browser’s recogniser alone", `Run ${ctx.clientDir ? "npx @saywright/studio setup" : "npm run setup"} to download it once (28 MB).`);
-	if (isHandModel(handModelFile(layout.dataDir))) ok("Hand model (for hand control, in Settings → Labs)");
 	const speech = new SpeechService(speechDir(layout), layout.speechWorker, () => void 0).status();
 	if (speech.runtime === "missing") warn("The speech engine can’t run on this computer", "Narration is still recorded; voice uses the browser’s recogniser.");
 	else {
@@ -2625,7 +2948,6 @@ function runQuiet(command, args, timeoutMs = 6e3, env) {
 *
 *   On-device voice model (28 MB)          voice commands understood without the browser's recogniser
 *   Speech models, Arabic and English      narration of test sessions transcribed on this computer, Arabic voice
-*   Hand model (7.8 MB, --hand)            hand control (Settings → Labs) without loading it from Google
 *   Test browser (in the repository)       running generated tests against the sample app
 */
 var HELP$2 = `
@@ -2634,7 +2956,6 @@ ${c.bold("saywright setup")} [options]: download the optional extras
   --no-speech           skip the speech models (Arabic and English, about 740 MB)
   --best-arabic         add the most accurate Arabic model without asking (1.6 GB more)
   --no-best-arabic      don't add it, don't ask
-  --hand                add the hand model, for hand control (Settings → Labs)
 `;
 /** One line that redraws itself, in a terminal; `done` clears it. */
 function progress(label) {
@@ -2686,7 +3007,7 @@ async function setup(argv, ctx) {
 	console.log(c.bold("\nSaywright setup\n"));
 	if (!browserSpeechReady(dataDir)) console.log(c.dim("… On-device voice model (28 MB)"));
 	await attempt("On-device voice model", () => ensureBrowserSpeech(dataDir), "Voice uses the browser’s recogniser alone until it is there.");
-	if (values.hand) await attempt("Hand model", () => ensureHandModel(dataDir), "Hand control loads it from Google’s servers instead.");
+	if (values.hand) console.log(c.dim("Hand control was removed in 0.2.0: there is no hand model to download."));
 	if (values.speech) {
 		const speech = new SpeechService(speechDir(ctx.layout), ctx.layout.speechWorker, () => void 0);
 		const status = speech.status();
@@ -3236,7 +3557,7 @@ async function readIgnore(root, dir) {
 		if (dirOnly) line = line.slice(0, -1);
 		const anchored = line.includes("/");
 		line = line.replace(/^\//, "");
-		const base = dir ? `${escapeRe(dir)}/` : "";
+		const base = dir ? `${escapeRe$1(dir)}/` : "";
 		rules.push({
 			re: new RegExp(`^${base}${anchored ? "" : "(?:.*/)?"}${globToRe(line)}$`),
 			negate,
@@ -3250,7 +3571,7 @@ function ignored(rules, rel, isDir) {
 	for (const r of rules) if ((!r.dirOnly || isDir) && r.re.test(rel)) out = !r.negate;
 	return out;
 }
-var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var escapeRe$1 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function globToRe(glob) {
 	let re = "";
 	for (let i = 0; i < glob.length; i++) {
@@ -3268,8 +3589,8 @@ function globToRe(glob) {
 				re += `[${glob.slice(i + 1, end).replace(/^!/, "^").replace(/\\/g, "\\\\")}]`;
 				i = end;
 			}
-		} else if (c === "\\" && i + 1 < glob.length) re += escapeRe(glob[++i]);
-		else re += escapeRe(c);
+		} else if (c === "\\" && i + 1 < glob.length) re += escapeRe$1(glob[++i]);
+		else re += escapeRe$1(c);
 	}
 	return re;
 }
@@ -15124,6 +15445,12 @@ var IGNORED_DIRS$1 = /* @__PURE__ */ new Set([
 	".turbo",
 	".vercel"
 ]);
+/** Refuses a path (relative to the project or its workspace) in a folder that isn't the app's code, or an environment file. */
+function offLimits(relative, asked) {
+	const parts = relative.split(path.sep);
+	if (IGNORED_DIRS$1.has(parts[0]) || parts.some((p) => p === "node_modules" || p === ".git")) throw new HttpError(400, `Path is not editable: ${asked}`);
+	if (parts.some((p) => p.startsWith(".env"))) throw new HttpError(400, "Environment files are off limits");
+}
 var TEXT_EXT = /\.([cm]?[jt]sx?|css|scss|sass|less|styl|json|md|mdx|html?|svg|vue|svelte|astro|php|erb|ejs|hbs|handlebars|mustache|njk|liquid|twig|jinja2?|j2|cshtml|razor|py|rb|go|ya?ml|toml|xml|txt)$/i;
 /** Folders never searched: dependencies, builds, tools' caches and other dot folders (as listFiles walks them). */
 var unsearched = (name) => IGNORED_DIRS$1.has(name) || name.startsWith(".") && name !== ".storybook";
@@ -15233,18 +15560,19 @@ var Project = class {
 		const abs = path.resolve(this.root, clean);
 		const relative = this.inside(abs);
 		if (!relative) throw new HttpError(400, `Path is outside the project: ${rel}`);
-		const first = relative.split(path.sep)[0];
-		if (IGNORED_DIRS$1.has(first) || relative.split(path.sep).some((p) => p === "node_modules" || p === ".git")) throw new HttpError(400, `Path is not editable: ${rel}`);
-		if (/(^|\/)\.env/.test(clean)) throw new HttpError(400, "Environment files are off limits");
-		if (!this.contains(abs)) throw new HttpError(400, `Path is outside the project: ${rel}`);
+		offLimits(relative, rel);
+		const real = this.realTarget(abs);
+		if (!real) throw new HttpError(400, `Path is outside the project: ${rel}`);
+		offLimits(real, rel);
 		return abs;
 	}
 	realRoot = null;
 	/**
-	* Whether a path stays inside the project with every link along it followed. A file that doesn't exist yet is
-	* judged by the folder it would be written in; a link that leads nowhere is refused (writing would create its target).
+	* Where a path leads with every link along it followed, relative to the project (or its workspace); null when that
+	* is outside both. A file that doesn't exist yet is judged by the folder it would be written in; a link that leads
+	* nowhere is refused (writing would create its target).
 	*/
-	contains(abs) {
+	realTarget(abs) {
 		this.realRoot ??= fs.realpathSync(this.root);
 		let probe = abs;
 		const rest = [];
@@ -15253,7 +15581,7 @@ var Project = class {
 			break;
 		} catch {
 			const parent = path.dirname(probe);
-			if (parent === probe) return false;
+			if (parent === probe) return null;
 			rest.unshift(path.basename(probe));
 			probe = parent;
 		}
@@ -15261,13 +15589,14 @@ var Project = class {
 		try {
 			real = fs.realpathSync(probe);
 		} catch {
-			return false;
+			return null;
 		}
 		const target = path.join(real, ...rest);
-		return [this.realRoot, this.workspace && fs.realpathSync(this.workspace)].some((root) => {
+		for (const root of [this.realRoot, this.workspace && fs.realpathSync(this.workspace)]) {
 			const relative = root ? path.relative(root, target) : "";
-			return !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
-		});
+			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) return relative;
+		}
+		return null;
 	}
 	rel(abs) {
 		return path.relative(this.root, abs).split(path.sep).join("/");
@@ -15286,12 +15615,17 @@ var Project = class {
 	}
 	/** Atomic write: temp file + rename, so the dev server never sees half a file. */
 	write(rel, content) {
-		const abs = this.resolve(rel);
+		const asked = this.resolve(rel);
+		let abs = asked;
+		try {
+			if (fs.lstatSync(asked).isSymbolicLink()) abs = fs.realpathSync(asked);
+		} catch {}
 		fs.mkdirSync(path.dirname(abs), { recursive: true });
 		const tmp = `${abs}.saywright-tmp`;
 		fs.writeFileSync(tmp, content);
 		fs.renameSync(tmp, abs);
-		this.index?.forget(this.rel(abs));
+		this.index?.forget(this.rel(asked));
+		if (abs !== asked) this.index?.forget(this.rel(abs));
 	}
 	remove(rel) {
 		const abs = this.resolve(rel);
@@ -16134,21 +16468,100 @@ function upstreamUrl(raw, upstream) {
 	return url.origin === upstream.origin ? url : null;
 }
 /** This computer's own names. */
-var LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\])$/;
-/** The proxy's path for another port of this computer: /__saywright/<http|https>/<host>:<port><path>. */
-var VIA = /^\/__saywright\/(https?)\/(localhost|127\.0\.0\.1|\[::1\]):(\d{1,5})(\/.*)?$/s;
+var LOOPBACK$1 = /^(localhost|127\.0\.0\.1|\[::1\])$/;
+/**
+* The proxy's path for another port of this computer: /__saywright/<http|https>[+cred]/<host>:<port><path>. `+cred`:
+* the page sent the request with its credentials (fetch's credentials: 'include', an event stream's withCredentials).
+*/
+var VIA = /^\/__saywright\/(https?)(\+cred)?\/(localhost|127\.0\.0\.1|\[::1\]):(\d{1,5})(\/.*)?$/s;
 /**
 * The address on this computer that a request to the proxy's path for another port stands for (the site's API), or
 * null: for a site on this computer only, on this computer's own names only, and never one of `refused` (the proxy's
 * own ports, the studio's).
 */
 function viaUrl(raw, upstream, refused) {
+	return viaRequest(raw, upstream, refused)?.url ?? null;
+}
+/** The same, and whether the page sent it with its credentials (see VIA). */
+function viaRequest(raw, upstream, refused) {
 	const m = VIA.exec(raw ?? "");
-	if (!m || !LOOPBACK.test(upstream.hostname)) return null;
-	const port = Number(m[3]);
-	const rest = m[4] ?? "/";
+	if (!m || !LOOPBACK$1.test(upstream.hostname)) return null;
+	const port = Number(m[4]);
+	const rest = m[5] ?? "/";
 	if (!port || port > 65535 || refused.has(port) || rest.startsWith("//") || rest.startsWith("/\\")) return null;
-	return new URL(`${m[1]}://${m[2]}:${port}${rest}`);
+	return {
+		url: new URL(`${m[1]}://${m[3]}:${port}${rest}`),
+		credentials: !!m[2]
+	};
+}
+/** Request headers the browser sets itself, or a page may not: none of them asks the API's leave first. */
+var BROWSER_SET = /* @__PURE__ */ new Set([
+	"accept-charset",
+	"accept-encoding",
+	"access-control-request-headers",
+	"access-control-request-method",
+	"connection",
+	"content-length",
+	"cookie",
+	"cookie2",
+	"date",
+	"dnt",
+	"expect",
+	"host",
+	"keep-alive",
+	"origin",
+	"referer",
+	"set-cookie",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"via",
+	"user-agent",
+	"priority",
+	"pragma",
+	"cache-control",
+	PROXY_CREDENTIALS_HEADER
+]);
+var SIMPLE_TYPE = /^(?:application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\s*(?:;|$)/i;
+/**
+* What a request the page made to another origin must have its API allow before it is sent (the browser's
+* preflight), as the browser decides: a method other than GET, HEAD or POST, or a header of the page's own beyond
+* the few any page may send. Null: a simple request, sent as it is.
+*/
+function preflightFor(method, headers) {
+	const own = Object.keys(headers).filter((h) => !BROWSER_SET.has(h) && !h.startsWith("sec-") && !h.startsWith("proxy-")).filter((h) => ![
+		"accept",
+		"accept-language",
+		"content-language",
+		"content-type"
+	].includes(h) || h === "content-type" && !SIMPLE_TYPE.test(String(headers[h]))).sort();
+	return [
+		"GET",
+		"HEAD",
+		"POST"
+	].includes(method) && !own.length ? null : {
+		method,
+		headers: own
+	};
+}
+/** Whether an API's answer may be read by a page of `origin`, by its CORS headers, as the browser decides. */
+function corsAllows(headers, origin, credentials) {
+	const allow = headers["access-control-allow-origin"];
+	if (allow === origin) return !credentials || headers["access-control-allow-credentials"] === "true";
+	return allow === "*" && !credentials;
+}
+/** Whether an API's answer to a preflight lets the request through. */
+function preflightAllows(status, headers, want, origin, credentials) {
+	if (status < 200 || status > 299 || !corsAllows(headers, origin, credentials)) return false;
+	const list = (h) => String(h ?? "").split(",").map((x) => x.trim().toLowerCase()).filter(Boolean);
+	const methods = list(headers["access-control-allow-methods"]);
+	const allowed = list(headers["access-control-allow-headers"]);
+	return ([
+		"GET",
+		"HEAD",
+		"POST"
+	].includes(want.method) || methods.includes(want.method.toLowerCase()) || !credentials && methods.includes("*")) && want.headers.every((h) => allowed.includes(h) || !credentials && allowed.includes("*") && h !== "authorization");
 }
 /**
 * Whether the page the proxy shows made the request: the browser says so (Sec-Fetch-Site, and Origin when it sends
@@ -16328,39 +16741,87 @@ var AppProxy = class {
 	* fails rather than getting an error page.
 	*/
 	via(target, req, res, proxyOrigin) {
-		const url = viaUrl(req.url, target.upstream, this.refused());
-		if (!url || !fromPage(req.headers, proxyOrigin)) {
+		const found = viaRequest(req.url, target.upstream, this.refused());
+		if (!found || !fromPage(req.headers, proxyOrigin)) {
 			res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
 			res.end("This proxy passes requests on to another port of this computer for the page it shows, and only for it.");
 			return;
 		}
+		const { url } = found;
+		const credentials = found.credentials || req.headers["x-saywright-credentials"] === "include";
+		const origin = target.upstream.origin;
 		const headers = this.requestHeaders(req, target, proxyOrigin);
 		headers.host = url.host;
+		delete headers[PROXY_CREDENTIALS_HEADER];
+		headers.origin = origin;
+		headers["sec-fetch-site"] = "same-site";
+		if (!credentials) delete headers.cookie;
 		if (req.headers["accept-encoding"]) headers["accept-encoding"] = req.headers["accept-encoding"];
 		else delete headers["accept-encoding"];
 		const secure = url.protocol === "https:";
-		const upstreamReq = (secure ? https : http).request(url, {
-			method: req.method,
-			headers,
+		const lib = secure ? https : http;
+		const tlsOptions = secure ? {
+			rejectUnauthorized: false,
+			servername: url.hostname === "localhost" ? "localhost" : void 0
+		} : {};
+		const blocked = (why) => {
+			if (res.headersSent) return void res.destroy();
+			res.writeHead(403, {
+				"Content-Type": "text/plain; charset=utf-8",
+				"X-Saywright-Blocked": "cors"
+			});
+			res.end(`Blocked as the browser blocks it outside the studio: ${why}`);
+		};
+		const opaque = req.headers["sec-fetch-mode"] === "no-cors";
+		const send = () => {
+			const upstreamReq = lib.request(url, {
+				method: req.method,
+				headers,
+				timeout: 3e4,
+				...tlsOptions
+			}, (up) => {
+				if (!opaque && !corsAllows(up.headers, origin, credentials)) {
+					up.resume();
+					return blocked(`${url.host} doesn’t let pages of ${origin} read what it answers${credentials ? " with their cookies" : ""} (CORS).`);
+				}
+				const out = {};
+				for (const [k, v] of Object.entries(up.headers)) {
+					if (v === void 0 || HOP.has(k) || DROP_RESPONSE.has(k)) continue;
+					if (k === "set-cookie") out[k] = (Array.isArray(v) ? v : [v]).map((c) => rewriteSetCookie(c, target.port, viaPrefix(url)));
+					else if (k === "location") out[k] = this.viaLocation(String(v), url, target, proxyOrigin);
+					else out[k] = v;
+				}
+				res.writeHead(up.statusCode ?? 502, out);
+				up.pipe(res);
+			});
+			upstreamReq.on("timeout", () => upstreamReq.destroy(/* @__PURE__ */ new Error("timed out")));
+			upstreamReq.on("error", () => res.destroy());
+			req.pipe(upstreamReq);
+		};
+		const want = opaque ? null : preflightFor(req.method ?? "GET", req.headers);
+		if (!want) return send();
+		const ask = {
+			host: url.host,
+			origin,
+			"access-control-request-method": want.method,
+			"sec-fetch-mode": "cors",
+			"sec-fetch-site": "same-site"
+		};
+		if (want.headers.length) ask["access-control-request-headers"] = want.headers.join(",");
+		if (req.headers["user-agent"]) ask["user-agent"] = req.headers["user-agent"];
+		const pre = lib.request(url, {
+			method: "OPTIONS",
+			headers: ask,
 			timeout: 3e4,
-			...secure ? {
-				rejectUnauthorized: false,
-				servername: url.hostname === "localhost" ? "localhost" : void 0
-			} : {}
+			...tlsOptions
 		}, (up) => {
-			const out = {};
-			for (const [k, v] of Object.entries(up.headers)) {
-				if (v === void 0 || HOP.has(k) || DROP_RESPONSE.has(k)) continue;
-				if (k === "set-cookie") out[k] = (Array.isArray(v) ? v : [v]).map((c) => rewriteSetCookie(c, target.port, viaPrefix(url)));
-				else if (k === "location") out[k] = this.viaLocation(String(v), url, target, proxyOrigin);
-				else out[k] = v;
-			}
-			res.writeHead(up.statusCode ?? 502, out);
-			up.pipe(res);
+			up.resume();
+			if (preflightAllows(up.statusCode ?? 0, up.headers, want, origin, credentials)) send();
+			else blocked(`${url.host} doesn’t allow a ${want.method} request${want.headers.length ? ` with ${want.headers.join(", ")}` : ""} from ${origin} (CORS).`);
 		});
-		upstreamReq.on("timeout", () => upstreamReq.destroy(/* @__PURE__ */ new Error("timed out")));
-		upstreamReq.on("error", () => res.destroy());
-		req.pipe(upstreamReq);
+		pre.on("timeout", () => pre.destroy(/* @__PURE__ */ new Error("timed out")));
+		pre.on("error", () => res.destroy());
+		pre.end();
 	}
 	/** A redirect from the API: to itself, it stays on its path in the proxy; to the site, in the proxy; elsewhere, as sent. */
 	viaLocation(location, api, target, proxyOrigin) {
@@ -16690,7 +17151,8 @@ var AppManager = class {
 		let connection = latest.connection;
 		if (env.kind === "local") {
 			if (await pluginAnswers(url, app.root && hasPlugin(app.root) ? 2e4 : 5e3)) connection = "plugin";
-			else if (connection === "plugin") connection = "proxy";
+			else if (app.root && hasScriptTag(app.root)) connection = "script";
+			else if (connection === "plugin" || connection === "script" && app.root) connection = "proxy";
 			if (connection !== latest.connection) this.registry.setEnv(app.id, {
 				...latest,
 				connection
@@ -16723,6 +17185,27 @@ var AppManager = class {
 		this.spaces.set(app.id, ws);
 		return ws;
 	}
+	/**
+	* Apps whose newest session was still recording when the studio stopped: their workspace is set up now (without
+	* opening the app), so the page recording it finds the studio again and the recording goes on.
+	*/
+	restoreRecordings() {
+		for (const app of this.registry.list()) {
+			if (this.spaces.has(app.id)) continue;
+			const state = app.root ? path.join(app.root, ".saywright") : path.join(this.deps.dataDir, "apps", app.id);
+			if (!recordingIn(path.join(state, "sessions"))) continue;
+			const env = app.envs.find((e) => e.id === app.env) ?? app.envs[0];
+			const dataDir = appStateDir(this.deps.dataDir, app);
+			const project = new Project(app.root ?? dataDir, env.url, dataDir, !!app.root);
+			this.spaces.set(app.id, {
+				app,
+				env,
+				project,
+				frameUrl: env.url,
+				...this.deps.build(project)
+			});
+		}
+	}
 	/** Tell the open app's plugin where the studio is (once the studio knows its own address). */
 	announceActive() {
 		const ws = this.active();
@@ -16783,6 +17266,16 @@ var AppManager = class {
 		this.proxy.close();
 	}
 };
+/** Whether the newest session in a sessions folder was still recording (only one records at a time, the newest). */
+function recordingIn(dir) {
+	try {
+		const newest = fs.readdirSync(dir).filter((n) => /^\d{8}-\d{6}-[a-z0-9]{4}$/.test(n)).sort().pop();
+		if (!newest) return false;
+		return JSON.parse(fs.readFileSync(path.join(dir, newest, "session.json"), "utf8")).status === "recording";
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region server/apps/github.ts
 /**
@@ -17218,6 +17711,16 @@ var FakeProvider = class {
 				}])
 			};
 		}
+		if (input.mode === "fix" && input.test && /\b(?:change|edit) the test\b/i.test(input.text)) return {
+			kind: "change",
+			title: "Loosens the check",
+			summary: "The test now accepts any amount.",
+			edits: applyEditSpecs(ctx.project, [{
+				path: input.test.path,
+				old_string: "toContainText('$80.80')",
+				new_string: "toContainText('$')"
+			}])
+		};
 		if (input.mode === "fix" || /\bfix\b/.test(t)) {
 			ctx.progress("Reading", "src/lib/pricing.ts");
 			await sleep$1(150);
@@ -23505,11 +24008,11 @@ function numbered(lines, start, end) {
 function userMessage(input, project) {
 	const parts = [];
 	parts.push(`Said: "${input.text.trim()}"`);
-	if (input.pageUrl) parts.push(`Page: ${input.pageUrl}`);
+	if (input.pageUrl) parts.push(`Page: ${redactUrl(input.pageUrl)}`);
 	if (input.refs.length) {
 		parts.push("\nReferenced elements:");
 		input.refs.forEach((r, i) => {
-			const text = r.text ? ` showing “${r.text.slice(0, 60)}”` : "";
+			const text = r.text ? ` showing “${maskSecrets(r.text).slice(0, 60)}”` : "";
 			parts.push(`${i + 1}. ${r.role} → ${r.name}${text}${r.src ? ` at ${r.src}${r.guessed ? " (a guess, found by searching the code for its text)" : ""}` : " (not mapped to source)"}`);
 		});
 	} else parts.push("\nThe user did not point at anything; work out the target from their words.");
@@ -42363,11 +42866,25 @@ var UsageLedger = class {
 			message: null
 		};
 	}
-	/** Whether a call may go ahead. In "stop" mode, not once a limit is reached. */
-	allow(now = Date.now()) {
-		const status = this.status(now);
+	/**
+	* Whether a call may go ahead. In "stop" mode, not once a limit is reached, nor when the call itself (`extraUsd`,
+	* `extraTokens`: what it is expected to cost) would go past one.
+	*/
+	allow(now = Date.now(), extraUsd = 0, extraTokens = 0) {
+		const status = this.status(now, extraUsd, extraTokens);
+		const stop = status.level === "over" && this.state.budget.mode === "stop";
+		if (stop && (extraUsd > 0 || extraTokens > 0) && this.status(now).level !== "over") {
+			const more = extraUsd > 0 ? `about ${money(extraUsd)} more` : `about ${compact(extraTokens)} more tokens`;
+			return {
+				ok: false,
+				status: {
+					...status,
+					message: `${(status.message ?? "Near your budget.").replace(/\.$/, "")}, and this would take ${more}.`
+				}
+			};
+		}
 		return {
-			ok: !(status.level === "over" && this.state.budget.mode === "stop"),
+			ok: !stop,
 			status
 		};
 	}
@@ -42457,9 +42974,9 @@ var AiService = class {
 	get effort() {
 		return this.connections.config.effort;
 	}
-	/** Throws when the budget says stop. */
-	gate() {
-		const { ok, status } = this.usage.allow();
+	/** Throws when the budget says stop (with `call`, what the call about to be made is expected to cost, counted in). */
+	gate(call) {
+		const { ok, status } = this.usage.allow(Date.now(), call?.usd ?? 0, call?.tokens ?? 0);
 		if (!ok) throw new AgentError(`${status.message ?? "The AI budget is used up."} Raise the limit or reset the count in Settings → AI to carry on.`, "budget");
 	}
 	record(c, model, u, feature, ms, reportedUsd) {
@@ -42549,10 +43066,22 @@ var AiService = class {
 		const chat = this.connections.chatModel(c.id, r.model);
 		if (!chat) throw new AgentError(`${c.label} can’t be used right now.`, "other");
 		const parts = chat.vision ? req.parts : req.parts.filter((p) => p.type === "text");
+		const input = Math.ceil((req.system.length + parts.reduce((n, p) => n + (p.type === "text" ? p.text.length : 0), 0)) / 4) + parts.filter((p) => p.type === "image").length * 1600;
+		const output = Math.min(req.maxTokens, 4e3);
+		const price = (c.models.find((m) => m.id === r.model) ?? modelInfo(c.kind, r.model))?.price;
+		const call = {
+			usd: costOf(price, {
+				input,
+				output,
+				cacheRead: 0,
+				cacheWrite: 0
+			}) ?? 0,
+			tokens: input + output
+		};
 		return jsonFrom(chat, {
 			...req,
 			parts
-		}, () => this.gate(), (res, ms) => this.record(c, r.model, res.usage, req.feature, ms, res.usd));
+		}, () => this.gate(call), (res, ms) => this.record(c, r.model, res.usage, req.feature, ms, res.usd));
 	}
 	/** A tiny real call, to check a connection works (a few tokens). */
 	async test(connectionId) {
@@ -44333,6 +44862,7 @@ function editorRoute(project) {
 }
 //#endregion
 //#region shared/autopilot.ts
+/** Autopilot's steps, as the studio and its server both describe them (see server/autopilot.ts). */
 var STEP_KINDS = [
 	"click",
 	"fill",
@@ -44370,7 +44900,10 @@ function describeStep(action, control) {
 	const name = control ? `“${control.name || control.role}”` : "";
 	switch (action.kind) {
 		case "click": return `Clicked ${name}`;
-		case "fill": return `Typed “${action.value ?? ""}” into ${name}`;
+		case "fill": {
+			const value = action.value ?? "";
+			return `Typed ${!!control?.field?.secret || isSecretHint(control?.name ?? "") || looksSecret(value) ? MASK : `“${maskSecrets(value)}”`} into ${name}`;
+		}
 		case "select": return `Chose “${action.value ?? ""}” in ${name}`;
 		case "check": return `${action.value === "off" ? "Unticked" : "Ticked"} ${name}`;
 		case "press": return control ? `Pressed ${action.value || "Enter"} in ${name}` : `Pressed ${action.value || "Enter"}`;
@@ -46330,6 +46863,56 @@ function findElement(code, loc, parsed) {
 	});
 	return found;
 }
+/** An element's own words as written: its text children, collapsed; empty when they are code (`{t('save')}`) or none. */
+function staticText(el) {
+	let out = "";
+	for (const c of el.children ?? []) if (c.type === "JSXText") out += ` ${c.value}`;
+	else if (c.type === "JSXExpressionContainer" && c.expression?.type === "StringLiteral") out += ` ${c.expression.value}`;
+	else if (c.type === "JSXExpressionContainer" && c.expression?.type !== "JSXEmptyExpression") return "";
+	return out.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;|&apos;/g, "'").replace(/\s+/g, " ").trim();
+}
+/** Whether the code's element can be the one that showed `text` (its own words are in it); true when it can't be told. */
+function showsText(el, text) {
+	const own = staticText(el).toLowerCase();
+	const shown = text.replace(/\s+/g, " ").trim().toLowerCase();
+	return !own || !shown || shown.includes(own);
+}
+/**
+* The element named `name` that shows `text`, near where one was (the code moved: lines added above it, or another
+* element now at its place), by its own words. `many` when several fit: never a guess between look-alikes.
+*/
+function findByWords(code, near, name, text, ast) {
+	const tree = ast ?? parseTsx(code);
+	if (!text.trim()) return null;
+	const fits = [];
+	const stack = [tree.program];
+	while (stack.length) {
+		const n = stack.pop();
+		if (!n || typeof n !== "object") continue;
+		if (Array.isArray(n)) {
+			for (const c of n) stack.push(c);
+			continue;
+		}
+		if (n.type === "JSXElement" && Math.abs(n.loc.start.line - near.line) <= 60 && elementName(n) === name && staticText(n) && showsText(n, text)) fits.push(n);
+		for (const key of Object.keys(n)) {
+			if (SKIP_KEYS$1.has(key)) continue;
+			const v = n[key];
+			if (v && typeof v === "object") stack.push(v);
+		}
+	}
+	if (fits.length > 1) return "many";
+	if (!fits.length) return null;
+	const at = fits[0].openingElement.loc.start;
+	const loc = {
+		line: at.line,
+		col: at.column + 1
+	};
+	const found = findElement(code, loc, tree);
+	return found ? {
+		loc,
+		found
+	} : null;
+}
 function elementName(el) {
 	const name = (n) => n.type === "JSXIdentifier" ? n.name : n.type === "JSXMemberExpression" ? `${name(n.object)}.${name(n.property)}` : "";
 	return name(el.openingElement.name);
@@ -46497,18 +47080,240 @@ function lineRange(code, node) {
 		whole: false
 	};
 }
-/**
-* Removing (or moving) a whole child of other markup, with only the blank space of its own lines, leaves valid
-* markup around it: these two need no parse to check.
-*/
-function removeElement(code, loc, ast) {
+/** What removing the element leaves: the code, and where the removed part began. */
+function removal$1(code, loc, ast) {
 	const f = findElement(code, loc, ast);
 	if (!f) throw new CodemodError("Element not found at that location");
 	const { unit } = childUnit(f, code);
 	const r = lineRange(code, unit);
 	const s = new MagicString(code);
 	s.remove(r.start, r.end);
-	return s.toString();
+	return {
+		code: s.toString(),
+		at: r.start,
+		found: f
+	};
+}
+/** Names never taken out with what used them: the JSX of the classic runtime needs them in scope unwritten. */
+var KEEP_IMPORTS = /* @__PURE__ */ new Set(["React", "h"]);
+/**
+* Remove the element, and what only it used, so the app still builds (an unused import or prop fails a build that
+* checks for them): the imports, and the props its component read for it (unless the props are spread on, where
+* leaving one out would change what is passed). Anything else it alone used (a variable, a helper, a hook's value)
+* may do something besides, so it stays and is named in `unused`.
+*/
+function removeElementTidy(code, loc, ast) {
+	const tree = ast ?? parseTsx(code);
+	const { code: after, at, found } = removal$1(code, loc, tree);
+	const before = nameCounts(tree.program);
+	const took = [];
+	/** Written somewhere besides its own declaration before the removal, and nowhere after it. */
+	const gone = (now) => (name, own) => (before.get(name) ?? 0) > own && (now.get(name) ?? 0) <= own;
+	let current = after;
+	let currentTree;
+	try {
+		currentTree = parseTsx(after);
+	} catch {
+		return {
+			code: after,
+			took: [],
+			unused: []
+		};
+	}
+	const fns = functionsAround(tree, found.el.start);
+	{
+		const lastUseGone = gone(nameCounts(currentTree.program));
+		const s = new MagicString(current);
+		let changed = false;
+		for (const fn of fns) {
+			const pattern = fn.params?.[0];
+			if (pattern?.type !== "ObjectPattern" || pattern.end > at || pattern.properties.some((p) => p.type === "RestElement")) continue;
+			const drop = /* @__PURE__ */ new Set();
+			for (const prop of pattern.properties) {
+				const name = boundName(prop);
+				if (name && lastUseGone(name, occurrences(prop, name))) drop.add(prop);
+			}
+			if (!drop.size) continue;
+			for (const prop of drop) took.push(`the ${boundName(prop)} prop`);
+			if (drop.size === pattern.properties.length) {
+				const close = current.indexOf("}", pattern.properties[pattern.properties.length - 1].end);
+				s.overwrite(pattern.start, close + 1, "_props");
+			} else dropFromList(s, pattern.properties, drop);
+			changed = true;
+		}
+		if (changed) {
+			const next = s.toString();
+			try {
+				currentTree = parseTsx(next);
+				current = next;
+			} catch {
+				took.length = 0;
+			}
+		}
+	}
+	{
+		const lastUseGone = gone(nameCounts(currentTree.program));
+		const s = new MagicString(current);
+		const named = [];
+		for (const decl of currentTree.program.body) {
+			if (decl.type !== "ImportDeclaration" || !decl.specifiers.length) continue;
+			const specs = decl.specifiers;
+			const drop = specs.filter((sp) => !KEEP_IMPORTS.has(sp.local.name) && lastUseGone(sp.local.name, 0));
+			if (!drop.length) continue;
+			for (const sp of drop) named.push(`the ${sp.local.name} import`);
+			if (drop.length === specs.length) {
+				const r = lineRange(current, decl);
+				s.remove(r.start, r.end);
+				continue;
+			}
+			const def = specs.find((sp) => sp.type === "ImportDefaultSpecifier");
+			const ns = specs.find((sp) => sp.type === "ImportNamespaceSpecifier");
+			const list = specs.filter((sp) => sp.type === "ImportSpecifier");
+			const out = new Set(drop);
+			if (def && out.has(def)) s.remove(def.start, ns ? ns.start : current.indexOf("{", def.end));
+			if (ns && out.has(ns)) s.remove(def ? def.end : ns.start, ns.end);
+			if (list.length && list.every((sp) => out.has(sp))) {
+				if (def) s.remove(def.end, current.indexOf("}", list[list.length - 1].end) + 1);
+			} else dropFromList(s, list, out);
+		}
+		if (named.length) {
+			const next = s.toString();
+			try {
+				currentTree = parseTsx(next);
+				current = next;
+				took.unshift(...named);
+			} catch {}
+		}
+	}
+	const lastUseGone = gone(nameCounts(currentTree.program));
+	const unused = [];
+	for (const fn of fns) for (const [name, own] of declaredIn(fn.body)) if (lastUseGone(name, own)) unused.push(name);
+	for (const [name, own] of declaredIn(tree.program)) if (lastUseGone(name, own)) unused.push(name);
+	return {
+		code: current,
+		took,
+		unused
+	};
+}
+/** Nodes whose `key` is a name written in place, not a use of one (`{ title: … }`, `title: string` in a type). */
+var NAMED_KEYS = /* @__PURE__ */ new Set([
+	"ObjectProperty",
+	"ObjectMethod",
+	"ClassProperty",
+	"ClassMethod",
+	"ClassAccessorProperty",
+	"TSPropertySignature",
+	"TSMethodSignature"
+]);
+/**
+* How often each name is written outside imports, as a use or a binding: not where it only names a property
+* (`row.title`, `{ title: … }`, `<Field title=…>`, a type's `title: string`), which uses nothing by that name.
+*/
+function nameCounts(root, skip) {
+	const counts = /* @__PURE__ */ new Map();
+	const stack = [root];
+	while (stack.length) {
+		const n = stack.pop();
+		if (!n || typeof n !== "object" || n === skip) continue;
+		if (Array.isArray(n)) {
+			for (const c of n) stack.push(c);
+			continue;
+		}
+		if (n.type === "ImportDeclaration") continue;
+		if ((n.type === "Identifier" || n.type === "JSXIdentifier") && typeof n.name === "string") counts.set(n.name, (counts.get(n.name) ?? 0) + 1);
+		for (const key of Object.keys(n)) {
+			if (SKIP_KEYS$1.has(key)) continue;
+			if (key === "key" && NAMED_KEYS.has(n.type) && !n.computed) continue;
+			if (key === "property" && (n.type === "MemberExpression" || n.type === "OptionalMemberExpression" || n.type === "JSXMemberExpression") && !n.computed) continue;
+			if (key === "name" && n.type === "JSXAttribute") continue;
+			if (key === "right" && n.type === "TSQualifiedName") continue;
+			const v = n[key];
+			if (v && typeof v === "object") stack.push(v);
+		}
+	}
+	return counts;
+}
+/** How often `name` is written in a binding, its default value left out (that is a use of other names). */
+function occurrences(binding, name) {
+	return nameCounts(binding, binding.value?.type === "AssignmentPattern" ? binding.value.right : binding.type === "AssignmentPattern" ? binding.right : void 0).get(name) ?? 0;
+}
+/** The name a property of a destructuring binds (`{ onDelete }`, `{ onDelete: del }`, `{ size = 'md' }`). */
+function boundName(prop) {
+	if (prop.type !== "ObjectProperty" || prop.computed) return null;
+	const v = prop.value;
+	if (v?.type === "Identifier") return v.name;
+	if (v?.type === "AssignmentPattern" && v.left.type === "Identifier") return v.left.name;
+	return null;
+}
+/**
+* The component the element at `loc` is part of: the nearest function around it named like one (`function Card`,
+* `const Card = () => …`). Null outside one.
+*/
+function componentAt(code, loc, ast) {
+	const tree = ast ?? parseTsx(code);
+	const offset = offsetOf(code, loc);
+	if (offset < 0) return null;
+	const chain = [];
+	walkAt(tree, null, offset, (n) => {
+		chain.push(n);
+		return false;
+	});
+	let name = null;
+	chain.forEach((n, i) => {
+		if (n.type !== "FunctionDeclaration" && n.type !== "FunctionExpression" && n.type !== "ArrowFunctionExpression") return;
+		let j = i - 1;
+		while (j >= 0 && chain[j].type === "CallExpression") j--;
+		const own = (chain[j]?.type === "VariableDeclarator" && chain[j].id.type === "Identifier" ? chain[j].id.name : null) ?? n.id?.name ?? null;
+		if (own && /^[A-Z]/.test(own)) name = own;
+	});
+	return name;
+}
+/** The functions around a place in the code, innermost first. */
+function functionsAround(ast, offset) {
+	const out = [];
+	walkAt(ast, null, offset, (n) => {
+		if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") out.unshift(n);
+		return false;
+	});
+	return out;
+}
+/** Names a block declares directly (not exported), with how often each is written in its declaration. */
+function declaredIn(block) {
+	const out = [];
+	const statements = block?.type === "BlockStatement" || block?.type === "Program" ? block.body : [];
+	for (const st of statements) {
+		if (st.type === "FunctionDeclaration" && st.id) out.push([st.id.name, 1]);
+		if (st.type !== "VariableDeclaration") continue;
+		for (const d of st.declarations) {
+			const names = [];
+			const collect = (p) => {
+				if (!p) return;
+				if (p.type === "Identifier") names.push(p.name);
+				else if (p.type === "ObjectPattern") for (const prop of p.properties) collect(prop.type === "RestElement" ? prop.argument : prop.value);
+				else if (p.type === "ArrayPattern") for (const e of p.elements) collect(e);
+				else if (p.type === "AssignmentPattern") collect(p.left);
+			};
+			collect(d.id);
+			for (const name of names) out.push([name, nameCounts(d.id, void 0).get(name) ?? 1]);
+		}
+	}
+	return out;
+}
+/** Take `drop` out of a comma-separated list, each run of them with the comma joining it to what stays. */
+function dropFromList(s, items, drop) {
+	let i = 0;
+	while (i < items.length) {
+		if (!drop.has(items[i])) {
+			i++;
+			continue;
+		}
+		let j = i;
+		while (j + 1 < items.length && drop.has(items[j + 1])) j++;
+		if (j + 1 < items.length) s.remove(items[i].start, items[j + 1].start);
+		else if (i > 0) s.remove(items[i - 1].end, items[j].end);
+		else s.remove(items[i].start, items[j].end);
+		i = j + 1;
+	}
 }
 function moveElement(code, from, to, where, parsed) {
 	const ast = parsed ?? parseTsx(code);
@@ -47605,6 +48410,7 @@ function sanitizeRefs(raw) {
 		if (hint) ref.hint = hint;
 		const frames = frameList(o.frames);
 		if (frames.length) ref.frames = frames;
+		if (typeof o.same === "number" && Number.isInteger(o.same) && o.same > 1) ref.same = Math.min(o.same, 1e6);
 		return ref;
 	});
 }
@@ -47639,7 +48445,7 @@ function sample(into, v, positive = false) {
 	if (into.length > SAMPLES) into.shift();
 }
 /**
-* How the studio is used in an app: the commands given (spoken or typed, pointing with the hand or the mouse), the
+* How the studio is used in an app: the commands given (spoken or typed, and whether the mouse pointed), the
 * changes kept and undone, the tests run. Each event is appended to .saywright/metrics.jsonl in the app (exported
 * from Stats); the studio itself keeps only the counts and the latest values its Stats show.
 */
@@ -47753,9 +48559,25 @@ var EVERYWHERE = /\b(?:everywhere|wherever|throughout|all of (?:them|these|those
 var EVERYWHERE_AT_END = new RegExp(`\\s+(?:${EVERYWHERE.source})(?:\\s+(?:it|they)\\s+(?:appears?|shows?|is|are)(?:\\s+used)?)?[.!]*$`, "i");
 /** What may follow a quoted new text without asking for anything more. */
 var POLITE = /^(?:please|thanks|thank you|instead|now|for me)?[.!]*$/i;
-var MARK = /\uE000(\d+)\uE000/g;
+var MARK$1 = /\uE000(\d+)\uE000/g;
+/** An unquoted new text without the quotes and the full stop around it ("Are you sure?" keeps its question mark). */
 function stripQuotes(s) {
-	return s.replace(/^[\s"“'‘]+|[\s"”'’.!?]+$/g, "");
+	return s.replace(/^[\s"“'‘]+|[\s"”'’.]+$/g, "");
+}
+/** Words that make a removal about something of the element, or about when, rather than the element itself. */
+var NOT_THE_ELEMENT = new Set("on in at for when if unless until while after before and but or so then with without except only instead to into than border borders shadow shadows padding margin margins spacing space gap underline background bg color colour outline radius rounded rounding corner corners bold italic animation transition scrollbar placeholder tooltip focus hover opacity blur gradient style styles styling class classes wrap wrapping overflow limit validation confirmation delay duplicate duplicates uppercase lowercase".split(" "));
+/**
+* What a request that starts with remove, delete, drop or hide asks to go: the element itself ("remove this", "get
+* rid of that button", "delete the VIP badge"), or something of it ("remove the border", "hide this on mobile").
+* Null for any other request: a word like delete in "make the Delete button ask first" is no reason to delete anything.
+*/
+function removal(asked) {
+	const s = asked.trim().replace(/^(?:(?:please|can you|could you|would you|just|now)\s+)+/, "");
+	const verb = /^(?:remove|delete|get rid of|drop|hide)\b(.*)$/.exec(s);
+	if (!verb) return null;
+	const rest = verb[1].replace(/\b(?:please|now|entirely|completely|altogether|for me)\b/g, " ").replace(/\bfrom (?:the |this )?(?:page|screen|view|app)\b/g, " ").trim();
+	const words = rest ? rest.split(/\s+/) : [];
+	return words.length <= 4 && !words.some((w) => NOT_THE_ELEMENT.has(w)) ? "element" : "other";
 }
 /**
 * The quoted parts of a request ("…", “…”, «…», '…'), each replaced by a marker so the words around them are read
@@ -47772,56 +48594,73 @@ function quoted(s) {
 		values
 	};
 }
-/** The new text a rename asks for, and whether it is for every place it appears; null when more is asked of it than a rename. */
+/**
+* The new text a rename asks for, whether it is for every place it appears, and whether it was quoted (then it is
+* taken exactly as written); null when more is asked of it than a rename.
+*/
 function newText(tail, values) {
 	const lead = /^\s*\uE000(\d+)\uE000(.*)$/s.exec(tail);
 	if (lead) {
 		const value = values[Number(lead[1])].trim();
-		const rest = lead[2].replace(MARK, (_m, i) => values[Number(i)]).trim();
+		const rest = lead[2].replace(MARK$1, (_m, i) => values[Number(i)]).trim();
 		if (EVERYWHERE.test(rest)) return {
 			value,
-			everywhere: true
+			everywhere: true,
+			quoted: true
 		};
 		return POLITE.test(rest) ? {
 			value,
-			everywhere: false
+			everywhere: false,
+			quoted: true
 		} : null;
 	}
-	let value = stripQuotes(tail.replace(MARK, (_m, i) => `"${values[Number(i)]}"`));
+	let value = stripQuotes(tail.replace(MARK$1, (_m, i) => `"${values[Number(i)]}"`));
 	const scope = EVERYWHERE_AT_END.exec(value);
 	if (scope) value = value.slice(0, scope.index).trim();
 	return {
 		value,
-		everywhere: !!scope
+		everywhere: !!scope,
+		quoted: false
 	};
 }
+/**
+* An unquoted new text starts with a capital, as said ("rename this to pay now" \u2192 "Pay now"), unless its first word
+* is written with capitals of its own: "iOS", "eBay", "macOS" stay as they are.
+*/
+function capitalized(value) {
+	const first = value.split(/\s/)[0];
+	return /\p{Lu}|\d/u.test(first.slice(1)) ? value : value[0].toUpperCase() + value.slice(1);
+}
 var words = (s) => " " + s.toLowerCase().replace(/[“”"‘’']/g, "").replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim() + " ";
 function parseQuick(input) {
 	const raw = input.trim();
 	const { masked, values } = quoted(raw);
 	const t = words(raw);
-	const asked = words(masked.replace(MARK, " "));
+	const asked = words(masked.replace(MARK$1, " "));
 	if (/\b(look|looks|style|styled)\s+(just\s+|exactly\s+)?like\b|\bsame (style|look|size|styling) as\b|\bmatch(es)?\b/.test(asked)) return {
 		kind: "copy",
 		adjust: /\b(smaller|tinier|less)\b/.test(asked) ? -1 : /\b(bigger|larger)\b/.test(asked) ? 1 : 0
 	};
-	const move = /\b(move|put|place|drag)\b.*\b(above|below|before|after|under|over|beneath|underneath)\b/.exec(asked);
-	if (move) return {
-		kind: "move",
-		where: /^(below|after|under|beneath|underneath)$/.test(move[2]) ? "below" : "above"
-	};
-	if (/\b(remove|delete|get rid of|drop|hide)\b/.test(asked)) return { kind: "remove" };
 	const text = /\b(?:rename|relabel|call)\b.*?\b(?:to|as)\b\s+(.+)$/is.exec(masked) ?? /\b(?:change|set|update|make)\s+(?:the\s+)?(?:text|label|copy|title|wording|words?)\b.*?\b(?:to|into)\b\s+(.+)$/is.exec(masked) ?? /\b(?:make\s+(?:this|that|it)\s+)?(?:say|read)s?\s+(.+)$/is.exec(masked);
 	if (text) {
 		const found = newText(text[1], values);
 		if (!found) return null;
-		const everywhere = found.everywhere || EVERYWHERE.test(masked.slice(0, text.index + text[0].length - text[1].length).replace(MARK, " "));
+		const everywhere = found.everywhere || EVERYWHERE.test(masked.slice(0, text.index + text[0].length - text[1].length).replace(MARK$1, " "));
 		if (found.value) return {
 			kind: "text",
-			value: found.value[0].toUpperCase() + found.value.slice(1),
+			value: found.quoted ? found.value : capitalized(found.value),
 			...everywhere ? { everywhere: true } : {}
 		};
 	}
+	if (/\b(?:and|then|also|plus)\b/.test(asked)) return null;
+	const move = /\b(move|put|place|drag)\b.*\b(above|below|before|after|under|over|beneath|underneath)\b/.exec(asked);
+	if (move) return {
+		kind: "move",
+		where: /^(below|after|under|beneath|underneath)$/.test(move[2]) ? "below" : "above"
+	};
+	const removes = removal(asked);
+	if (removes === "element") return { kind: "remove" };
+	if (removes === "other") return null;
 	const big = /\b(bigger|larger|huge|grow|taller|wider|increase)\b/.test(t);
 	const small = /\b(smaller|tiny|tinier|shrink|shorter|narrower|decrease|compact)\b/.test(t);
 	const spacing = /\b(padding|spacing|space|gap|gaps|room|airy|tighter|looser|roomier)\b/.test(t);
@@ -47898,144 +48737,195 @@ function quickEdit(text, refs, project) {
 		why: "Changing words everywhere they appear needs an AI: a quick edit changes only what you point at."
 	};
 	const a = refs[0];
-	const where = locOf(a);
+	if (!a && /\b(?:this|that|these|those|it|them)\b/i.test(text)) return {
+		kind: "message",
+		tone: "info",
+		text: "Point at what you mean (or click it to select it), then say it again."
+	};
+	let where = locOf(a);
 	if (!a || !where || !/\.[jt]sx$/.test(where.file)) return null;
 	let code;
 	let ast;
 	try {
 		code = project.read(where.file);
-		ast = parseTsx(code);
 	} catch {
 		return null;
 	}
-	const found = findElement(code, where.loc, ast);
-	if (!found) return null;
-	const name = elementName(found.el);
+	try {
+		ast = parseTsx(code);
+	} catch {
+		return {
+			kind: "message",
+			tone: "warn",
+			text: `${where.file} doesn’t parse right now (a syntax error?), so a quick edit can’t be made in it. Fix it, or ask the AI.`,
+			next: [{ kind: "ask-ai" }, {
+				kind: "open",
+				src: a.src ?? `${where.file}:1:1`
+			}]
+		};
+	}
+	let found = findElement(code, where.loc, ast);
+	if (!found || !showsText(found.el, a.text)) {
+		const moved = findByWords(code, where.loc, found ? elementName(found.el) : a.name, a.text, ast);
+		if (moved && moved !== "many") {
+			where = {
+				file: where.file,
+				loc: moved.loc
+			};
+			found = moved.found;
+		} else if (!found || moved === "many") return {
+			kind: "message",
+			tone: "info",
+			text: `The code changed since you selected ${describeRef(a)}, so it isn’t where it was: select it again.`,
+			next: [{ kind: "ask-ai" }]
+		};
+	}
+	const el = found.el;
+	const here = where;
+	const name = elementName(el);
 	const config = project.config;
 	const spec = project.componentSpec(name, where.file);
-	const props = readProps(found.el);
+	const props = readProps(el);
 	const what = describeRef(a);
-	try {
-		switch (intent.kind) {
-			case "set": {
-				if (!spec) return null;
-				const pick = pickSet(spec, intent.terms, config.synonyms);
-				if (!pick) return null;
-				const def = spec.props[pick.prop];
-				if (current(props, pick.prop, def) === pick.value) return {
-					kind: "message",
-					tone: "info",
-					text: `${what} already uses ${pick.prop} “${pick.value}”.`
-				};
-				const after = setProp(code, where.loc, pick.prop, valueOrNull(def, pick.value), ast);
-				const was = current(props, pick.prop, def);
-				return edit(`${what} · ${pick.prop} ${was ? `${was} → ` : "→ "}${pick.value}`, `Set ${pick.prop}="${pick.value}" on ${name} in ${where.file}.`, where.file, code, after);
-			}
-			case "step": {
-				if (!spec) return null;
-				const chosen = stepProp(spec, intent.focus);
-				if (!chosen) return null;
-				const [prop, def] = chosen;
-				const now = current(props, prop, def);
-				if (now === null) return null;
-				const steps = def.ladder ?? def.values;
-				const i = steps.indexOf(now);
-				if (i < 0) return null;
-				const next = steps[Math.max(0, Math.min(steps.length - 1, i + intent.dir * intent.amount))];
-				if (next === now) {
-					const ds = spec.file ? [{
-						kind: "open",
-						src: `${spec.file}:1:1`
-					}] : [];
-					return {
+	const result = attempt(intent, here);
+	if (result?.kind === "edit") {
+		if (a.same && a.same > 1) {
+			result.title += ` (all ${a.same} on this page)`;
+			result.summary += ` Its code draws it ${a.same} times on this page (the rows of a list, or a component used several times): this changes them all.`;
+		}
+		const component = componentAt(code, here.loc, ast);
+		if (component) result.component = component;
+	}
+	return result;
+	function attempt(intent, where) {
+		try {
+			switch (intent.kind) {
+				case "set": {
+					if (!spec) return null;
+					const pick = pickSet(spec, intent.terms, config.synonyms);
+					if (!pick) return null;
+					const def = spec.props[pick.prop];
+					if (current(props, pick.prop, def) === pick.value) return {
 						kind: "message",
 						tone: "info",
-						text: `${what} is already the ${intent.dir > 0 ? "largest" : "smallest"} ${prop} (“${now}”) in your design system.`,
-						next: [{ kind: "ask-ai" }, ...ds]
+						text: `${what} already uses ${pick.prop} “${pick.value}”.`
 					};
+					const after = setProp(code, where.loc, pick.prop, valueOrNull(def, pick.value), ast);
+					const was = current(props, pick.prop, def);
+					return edit(`${what} · ${pick.prop} ${was ? `${was} → ` : "→ "}${pick.value}`, `Set ${pick.prop}="${pick.value}" on ${name} in ${where.file}.`, where.file, code, after);
 				}
-				const after = setProp(code, where.loc, prop, valueOrNull(def, next), ast);
-				return edit(`${what} · ${prop} ${now} → ${next}`, `Changed ${prop} from "${now}" to "${next}" on ${name}.`, where.file, code, after);
-			}
-			case "copy": {
-				const b = refs[1];
-				const bWhere = locOf(b);
-				if (!b || !bWhere) return {
-					kind: "message",
-					tone: "info",
-					text: "Point at a second thing for “that”, or select both first (hold a pinch, or ⇧ click, on each)."
-				};
-				if (!spec) return null;
-				const bCode = bWhere.file === where.file ? code : project.read(bWhere.file);
-				const bFound = findElement(bCode, bWhere.loc, bCode === code ? ast : void 0);
-				if (!bFound) return null;
-				if (elementName(bFound.el) !== name) return null;
-				const bProps = readProps(bFound.el);
-				const sets = [];
-				const changed = [];
-				for (const [prop, def] of Object.entries(spec.props)) {
-					let target = current(bProps, prop, def);
-					if (target === null) continue;
-					if (intent.adjust && def.ordered) {
-						const steps = def.ladder ?? def.values;
-						const i = steps.indexOf(target);
-						if (i >= 0) target = steps[Math.max(0, Math.min(steps.length - 1, i + intent.adjust))];
+				case "step": {
+					if (!spec) return null;
+					const chosen = stepProp(spec, intent.focus);
+					if (!chosen) return null;
+					const [prop, def] = chosen;
+					const now = current(props, prop, def);
+					if (now === null) return null;
+					const steps = def.ladder ?? def.values;
+					const i = steps.indexOf(now);
+					if (i < 0) return null;
+					const next = steps[Math.max(0, Math.min(steps.length - 1, i + intent.dir * intent.amount))];
+					if (next === now) {
+						const ds = spec.file ? [{
+							kind: "open",
+							src: `${spec.file}:1:1`
+						}] : [];
+						return {
+							kind: "message",
+							tone: "info",
+							text: `${what} is already the ${intent.dir > 0 ? "largest" : "smallest"} ${prop} (“${now}”) in your design system.`,
+							next: [{ kind: "ask-ai" }, ...ds]
+						};
 					}
-					if (current(props, prop, def) === target) continue;
-					sets.push([prop, valueOrNull(def, target)]);
-					changed.push(`${prop}="${target}"`);
+					const after = setProp(code, where.loc, prop, valueOrNull(def, next), ast);
+					return edit(`${what} · ${prop} ${now} → ${next}`, `Changed ${prop} from "${now}" to "${next}" on ${name}.`, where.file, code, after);
 				}
-				if (!changed.length) return {
-					kind: "message",
-					tone: "info",
-					text: `${what} already looks like ${describeRef(b)}.`
-				};
-				const after = setProps(code, where.loc, sets, ast);
-				const tail = intent.adjust < 0 ? ", but smaller" : intent.adjust > 0 ? ", but bigger" : "";
-				return edit(`${what} looks like ${describeRef(b)}${tail}`, `Copied ${changed.join(", ")} from ${describeRef(b)}.`, where.file, code, after);
-			}
-			case "text": {
-				const textProp = spec?.text ?? "children";
-				let after;
-				try {
-					after = setText(code, where.loc, intent.value, textProp, ast);
-				} catch (err) {
-					if (!(err instanceof ComputedTextError)) throw err;
-					return {
-						kind: "needs-ai",
-						why: `${what}’s text is built from code (“${childrenCode(code, found.el)}”), so changing it needs an AI.`,
-						src: a.src ?? void 0
+				case "copy": {
+					const b = refs[1];
+					const bWhere = locOf(b);
+					if (!b || !bWhere) return {
+						kind: "message",
+						tone: "info",
+						text: "Point at a second thing for “that”, or select both first (⇧ click each)."
 					};
+					if (!spec) return null;
+					const bCode = bWhere.file === where.file ? code : project.read(bWhere.file);
+					const bFound = findElement(bCode, bWhere.loc, bCode === code ? ast : void 0);
+					if (!bFound) return null;
+					if (elementName(bFound.el) !== name) return null;
+					const bProps = readProps(bFound.el);
+					const sets = [];
+					const changed = [];
+					for (const [prop, def] of Object.entries(spec.props)) {
+						let target = current(bProps, prop, def);
+						if (target === null) continue;
+						if (intent.adjust && def.ordered) {
+							const steps = def.ladder ?? def.values;
+							const i = steps.indexOf(target);
+							if (i >= 0) target = steps[Math.max(0, Math.min(steps.length - 1, i + intent.adjust))];
+						}
+						if (current(props, prop, def) === target) continue;
+						sets.push([prop, valueOrNull(def, target)]);
+						changed.push(`${prop}="${target}"`);
+					}
+					if (!changed.length) return {
+						kind: "message",
+						tone: "info",
+						text: `${what} already looks like ${describeRef(b)}.`
+					};
+					const after = setProps(code, where.loc, sets, ast);
+					const tail = intent.adjust < 0 ? ", but smaller" : intent.adjust > 0 ? ", but bigger" : "";
+					return edit(`${what} looks like ${describeRef(b)}${tail}`, `Copied ${changed.join(", ")} from ${describeRef(b)}.`, where.file, code, after);
+				}
+				case "text": {
+					const textProp = spec?.text ?? "children";
+					let after;
+					try {
+						after = setText(code, where.loc, intent.value, textProp, ast);
+					} catch (err) {
+						if (!(err instanceof ComputedTextError)) throw err;
+						return {
+							kind: "needs-ai",
+							why: `${what}’s text is built from code (“${childrenCode(code, el)}”), so changing it needs an AI.`,
+							src: a.src ?? void 0
+						};
+					}
+					return edit(`Rename ${what} to “${intent.value}”`, `Changed the text of ${name} in ${where.file}.`, where.file, code, after);
+				}
+				case "remove": {
+					const { code: after, took, unused } = removeElementTidy(code, where.loc, ast);
+					const also = took.length ? ` Also took out what only it used: ${andList(took)}.` : "";
+					const left = unused.length ? ` Now unused, and left as they are in case they do more: ${andList(unused.map((n) => `\`${n}\``))}.` : "";
+					return edit(`Remove ${what}${unused.length ? ` · leaves ${unused.slice(0, 2).join(", ")}${unused.length > 2 ? "…" : ""} unused` : ""}`, `Removed the ${name} element from ${where.file}.${also}${left}`, where.file, code, after);
+				}
+				case "move": {
+					const b = refs[1];
+					const bWhere = locOf(b);
+					if (!b || !bWhere) return {
+						kind: "message",
+						tone: "info",
+						text: "Say where: point at the other element while you say “that”."
+					};
+					if (bWhere.file !== where.file) return null;
+					const after = moveElement(code, where.loc, bWhere.loc, intent.where, ast);
+					if (after === code) return {
+						kind: "message",
+						tone: "info",
+						text: `${what} is already ${intent.where} ${describeRef(b)}.`
+					};
+					return edit(`Move ${what} ${intent.where} ${describeRef(b)}`, `Reordered elements in ${where.file}.`, where.file, code, after);
 				}
-				return edit(`Rename ${what} to “${intent.value}”`, `Changed the text of ${name} in ${where.file}.`, where.file, code, after);
-			}
-			case "remove": {
-				const after = removeElement(code, where.loc, ast);
-				return edit(`Remove ${what}`, `Removed the ${name} element from ${where.file}.`, where.file, code, after);
-			}
-			case "move": {
-				const b = refs[1];
-				const bWhere = locOf(b);
-				if (!b || !bWhere) return {
-					kind: "message",
-					tone: "info",
-					text: "Say where: point at the other element while you say “that”."
-				};
-				if (bWhere.file !== where.file) return null;
-				const after = moveElement(code, where.loc, bWhere.loc, intent.where, ast);
-				if (after === code) return {
-					kind: "message",
-					tone: "info",
-					text: `${what} is already ${intent.where} ${describeRef(b)}.`
-				};
-				return edit(`Move ${what} ${intent.where} ${describeRef(b)}`, `Reordered elements in ${where.file}.`, where.file, code, after);
 			}
+		} catch (err) {
+			if (err instanceof CodemodError) return null;
+			throw err;
 		}
-	} catch (err) {
-		if (err instanceof CodemodError) return null;
-		throw err;
+		return null;
 	}
-	return null;
+}
+/** “a, b and c”. */
+function andList(items) {
+	return items.length <= 1 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
 }
 /** Set one design-system prop on the element at `src`, from the Inspector. */
 function propEdit(project, src, prop, value) {
@@ -48242,6 +49132,18 @@ var REPLAY_REASONS = {
 		en: "something went wrong",
 		ar: "حدث خطأ"
 	},
+	disabled: {
+		en: "it was disabled, so a person couldn’t use it either",
+		ar: "كان معطّلًا، فلا يستطيع أحد استخدامه"
+	},
+	secret: {
+		en: "it needs a secret that isn’t saved (the Test tab keeps them)",
+		ar: "يحتاج قيمة سرية غير محفوظة (تحفظها لسان الاختبار)"
+	},
+	"no-effect": {
+		en: "it did nothing this time",
+		ar: "لم يفعل شيئًا هذه المرة"
+	},
 	stopped: {
 		en: "you stopped it",
 		ar: "أوقفتَها أنت"
@@ -48700,6 +49602,17 @@ function changedLines(screens) {
 }
 //#endregion
 //#region server/sessions/analyze.ts
+/**
+* Turns a recorded session into findings without AI: a merged timeline,
+* grouped issues with evidence, and scores. Deterministic, so the same session
+* always scores the same.
+*
+* Long, noisy sessions stay readable: messages and addresses that differ only in
+* ids, numbers or timestamps are one problem with a count ("GET /api/orders/{id}"),
+* a problem's repeats past its evidence aren't listed one by one, and each kind of
+* problem lists its first 200; the rest is counted in `more`. The work is done in
+* slices (analyzeAsync), so the studio keeps answering while a long one runs.
+*/
 var SLOW_REQUEST_MS = 1500;
 /** Occurrences of one problem kept as its evidence (and listed in the timeline); later ones are counted. */
 var EVIDENCE = 12;
@@ -48773,7 +49686,7 @@ function fmtMsAr(ms) {
 /** An address's parts, without building a URL for each of thousands of requests. */
 var URL_PARTS = /^(?:[a-z][\w+.-]*:\/\/[^/?#]*)?([^?#]*)(\?[^#]*)?(#.*)?$/i;
 /** The page part of a URL: path, a short query, and the hash when the app routes with it (#/checkout). */
-function pathOf(url) {
+function pathOf$1(url) {
 	const m = /^(?:https?:\/\/[^/?#\s]+)?\/[^\s\\]*$/i.test(url) ? URL_PARTS.exec(url) : null;
 	if (!m || /(^|\/)\.\.?(\/|$)|%/.test(m[1])) try {
 		const u = new URL(url, "http://x");
@@ -49061,15 +49974,19 @@ function* analysis(meta, events, transcript, shots) {
 				});
 				lastAction = it;
 				refFile(e.el.src);
-				if (e.el.locator) steps.push({
-					t: at,
-					kind: "fill",
-					locator: e.el.locator,
-					value: e.masked ? "" : e.value,
-					description: `Fill ${nameOf(e.el)}`,
-					descriptionAr: `املأ ${nameOfAr(e.el)}`,
-					...likeOf(e.el)
-				});
+				if (e.el.locator) {
+					const secret = e.masked ? { secret: e.secret ?? secretName(e.el.label || e.el.name) } : {};
+					steps.push({
+						t: at,
+						kind: "fill",
+						locator: e.el.locator,
+						value: e.masked ? "" : e.value,
+						...secret,
+						description: `Fill ${nameOf(e.el)}`,
+						descriptionAr: `املأ ${nameOfAr(e.el)}`,
+						...likeOf(e.el)
+					});
+				}
 				if (!e.el.label && e.el.role === "textbox") issue(`nolabel:${e.el.src ?? e.el.locator}`, () => ({
 					kind: "accessibility",
 					severity: "medium",
@@ -49083,7 +50000,7 @@ function* analysis(meta, events, transcript, shots) {
 				}), it);
 				break;
 			}
-			case "change":
+			case "change": {
 				lastAction = add({
 					t: at,
 					kind: "action",
@@ -49092,17 +50009,20 @@ function* analysis(meta, events, transcript, shots) {
 					src: e.el.src
 				});
 				refFile(e.el.src);
+				const list = e.checked === void 0 && (e.el.tag === "select" || e.el.role === "combobox" || e.el.role === "listbox");
 				if (e.el.locator) steps.push({
 					t: at,
 					kind: "fill",
 					locator: e.el.locator,
 					value: e.value,
 					...e.checked !== void 0 ? { checked: e.checked } : {},
+					...list ? { select: e.options?.length ? e.options : [e.value] } : {},
 					description: `Set ${nameOf(e.el)}`,
 					descriptionAr: `اضبط ${nameOfAr(e.el)}`,
 					...likeOf(e.el)
 				});
 				break;
+			}
 			case "submit":
 				lastAction = add({
 					t: at,
@@ -49139,15 +50059,15 @@ function* analysis(meta, events, transcript, shots) {
 				add({
 					t: at,
 					kind: "navigation",
-					text: `${how} ${pathOf(e.url)}${e.title ? ` (“${e.title}”)` : ""}`,
-					textAr: `${howAr} ${iso(pathOf(e.url))}${e.title ? ` («${iso(e.title)}»)` : ""}`
+					text: `${how} ${pathOf$1(e.url)}${e.title ? ` (“${e.title}”)` : ""}`,
+					textAr: `${howAr} ${iso(pathOf$1(e.url))}${e.title ? ` («${iso(e.title)}»)` : ""}`
 				});
 				if (e.type === "page" && !steps.length) steps.push({
 					t: at,
 					kind: "navigate",
 					url: e.url,
-					description: `Open ${pathOf(e.url)}`,
-					descriptionAr: `افتح ${iso(pathOf(e.url))}`
+					description: `Open ${pathOf$1(e.url)}`,
+					descriptionAr: `افتح ${iso(pathOf$1(e.url))}`
 				});
 				break;
 			}
@@ -49239,7 +50159,7 @@ function* analysis(meta, events, transcript, shots) {
 			case "net": {
 				const n = 1 + (e.repeat ?? 0);
 				netTotal += n;
-				const page = pathOf(e.url);
+				const page = pathOf$1(e.url);
 				const route = normalizePath(page.split("?")[0]);
 				const key = `${e.method} ${route}`;
 				const ep = endpoints.get(key) ?? {
@@ -49798,6 +50718,16 @@ function stackSource(stack) {
 * from the analysis alone.
 */
 /** mm:ss from the start of the session. */
+/** What a restart of the studio during a recording did to it. */
+function restartWords(r) {
+	return r.resumed ? {
+		en: "the page recording it went on, and sent what it kept meanwhile, so nothing is missing.",
+		ar: "واصلت الصفحة التسجيل وأرسلت ما احتفظت به في أثناء ذلك، فلم يضع شيء."
+	} : {
+		en: "the recording ended there; nothing after it was recorded.",
+		ar: "انتهى التسجيل عندها، ولم يُسجَّل شيء بعدها."
+	};
+}
 function clock(t, start) {
 	const s = Math.max(0, Math.round((t - start) / 1e3));
 	return `${String(Math.floor(s / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
@@ -50009,6 +50939,7 @@ function evidencePack(input) {
 	if (meta.git) push(`Git: ${meta.git.branch} @ ${meta.git.commit}${meta.git.dirty ? " (uncommitted changes)" : ""}`);
 	push(`Pages: ${analysis.pages.map((p) => `${p.url} (${Math.round(p.ms / 1e3)} s)`).join(" → ") || "unknown"}`);
 	push(`Narration: ${analysis.transcript.length} sentences, language setting ${meta.lang}`);
+	for (const r of meta.restarts ?? []) push(`Studio restart at ${clock(r.at, t0)}: ${restartWords(r).en}`);
 	push("</session>");
 	const s = analysis.scores;
 	push("<scores computed=\"deterministically\">");
@@ -50183,7 +51114,7 @@ var MOMENTS = {
 /** When the screen was read: after which action, or at which moment; a page shown in full says which page. */
 function screenMoment(s) {
 	const when = s.after ? `after ${s.after.id ? `${s.after.id} ` : ""}${s.after.text}` : MOMENTS[s.moment] ?? "";
-	return s.diff ? when : `${pathOf(s.url)} ${when} (in full)`.replace(/\s+/g, " ");
+	return s.diff ? when : `${pathOf$1(s.url)} ${when} (in full)`.replace(/\s+/g, " ");
 }
 var SYSTEM = `You are a senior QA engineer and UX researcher reviewing a recorded test session of a web app that is under development. The tester used the app while talking out loud; the studio recorded every action, error, request and performance signal, transcribed the narration on-device, linked each sentence to what was being pointed at, and grouped issues automatically.
 
@@ -50547,6 +51478,14 @@ function localReport(meta, analysis, note, lang = "en") {
 		effort: "small"
 	});
 	const pages = analysis.pages.length;
+	const restarted = (meta.restarts ?? []).map((r) => ar ? `أُعيد تشغيل الاستوديو عند ${clock(r.at, meta.startedAt)}: ${restartWords(r).ar}` : `The studio restarted at ${clock(r.at, meta.startedAt)}: ${restartWords(r).en}`).join(" ");
+	if (restarted) note = note ? {
+		en: `${note.en} ${restarted}`,
+		ar: `${note.ar} ${restarted}`
+	} : {
+		en: restarted,
+		ar: restarted
+	};
 	const summary = ar ? `اختبار لمدة ${durationWordsAr(analysis.durationMs)} على ${arCount(pages, AR_UNITS.page)}. النقرات: ${counts.clicks}، الإدخالات: ${counts.inputs}، الجمل المنطوقة: ${analysis.transcript.length}. ${top.length ? `أهم مشكلة: ${title(top[0])}.` : "لم تُسجَّل أخطاء ولا طلبات فاشلة ولا علامات تعثّر."}${note ? ` ${note.ar}` : ""}` : `${durationWords(analysis.durationMs)} of testing across ${pages} page${pages === 1 ? "" : "s"}: ${counts.clicks} click${counts.clicks === 1 ? "" : "s"}, ${counts.inputs} input${counts.inputs === 1 ? "" : "s"} and ${analysis.transcript.length} spoken comment${analysis.transcript.length === 1 ? "" : "s"}. ${top.length ? `The most important problem: ${top[0].title}.` : "No errors, failed requests or signs of frustration were recorded."}${note ? ` ${note.en}` : ""}`;
 	const notes = (k) => (ar ? s[k].notesAr?.[0] ?? s[k].notes[0] : s[k].notes[0]) ?? "";
 	return {
@@ -50853,6 +51792,19 @@ function sendFile(res, file, type, range) {
 		stream.pipe(res);
 	});
 }
+/** This computer's own names: a page at 127.0.0.1:5173 is the app at localhost:5173. */
+var LOOPBACK = /^(localhost|127\.0\.0\.1|\[::1\])$/;
+/** Whether a page's origin is the address `url` is at (its scheme, port and name, any of this computer's names alike). */
+function sameAddress(url, from) {
+	try {
+		const a = new URL(url);
+		const b = new URL(from);
+		const port = (u) => u.port || (u.protocol === "https:" ? "443" : "80");
+		return a.protocol === b.protocol && port(a) === port(b) && (a.hostname === b.hostname || LOOPBACK.test(a.hostname) && LOOPBACK.test(b.hostname));
+	} catch {
+		return false;
+	}
+}
 function sessionRoutes(router, deps) {
 	const { speech } = deps;
 	const of = (id) => deps.forSession(id).sessions;
@@ -50863,14 +51815,28 @@ function sessionRoutes(router, deps) {
 	};
 	const origin = (raw) => String(raw.headers.host ? `http://${raw.headers.host}` : "");
 	/**
+	* Whether a page may start recording into the open app's sessions, or make the studio load its speech models: the
+	* studio's own page, or the open app's (at its own address, or the proxy's in front of it). Any other page on this
+	* computer could otherwise fill the app's history with what it likes, and have it reported on.
+	*/
+	const fromOpenApp = (raw) => {
+		if (sameOrigin(raw)) return true;
+		const from = typeof raw.headers.origin === "string" ? raw.headers.origin : "";
+		if (!from) return true;
+		const ws = deps.active();
+		return !!ws && [ws.env?.url, ws.frameUrl].some((url) => !!url && sameAddress(url, from));
+	};
+	/**
 	* Writing to a session (or following it) from an app's page takes the session's key, given to whoever started it:
 	* another page on this computer can't add to or read someone else's recording. The studio's own page needs none.
 	*/
 	const writer = (req) => {
-		if (sameOrigin(req.raw)) return;
-		if (!holdsKey(req, of(req.params.id), req.params.id)) throw new HttpError(403, "This page can’t write to that session.");
+		const sessions = of(req.params.id);
+		if (!sameOrigin(req.raw) && !holdsKey(req, sessions, req.params.id)) throw new HttpError(403, "This page can’t write to that session.");
+		sessions.resumed(req.params.id);
 	};
 	router.post("/sessions", (req) => {
+		if (!fromOpenApp(req.raw)) throw new HttpError(403, "Only the app open in the studio can record a session. Open this app in the studio first.");
 		const body = req.body ?? {};
 		const lang = LANGS.includes(body.lang) ? body.lang : "auto";
 		const replayOf = body.source === "replay" && typeof body.replayOf === "string" ? body.replayOf : void 0;
@@ -50908,7 +51874,8 @@ function sessionRoutes(router, deps) {
 		};
 	});
 	router.get("/sessions/active", (req) => {
-		const ws = deps.active();
+		const open = deps.active();
+		const ws = open?.sessions.active() ? open : deps.recording?.() ?? open;
 		const m = ws?.sessions.active() ?? null;
 		if (!sameOrigin(req.raw)) return {
 			session: m && {
@@ -51003,7 +51970,10 @@ function sessionRoutes(router, deps) {
 	router.put("/sessions/:id", (req) => {
 		const name = asString(req.body?.name, "name", 120).trim();
 		if (!name) throw new HttpError(400, "Name it something");
-		return { session: of(req.params.id).store.update(req.params.id, { name }) };
+		return { session: of(req.params.id).store.update(req.params.id, {
+			name,
+			renamed: true
+		}) };
 	});
 	router.delete("/sessions/:id", (req) => {
 		of(req.params.id).remove(req.params.id);
@@ -51114,6 +52084,7 @@ function sessionRoutes(router, deps) {
 		return speech.status();
 	});
 	router.post("/speech/warm", async (req) => {
+		if (!fromOpenApp(req.raw)) throw new HttpError(403, "Only the app open in the studio can do that.");
 		const mode = req.query.get("mode");
 		if (mode) {
 			const m = mode === "en" ? "en" : mode === "ar" ? "ar" : "auto";
@@ -51495,7 +52466,7 @@ var SessionStore = class {
 				hour: "2-digit",
 				minute: "2-digit"
 			})}`,
-			appUrl: input.appUrl,
+			appUrl: redactUrl(input.appUrl),
 			source: input.source,
 			...input.replayOf ? { replayOf: input.replayOf } : {},
 			lang: input.lang,
@@ -51602,6 +52573,27 @@ var SessionStore = class {
 		const st = this.open.get(meta.id);
 		if (st) st.dirty = false;
 	}
+	/**
+	* A recording's write key, kept beside it (only its owner can read it) so a studio that restarts still takes what
+	* the page recording it sends: that page alone was given it. Gone once the recording ends.
+	*/
+	saveKey(id, key) {
+		writeFileAtomic(path.join(this.dir(id), ".key"), key, {
+			mode: 384,
+			sync: false
+		});
+	}
+	savedKey(id) {
+		try {
+			const key = fs.readFileSync(path.join(this.dir(id), ".key"), "utf8").trim();
+			return /^[0-9a-f]{32}$/.test(key) ? key : null;
+		} catch {
+			return null;
+		}
+	}
+	dropKey(id) {
+		if (ID.test(id)) fs.rmSync(path.join(this.root, id, ".key"), { force: true });
+	}
 	/** Stop the timer and write what's pending (the studio is shutting down or restarting). */
 	close() {
 		clearInterval(this.saveTimer);
@@ -51653,10 +52645,10 @@ var SessionStore = class {
 			if (!e || typeof e !== "object" || typeof e.seq !== "number" || typeof e.t !== "number" || typeof e.type !== "string") continue;
 			if (seen.has(e.seq)) continue;
 			seen.add(e.seq);
-			fresh.push({
+			fresh.push(scrubEvent({
 				...e,
 				page
-			});
+			}));
 		}
 		st.lastActivity = Date.now();
 		if (!fresh.length) return fresh;
@@ -51912,7 +52904,7 @@ var SessionStore = class {
 	/** The report in the language spoken; a new one replaces its translation too. */
 	saveReport(id, r) {
 		const dir = this.dir(id);
-		writeFileAtomic(path.join(dir, "report.json"), JSON.stringify(r, null, 1));
+		writeFileAtomic(path.join(dir, "report.json"), masked(r));
 		for (const lang of ["en", "ar"]) fs.rmSync(path.join(dir, `report-${lang}.json`), { force: true });
 	}
 	report(id) {
@@ -51923,7 +52915,7 @@ var SessionStore = class {
 		}
 	}
 	saveTranslation(id, r) {
-		writeFileAtomic(path.join(this.dir(id), `report-${r.lang}.json`), JSON.stringify(r, null, 1));
+		writeFileAtomic(path.join(this.dir(id), `report-${r.lang}.json`), masked(r));
 	}
 	/** The report in the other language, once written. */
 	translation(id) {
@@ -51977,6 +52969,13 @@ var SessionStore = class {
 		}
 	}
 };
+/**
+* A report as it is kept: what the AI wrote may repeat a key or a card number it saw (an older plugin's screenshot,
+* a response body), and every text in it is masked before it is saved, shown, exported or sent anywhere.
+*/
+function masked(r) {
+	return JSON.stringify(r, (_key, value) => typeof value === "string" ? maskSecrets(value) : value, 1);
+}
 //#endregion
 //#region server/sessions/verify.ts
 /**
@@ -52027,6 +53026,30 @@ function requested(replay, endpoint) {
 	const want = normKey(endpoint);
 	return replay.network.endpoints.some((e) => normKey(`${e.method} ${e.url}`) === want);
 }
+/** The steps a replay plays, in order (as the studio's replayer picks them). */
+var playable = (a) => a.steps.filter((s) => s.kind !== "navigate" && !!s.locator);
+/** A session's reads of the screen were thinned to stay within a size: a read missing from them says nothing. */
+var thinned = (screens) => screens.length >= 140 || screens.reduce((n, s) => n + s.lines.reduce((m, l) => m + l.length + 1, 0), 0) > 5e4;
+/**
+* The step a problem came after, when it changed the screen the first time and changed nothing after the same step
+* in the replay: it was done, but it didn't do what it did. Whatever came of it then can't be judged from the replay.
+*/
+function noEffect(original, replay, issue) {
+	const steps = playable(original);
+	let i = -1;
+	for (let k = 0; k < steps.length && steps[k].t <= issue.t; k++) i = k;
+	if (i < 0) return null;
+	const step = steps[i];
+	const end = steps[i + 1]?.t ?? Infinity;
+	const screens = original.screens ?? [];
+	const at = screens.findIndex((s) => !!s.after && s.t > step.t && s.t < end);
+	if (at < 0) return null;
+	const again = replay.screens ?? [];
+	if (thinned(screens) || thinned(again)) return null;
+	const text = screens[at].after.text;
+	const nth = screens.slice(0, at).filter((s) => s.after?.text === text).length;
+	return again.filter((s) => s.after?.text === text)[nth] ? null : step;
+}
 function verifyIssues(original, replay, outcome) {
 	const failed = outcome.steps.failed;
 	const recorded = replay.pages.length > 0 || replay.timeline.length > 0;
@@ -52058,7 +53081,8 @@ function verifyIssues(original, replay, outcome) {
 			continue;
 		}
 		if (o.t >= reachedUntil && failed) {
-			out[o.id] = unknown(`The replay stopped before this: ${failed.description} (${replayReason(failed.reason, "en")}).`, `توقّفت الإعادة قبل هذا: ${failed.descriptionAr ?? failed.description} (${replayReason(failed.reason, "ar")}).`);
+			const stuck = failed.reason === "disabled" && /^(?:dead|disabled|rage):/.test(key) && o.t - failed.t < 3e3;
+			out[o.id] = stuck ? still(`It is still disabled: ${failed.description}.`, `ما زال معطّلًا: ${failed.descriptionAr ?? failed.description}.`) : unknown(`The replay stopped before this: ${failed.description} (${replayReason(failed.reason, "en")}).`, `توقّفت الإعادة قبل هذا: ${failed.descriptionAr ?? failed.description} (${replayReason(failed.reason, "ar")}).`);
 			continue;
 		}
 		if (key.startsWith("inp:") || key.startsWith("disabled:")) {
@@ -52075,6 +53099,11 @@ function verifyIssues(original, replay, outcome) {
 			out[o.id] = unknown("The replay didn’t make this request, so it couldn’t tell.", "لم ترسل الإعادة هذا الطلب، فلم تستطع الحكم.");
 			continue;
 		}
+		const idle = noEffect(original, replay, o);
+		if (idle) {
+			out[o.id] = unknown(`The step before it, ${idle.description}, changed nothing on screen in the replay (it did the first time), so it can’t tell.`, `الخطوة التي سبقته، ${idle.descriptionAr ?? idle.description}، لم تغيّر شيئًا على الشاشة في الإعادة (وغيّرت في المرة الأولى)، فتعذّر الحكم.`);
+			continue;
+		}
 		out[o.id] = fixed("It didn’t happen in the replay.", "لم يحدث في الإعادة.");
 	}
 	return out;
@@ -52416,6 +53445,8 @@ var scoresFrom = (s) => ({
 		notes: []
 	}
 });
+/** How long a recording found unfinished at startup waits for its page to come back (it retries every few seconds). */
+var RESUME_MS = 6e4;
 var Sessions = class {
 	deps;
 	store;
@@ -52436,16 +53467,56 @@ var Sessions = class {
 	notable = /* @__PURE__ */ new Map();
 	/** Each recording's key: an app's page writes to a session, and follows it, only with the key it was given. */
 	keys = /* @__PURE__ */ new Map();
+	/** Recordings found unfinished when the studio started: each finishes unless its page comes back in time. */
+	recovering = /* @__PURE__ */ new Map();
 	/** Per recording: when its last problem went out, and the newest one waiting to (see ISSUE_EVERY_MS). */
 	issueFrames = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 		this.store = new SessionStore(deps.project);
-		for (const m of this.store.list()) if (m.status === "recording" || m.status === "processing") this.finish(m.id, "Recovered after a restart");
+		for (const m of this.store.list()) if (m.status === "recording") this.recover(m);
+		else if (m.status === "processing") this.finish(m.id, "Recovered after a restart");
 	}
 	emit(live) {
 		this.deps.emit("session", live);
 	}
+	/**
+	* A session the studio was recording when it stopped. The page recording it keeps what it records while the
+	* studio is away, and sends it once the studio is back: for a while its key is taken again and the recording
+	* goes on. If nothing comes, it is finished with what it has, and its report says where it ended.
+	*/
+	recover(m) {
+		const key = this.store.savedKey(m.id);
+		if (!key) return void this.finish(m.id, "Recovered after a restart");
+		this.keys.set(m.id, key);
+		this.store.update(m.id, { restarts: [...m.restarts ?? [], {
+			at: Date.now(),
+			resumed: false
+		}] });
+		const timer = setTimeout(() => {
+			this.recovering.delete(m.id);
+			if (this.store.meta(m.id).status === "recording") this.finish(m.id, "Recovered after a restart");
+		}, RESUME_MS);
+		timer.unref?.();
+		this.recovering.set(m.id, timer);
+	}
+	/** The page recording a session sent something: after a restart, that recording goes on. */
+	resumed(id) {
+		const timer = this.recovering.get(id);
+		if (!timer) return;
+		clearTimeout(timer);
+		this.recovering.delete(id);
+		const restarts = this.store.meta(id).restarts ?? [];
+		this.store.update(id, { restarts: restarts.map((r, i) => i === restarts.length - 1 ? {
+			...r,
+			resumed: true
+		} : r) });
+		this.emit({
+			kind: "status",
+			id,
+			status: "recording"
+		});
+	}
 	active() {
 		return this.store.active();
 	}
@@ -52458,7 +53529,9 @@ var Sessions = class {
 		}
 		const meta = this.store.create(input);
 		this.segmentNo.set(meta.id, 0);
-		this.keys.set(meta.id, randomBytes(16).toString("hex"));
+		const key = randomBytes(16).toString("hex");
+		this.keys.set(meta.id, key);
+		this.store.saveKey(meta.id, key);
 		this.emit({
 			kind: "status",
 			id: meta.id,
@@ -52617,6 +53690,9 @@ var Sessions = class {
 	stop(id, endedAt) {
 		const meta = this.store.meta(id);
 		if (meta.status !== "recording") return meta;
+		const recovering = this.recovering.get(id);
+		if (recovering) clearTimeout(recovering);
+		this.recovering.delete(id);
 		const now = Date.now();
 		const end = typeof endedAt === "number" && endedAt >= meta.startedAt && endedAt <= now ? endedAt : now;
 		const updated = this.store.update(id, {
@@ -52649,6 +53725,7 @@ var Sessions = class {
 	async finish(id, note) {
 		if (this.processing.has(id)) return;
 		this.processing.add(id);
+		this.store.dropKey(id);
 		try {
 			const meta = this.store.meta(id);
 			if (meta.status === "recording" || !meta.endedAt) this.store.update(id, {
@@ -52988,6 +54065,8 @@ var Sessions = class {
 		this.countTimers.clear();
 		for (const f of this.issueFrames.values()) if (f.timer) clearTimeout(f.timer);
 		this.issueFrames.clear();
+		for (const t of this.recovering.values()) clearTimeout(t);
+		this.recovering.clear();
 		this.store.close();
 	}
 	remove(id) {
@@ -53274,11 +54353,13 @@ function mcpTools(deps) {
 				const w = open();
 				const c = deps.context.app === w.app.id ? deps.context : null;
 				const lines = [`App: ${w.app.name} (${w.env.label}: ${w.env.url})`, w.project.hasCode ? `Code: ${w.project.root}` : "Code: not on this computer (linked by address only)"];
-				if (c?.pageUrl) lines.push(`Page: ${c.pageUrl}`);
+				if (c?.pageUrl) lines.push(`Page: ${redactUrl(c.pageUrl)}`);
+				const key = (r) => `${r.src ?? ""}|${r.label}|${r.text}`;
+				const selected = new Set(c?.selection.map(key) ?? []);
 				const refs = c ? [...c.selection.map((r) => ({
 					...r,
 					role: "selected"
-				})), ...c.pins.map((r) => ({
+				})), ...c.pins.filter((r) => !selected.has(key(r))).map((r) => ({
 					...r,
 					role: "pinned"
 				}))] : [];
@@ -53289,7 +54370,7 @@ function mcpTools(deps) {
 				lines.push("", `Pointed at (${ago(c.at)}):`);
 				(await deps.mapRefs(refs, c?.pageUrl ?? void 0)).forEach((r, i) => {
 					const where = r.src ? ` at ${r.src}${r.guessed ? " (a guess: found by searching the code for its text, not reported by the app; check it)" : ""}` : " (not traced to a file)";
-					lines.push(`${i + 1}. ${refs[i].role}: ${r.label || r.name}${r.text ? ` showing “${r.text.slice(0, 80)}”` : ""}${where}`);
+					lines.push(`${i + 1}. ${refs[i].role}: ${maskSecrets(r.label || r.name)}${r.text ? ` showing “${maskSecrets(r.text).slice(0, 80)}”` : ""}${where}`);
 					const at = r.src ? parseSrc(r.src) : null;
 					if (at && w.project.hasCode && w.project.exists(at.file)) {
 						const text = w.project.read(at.file).split("\n");
@@ -53298,7 +54379,8 @@ function mcpTools(deps) {
 						lines.push("```", ...text.slice(from - 1, to).map((l, k) => `${String(from + k).padStart(4)}${from + k === at.line ? ">" : " "} ${l}`), "```");
 					}
 				});
-				if (c?.said) lines.push("", `Last said in the studio: “${c.said}”`);
+				const said = deps.context;
+				if (said.said && said.saidApp === w.app.id) lines.push("", `Last said in the studio (${ago(said.saidAt ?? said.at)}): “${maskSecrets(said.said)}”`);
 				return lines.join("\n");
 			}
 		},
@@ -54407,10 +55489,80 @@ function installSkills(root, skills) {
 	return written;
 }
 //#endregion
+//#region shared/steps.ts
+/**
+* Recorded steps as a test may hold them, the same in the studio's page and its server: a secret by its name only,
+* and a choice in a list as a choice. Steps an older plugin recorded (a password in clear, a list written as a
+* fill) are put right here, before anyone sees them.
+*/
+/** A secret's name as a test reads it: capitals, digits and underscores (PASSWORD, CARD_NUMBER). */
+var secretKey$2 = (name) => secretEnvName(name).slice(SECRET_ENV_PREFIX.length);
+/** The field a locator names, in words: `page.getByLabel('Password')` → Password. */
+function fieldWords(step) {
+	return `${Array.from((step.locator ?? "").matchAll(/'((?:[^'\\]|\\.)*)'/g), (m) => m[1]).join(" ")} ${/“([^”]*)”[^“]*$/.exec(step.description)?.[1] ?? ""}`;
+}
+/**
+* Steps as a test may hold them, whoever recorded them: a value typed into a field called like a secret (an older
+* plugin's “Type “hunter2” into the “Password” field”), or one that looks like a key or a card number, becomes a
+* secret by name with no value, and its description loses the value; a choice in a list an older plugin wrote as a
+* fill (“Choose …”) becomes a choice.
+*/
+function sanitizeSteps(steps) {
+	return steps.map((step) => {
+		if (step.kind !== "fill" || step.checked !== void 0) return step;
+		if (step.secret) return {
+			...step,
+			value: "",
+			secret: secretKey$2(step.secret)
+		};
+		if (!step.select && !step.values && /^Choose “/.test(step.description)) return {
+			...step,
+			values: [step.value ?? ""]
+		};
+		if (step.select || step.values) return step;
+		const words = fieldWords(step);
+		if (isSecretHint(words) || looksSecret(step.value ?? "")) {
+			const into = / into (.+)$/.exec(step.description)?.[1];
+			return {
+				...step,
+				value: "",
+				secret: secretKey$2(secretName(/'([^']*)'/.exec(step.locator ?? "")?.[1] ?? words)),
+				description: into ? `Type ${MASK} into ${into}` : `Type ${MASK}`
+			};
+		}
+		return {
+			...step,
+			value: maskSecrets(step.value ?? ""),
+			description: maskSecrets(step.description)
+		};
+	});
+}
+//#endregion
+//#region shared/text.ts
+/**
+* A check on a whole row receives "Total$78.40" when "$80.80" was expected:
+* pick out the part that has the same shape as the expectation.
+*/
+function focusOn(received, expected) {
+	if (!received || !expected || received === expected) return received;
+	const shape = expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\d+/g, "\\d+");
+	if (shape === expected || !/\\d\+/.test(shape)) return received;
+	return new RegExp(shape).exec(received)?.[0] ?? received;
+}
+/** What a check says should be, after the thing it is about: "should show “$80.80”", "should be checked". */
+function shouldBe(e, quote = (s) => `“${s}”`) {
+	if (e.field === "checked") return e.expected === "not checked" ? "should not be checked" : "should be checked";
+	if (e.field === "select") return `should have ${quote(e.expected)} chosen`;
+	return `should show ${quote(e.expected)}`;
+}
+//#endregion
 //#region server/tests/generate.ts
 /**
-* Writes a Playwright test from a recorded flow: its steps, and what the tester
-* said should show. Page text only ever goes into strings and comments, escaped.
+* Writes a Playwright test from a recorded flow: its steps and the checks the tester said, in the order they
+* happened. Page text only ever goes into strings and comments, escaped. Each step and each check is a test.step
+* numbered in the order it was written, so a run shows how far the test got, and which of them ran: a pass is only
+* believed when every one of them did. A secret is never written into the file: the test reads it from the
+* environment (SAYWRIGHT_SECRET_PASSWORD), where the studio puts what you saved for it.
 */
 /** What a locator may call, as the bridge writes them: finding, narrowing to a card or row, picking one. */
 var CALLS = /* @__PURE__ */ new Set([
@@ -54431,6 +55583,11 @@ var CALLS = /* @__PURE__ */ new Set([
 var STRING = /^'(?:[^'\\\r\n\u2028\u2029]|\\[^\r\n\u2028\u2029])*'/;
 var LITERAL = /^(?:-?\d+(?:\.\d+)?|true|false)/;
 /**
+* A regular expression literal as the bridge writes one, for a name or a text with its numbers left open
+* (`/^Pay \$\d[\d.,]* and subscribe$/`): one token as JavaScript reads it, so nothing in it runs either.
+*/
+var REGEX = /^\/(?![*/])(?:[^/\\[\r\n\u2028\u2029]|\\[^\r\n\u2028\u2029]|\[(?:[^\]\\\r\n\u2028\u2029]|\\[^\r\n\u2028\u2029])*\])+\/[imsu]*/;
+/**
 * Locators arrive as Playwright expressions built by the bridge, on one line; accept only that shape: `page`, then
 * calls whose arguments are strings, numbers and flat objects of them. Page text can only be inside those strings,
 * so whatever it says, nothing in it runs.
@@ -54451,7 +55608,7 @@ function isLocator(code) {
 	};
 	const value = (flat) => {
 		blank();
-		if (token(STRING) !== null || token(LITERAL) !== null) return true;
+		if (token(STRING) !== null || token(LITERAL) !== null || token(REGEX) !== null) return true;
 		if (flat || code[i] !== "{") return false;
 		i++;
 		for (;;) {
@@ -54492,45 +55649,162 @@ function testTitle(input) {
 	if (input.name?.trim()) return input.name.trim();
 	const e = input.expectations[0];
 	if (!e) return "narrated flow";
-	return `${e.description.replace(/^the /i, "")} should show ${e.expected}`;
+	return `${e.description.replace(/^the /i, "")} ${shouldBe(e, plain)}`;
+}
+var plain = (s) => s;
+/** A secret's name as the test reads it: capitals, digits and underscores (PASSWORD, CARD_NUMBER). */
+var secretKey$1 = (name) => secretEnvName(name).slice(SECRET_ENV_PREFIX.length);
+/** A page's address without its origin, as `page.goto` takes it with the config's baseURL. */
+function pathOf(url) {
+	try {
+		const u = new URL(url, "http://app.invalid");
+		return `${u.pathname}${u.search}${u.hash}` || "/";
+	} catch {
+		return "/";
+	}
 }
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+/**
+* What a page's address must look like to be the same page on another run: its path, with the parts that change
+* from one run to the next (numbers, ids) left open; the query and the hash are left out. A hash route (#/checkout)
+* is the path.
+*/
+function urlPattern(url) {
+	let u;
+	try {
+		u = new URL(url, "http://app.invalid");
+	} catch {
+		return ".*";
+	}
+	const body = (u.hash.startsWith("#/") ? u.hash.slice(1).split("?")[0] : u.pathname).split("/").map((p) => {
+		if (!p) return "";
+		const plain = decodeURIComponentSafe(p);
+		return /\d/.test(plain) && (/^\d+$/.test(plain) || /^[0-9a-f-]{8,}$/i.test(plain) || /^[\w-]{16,}$/.test(plain)) ? "[^/?#]+" : escapeRe(p);
+	}).join("/").replace(/\/$/, "") || "";
+	return u.hash.startsWith("#/") ? `^[^#]*#${body}/?(?:[?]|$)` : `^[a-z]+://[^/]+${body}/?(?:[?#]|$)`;
+}
+function decodeURIComponentSafe(s) {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+}
+/** How a step is done, as code. */
+function stepCode(step) {
+	switch (step.kind) {
+		case "click": return `await ${safeLocator(step.locator)}.click();`;
+		case "fill": {
+			const loc = safeLocator(step.locator);
+			if (step.secret) return `await ${loc}.fill(secret(${jsString(secretKey$1(step.secret))}));`;
+			if (step.checked !== void 0) return `await ${loc}.${step.checked ? "check" : "uncheck"}();`;
+			if (step.select || step.values) return `await ${loc}.selectOption(${optionsCode(step)});`;
+			return `await ${loc}.fill(${jsString(maskSecrets(step.value ?? ""))});`;
+		}
+		case "press": return `await ${safeLocator(step.locator)}.press(${jsString(step.key ?? "Enter")});`;
+		case "goto": return step.url ? `await page.goto(${jsString(pathOf(step.url))});` : null;
+		case "url": return step.url ? `await expect(page).toHaveURL(new RegExp(${jsString(urlPattern(step.url))}));` : null;
+		default: return null;
+	}
+}
+/**
+* The options a step chose, as selectOption takes them: by what each says ({ label: 'Express' }), or by its value
+* when what it says has numbers in it (a price changes, its value doesn't) or isn't known.
+*/
+function optionsCode(step) {
+	const labels = step.select ?? [];
+	const values = step.values ?? [];
+	const one = (i) => {
+		const label = labels[i] ?? "";
+		const value = values[i];
+		if (label && !/\d/.test(label)) return `{ label: ${jsString(label)} }`;
+		if (value !== void 0 && value !== "") return jsString(value);
+		return `{ label: ${jsString(label)} }`;
+	};
+	const count = Math.max(labels.length, values.length);
+	if (count <= 1) return count ? one(0) : "[]";
+	return `[${Array.from({ length: count }, (_, i) => one(i)).join(", ")}]`;
+}
+/**
+* A check, as code: text for most things, the value for a field, whether a checkbox is checked, the options chosen in
+* a list (one of them says it, however many are chosen).
+*/
+function checkCode(e) {
+	const loc = safeLocator(e.locator);
+	if (e.field === "checked") return `await expect(${loc}).${e.expected === "not checked" ? "not." : ""}toBeChecked();`;
+	if (e.field === "value") return `await expect(${loc}).toHaveValue(new RegExp(${jsString(escapeRe(e.expected))}));`;
+	if (e.field === "select") return `await expect(${loc}.locator('option:checked')).toContainText([${jsString(e.expected)}]);`;
+	return `await expect(${loc}).toContainText(${jsString(e.expected)});`;
+}
+/** A step title: its number (what a run is checked against) and its words, on one line. */
+var title = (mark, words) => jsString(`[${mark}] ${words.replace(/\s+/g, " ").trim().slice(0, 160)}`);
 function generateSpec(input, date = /* @__PURE__ */ new Date()) {
-	const url = new URL(input.startUrl);
-	const start = `${url.pathname}${url.search}${url.hash}` || "/";
+	const start = pathOf(input.startUrl);
+	const secrets = [...new Set(input.steps.filter((s) => s.kind === "fill" && s.secret).map((s) => secretKey$1(s.secret)))];
 	const lines = [];
 	lines.push(`import { expect, test } from '@playwright/test';`, "");
-	lines.push(`// Narrated with ${BRAND.name} on ${date.toISOString().slice(0, 10)}. Expectations come from what was said.`);
+	lines.push(`// Narrated with ${BRAND.name} on ${date.toISOString().slice(0, 10)}: the steps you took and the checks you said, in that order.`);
+	lines.push(`// Each is a test.step, so a run shows how far it got. It starts from a fresh browser, with no cookies or storage.`);
+	if (secrets.length) {
+		lines.push(`// Secrets are never written here: it types ${secrets.join(", ")} from ${secrets.map((s) => secretEnvName(s)).join(", ")}`);
+		lines.push(`// (${BRAND.name} sets the ones you saved in its Test tab; elsewhere, set them in the environment).`);
+		lines.push(`function secret(name: string): string {`);
+		lines.push(`  const value = process.env[\`${SECRET_ENV_PREFIX}\${name}\`];`);
+		lines.push(`  if (!value) throw new Error(\`This test needs ${SECRET_ENV_PREFIX}\${name}: set it in the environment, or save it in ${BRAND.name}'s Test tab.\`);`);
+		lines.push(`  return value;`);
+		lines.push(`}`);
+	}
+	lines.push("");
 	lines.push(`test(${jsString(testTitle(input))}, async ({ page }) => {`);
-	lines.push(`  await page.goto(${jsString(start)});`);
-	for (const step of input.steps) switch (step.kind) {
-		case "click":
-			lines.push(`  await ${safeLocator(step.locator)}.click();`);
-			break;
-		case "fill":
-			if (step.checked !== void 0) lines.push(`  await ${safeLocator(step.locator)}.${step.checked ? "check" : "uncheck"}();`);
-			else lines.push(`  await ${safeLocator(step.locator)}.fill(${jsString(step.value ?? "")});`);
-			break;
-		case "press":
-			lines.push(`  await ${safeLocator(step.locator)}.press(${jsString(step.key ?? "Enter")});`);
-			break;
-		case "goto":
-			if (step.url) {
-				const u = new URL(step.url);
-				lines.push(`  await page.goto(${jsString(`${u.pathname}${u.search}${u.hash}`)});`);
-			}
-			break;
-		case "note": lines.push(`  // ${jsComment(step.description)}`);
-	}
+	let n = 0;
+	let k = 0;
+	const step = (mark, words, body) => {
+		lines.push(`  await test.step(${title(mark, words)}, async () => {`);
+		for (const b of body) lines.push(`    ${b}`);
+		lines.push(`  });`);
+	};
+	step(String(++n), `Open ${start}`, [`await page.goto(${jsString(start)});`]);
+	const checksAt = /* @__PURE__ */ new Map();
 	for (const e of input.expectations) {
-		lines.push(`  // ${jsComment(`You said ${e.description} should show ${e.expected} (it showed ${e.actual || "nothing"}).`)}`);
-		lines.push(`  await expect(${safeLocator(e.locator)}).toContainText(${jsString(e.expected)});`);
+		const at = Math.max(0, Math.min(input.steps.length, e.after ?? input.steps.length));
+		checksAt.set(at, [...checksAt.get(at) ?? [], e]);
 	}
+	const check = (e) => {
+		const was = e.field === "checked" ? `it was ${e.actual || "not checked"}` : `it showed ${e.actual || "nothing"}`;
+		step(`check ${++k}`, maskSecrets(`${e.description.replace(/^./, (c) => c.toUpperCase())} ${shouldBe(e, plain)}`), [`// ${jsComment(maskSecrets(`You said ${e.description} ${shouldBe(e, plain)} (${was}).`))}`, checkCode(e)]);
+	};
+	input.steps.forEach((s, i) => {
+		for (const e of checksAt.get(i) ?? []) check(e);
+		if (s.kind === "note") {
+			lines.push(`  // ${jsComment(maskSecrets(s.description))}`);
+			return;
+		}
+		const code = stepCode(s);
+		if (code) step(String(++n), maskSecrets(s.description), [code]);
+	});
+	for (const e of checksAt.get(input.steps.length) ?? []) check(e);
 	lines.push("});", "");
 	return lines.join("\n");
 }
-function writeSpec(project, input) {
+/** The secrets a test types (by name), as its code reads them. */
+function secretsOf(code) {
+	return [...new Set(Array.from(code.matchAll(/\bsecret\('([A-Z0-9_]+)'\)/g), (m) => m[1]))];
+}
+/**
+* Write the test to `tests/saywright/`, never over a file of someone else's. `replace`: the test this one is a new
+* version of (written again after another check was added): it takes that file's place when the studio wrote it and
+* nobody changed it since, rather than leaving both to run.
+*/
+function writeSpec(project, input, replace) {
 	const code = generateSpec(input);
 	const dir = `tests/${BRAND.slug}`;
+	if (replace && replace.path.startsWith(`${dir}/`) && /^[\w./-]+\.spec\.ts$/.test(replace.path) && !replace.path.includes("..") && project.exists(replace.path) && project.read(replace.path) === replace.code) {
+		project.write(replace.path, code);
+		return {
+			path: replace.path,
+			code
+		};
+	}
 	const base = slug(testTitle(input));
 	let rel = `${dir}/${base}.spec.ts`;
 	for (let i = 2; project.exists(rel); i++) rel = `${dir}/${base}-${i}.spec.ts`;
@@ -54542,19 +55816,18 @@ function writeSpec(project, input) {
 	};
 }
 //#endregion
-//#region shared/text.ts
+//#region server/tests/run.ts
 /**
-* A check on a whole row receives "Total$78.40" when "$80.80" was expected:
-* pick out the part that has the same shape as the expectation.
+* Runs a generated test with Playwright, and says what the run proves. The test runs with a configuration of the
+* studio's own (kept with the studio's data, never in the app's code): Chromium, no retries, no web server of its
+* own (the app the studio has open is the one tested), a fresh browser, and a JSON report. The app's own Playwright
+* configuration can't change the verdict (its retries, its browsers, its other tests), but its setup can come along:
+* a `tests/saywright/setup.ts` runs first, to put the data the test needs in place.
+*
+* A pass is believed only when every step and check of the test reported that it ran and passed, on the first try,
+* and the test is the one it is compared with. A failure says where: at a check (the bug shows) or at an earlier
+* step (the test didn't get that far: it doesn't show the bug yet).
 */
-function focusOn(received, expected) {
-	if (!received || !expected || received === expected) return received;
-	const shape = expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\d+/g, "\\d+");
-	if (shape === expected || !/\\d\+/.test(shape)) return received;
-	return new RegExp(shape).exec(received)?.[0] ?? received;
-}
-//#endregion
-//#region server/tests/run.ts
 var ANSI = /\x1b\[[0-9;]*m/g;
 function playwrightCli(project) {
 	try {
@@ -54603,8 +55876,9 @@ function run(cmd, cwd, env, timeoutMs, onLine) {
 		});
 	});
 }
+/** Every test's runs (retries included), in the order the report lists them. */
 function collect(suite, out) {
-	for (const spec of suite.specs ?? []) for (const t of spec.tests) if (t.results.length) out.push(t.results[t.results.length - 1]);
+	for (const spec of suite.specs ?? []) for (const t of spec.tests) out.push(t.results);
 	for (const s of suite.suites ?? []) collect(s, out);
 }
 function parseFailure(message) {
@@ -54617,64 +55891,244 @@ function parseFailure(message) {
 	};
 }
 var NEEDS_BROWSER = /Executable doesn't exist|download new browsers|npx playwright install/i;
-async function runSpec(project, rel, baseUrl) {
-	project.resolve(rel);
+/** A step or check of a generated test, by the mark its title starts with. */
+var MARK = /^\[(\d+|check \d+)\] /;
+/** The steps and checks a test has, as its code names them (in order). */
+function marksOf(code) {
+	return Array.from(code.matchAll(/\btest\.step\('\[(\d+|check \d+)\] /g), (m) => m[1]);
+}
+/** A short fingerprint of a test's code: a later run compares it, to know the test is the same one. */
+var hashOf = (code) => createHash("sha256").update(code).digest("hex").slice(0, 16);
+/** The values of secrets, masked out of what a run says (its errors and output). */
+/** What a run says, without the saved secrets' values, and without any key or card number the page showed (it goes to the AI with Fix with …). */
+function masker(values) {
+	const all = values.filter((v) => v.length >= 3).sort((a, b) => b.length - a.length);
+	return (text) => text === void 0 ? text : maskSecrets(all.reduce((t, v) => t.split(v).join(MASK), text));
+}
+/**
+* What a run proves. `steps`: what the report says of each step and check; `marks`: what the test has. A pass with
+* a step or check missing from the report proves nothing about it.
+*/
+function judge(result, marks, mask) {
+	const steps = (result.steps ?? []).filter((s) => MARK.test(s.title)).map((s) => ({
+		title: mask(s.title),
+		check: /^\[check /.test(s.title),
+		ok: !s.error,
+		error: s.error?.message ? mask(s.error.message.replace(ANSI, "").slice(0, 1200)) : void 0
+	}));
+	const seen = new Set(steps.map((s) => MARK.exec(s.title)[1]));
+	const isCheck = (m) => m.startsWith("check ");
+	const counts = {
+		steps: marks.filter((m) => !isCheck(m)).length,
+		checks: marks.filter(isCheck).length,
+		stepsPassed: steps.filter((s) => !s.check && s.ok).length,
+		checksPassed: steps.filter((s) => s.check && s.ok).length
+	};
+	if (result.status === "passed") {
+		const missing = marks.filter((m) => !seen.has(m));
+		if (!marks.length) return {
+			status: "passed",
+			verified: false,
+			unverified: "This test has no numbered steps (an older version of Saywright wrote it, or it was written by hand), so a pass can’t show that each step and check ran. Generate it again.",
+			steps,
+			counts
+		};
+		if (!counts.checks) return {
+			status: "passed",
+			verified: false,
+			unverified: "This test has no check, so a pass only shows its steps ran.",
+			steps,
+			counts
+		};
+		if (missing.length) return {
+			status: "passed",
+			verified: false,
+			unverified: `The test passed, but ${missing.length === 1 ? "a step" : `${missing.length} steps`} of it didn’t report running (${missing.map((m) => `[${m}]`).join(", ")}).`,
+			steps,
+			counts
+		};
+		if ((result.retry ?? 0) > 0) return {
+			status: "passed",
+			verified: false,
+			unverified: "The test passed only when tried again.",
+			steps,
+			counts
+		};
+		return {
+			status: "passed",
+			verified: true,
+			steps,
+			counts
+		};
+	}
+	if (result.status === "skipped") return {
+		status: "error",
+		message: "The test was skipped, so it shows nothing.",
+		steps,
+		counts
+	};
+	const failing = steps.find((s) => !s.ok);
+	const message = mask((failing?.error ?? result.error?.message ?? result.errors?.[0]?.message ?? result.status).replace(ANSI, ""));
+	return {
+		status: "failed",
+		failedAt: failing?.check ? "check" : "step",
+		message: message.slice(0, 1200),
+		steps,
+		counts
+	};
+}
+/** A value as JavaScript source: the studio's configuration is written as a module with no imports. */
+var js = (v) => JSON.stringify(v);
+async function runSpec(project, rel, opts) {
+	const file = project.resolve(rel);
 	const started = Date.now();
+	let code;
+	try {
+		code = fs.readFileSync(file, "utf8");
+	} catch {
+		return {
+			status: "error",
+			durationMs: 0,
+			message: `${rel} isn’t there any more.`
+		};
+	}
+	const hash = hashOf(code);
 	const env = {
 		...process.env,
-		SAYWRIGHT_TARGET_URL: baseUrl,
-		FORCE_COLOR: "0",
-		CI: "1"
+		SAYWRIGHT_TARGET_URL: opts.baseUrl,
+		FORCE_COLOR: "0"
 	};
-	const { code, stdout, stderr } = await run([
-		...playwrightCli(project),
-		"test",
-		rel,
-		"--reporter=json",
-		"--workers=1"
-	], project.root, env, 12e4);
-	const durationMs = Date.now() - started;
-	const all = `${stdout}\n${stderr}`;
-	if (NEEDS_BROWSER.test(all)) return {
-		status: "setup-needed",
-		durationMs,
-		message: "Playwright needs its Chromium browser (one-time, about 150 MB)."
-	};
-	if (/Cannot find module '@playwright\/test'|Cannot find package '@playwright\/test'/.test(all)) return {
+	delete env.CI;
+	const values = [];
+	const missingSecrets = [];
+	for (const name of secretsOf(code)) {
+		const v = opts.secrets?.[name] || process.env[secretEnvName(name)];
+		if (v) {
+			env[secretEnvName(name)] = v;
+			values.push(v);
+		} else missingSecrets.push(name);
+	}
+	if (missingSecrets.length) return {
 		status: "setup-needed",
-		durationMs,
-		message: `This project needs @playwright/test. Run: ${fs.existsSync(path.join(project.root, "pnpm-lock.yaml")) ? "pnpm add -D" : fs.existsSync(path.join(project.root, "yarn.lock")) ? "yarn add -D" : fs.existsSync(path.join(project.root, "bun.lockb")) || fs.existsSync(path.join(project.root, "bun.lock")) ? "bun add -d" : "npm i -D"} @playwright/test`
+		durationMs: 0,
+		hash,
+		missingSecrets,
+		message: `This test types ${missingSecrets.join(", ")}. Save ${missingSecrets.length > 1 ? "them" : "it"} in the Test tab (kept on this computer only, never in the test), or set ${missingSecrets.map((n) => secretEnvName(n)).join(", ")}.`
 	};
-	let report;
+	const mask = masker(values);
+	fs.mkdirSync(opts.workDir, {
+		recursive: true,
+		mode: 448
+	});
+	sweepRuns(opts.workDir);
+	const id = `${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+	const configFile = path.join(opts.workDir, `run-${id}.config.mjs`);
+	const reportFile = path.join(opts.workDir, `run-${id}.json`);
+	const outputDir = path.join(opts.workDir, `run-${id}`);
+	const setup = [
+		"setup.ts",
+		"setup.mjs",
+		"setup.js"
+	].map((f) => path.join(path.dirname(file), f)).find((f) => fs.existsSync(f));
+	const chromium = process.env.PW_CHROMIUM_PATH;
+	fs.writeFileSync(configFile, `// Written by Saywright for one run of ${js(rel)}; removed after it.
+export default {
+  testDir: ${js(path.dirname(file))},
+  testMatch: ${js(path.basename(file))},
+  outputDir: ${js(outputDir)},
+  retries: 0,
+  workers: 1,
+  timeout: 60000,
+  expect: { timeout: 10000 },
+  reporter: [['json', { outputFile: ${js(reportFile)} }]],
+${setup ? `  globalSetup: ${js(setup)},\n` : ""}  use: {
+    baseURL: ${js(opts.baseUrl)},
+    browserName: 'chromium',
+    actionTimeout: 15000,
+    navigationTimeout: 30000,
+${chromium ? `    launchOptions: { executablePath: ${js(chromium)} },\n` : ""}  },
+};
+`);
 	try {
-		report = JSON.parse(stdout.slice(stdout.indexOf("{")));
-	} catch {
-		return {
+		const { code: exit, stdout, stderr } = await run([
+			...playwrightCli(project),
+			"test",
+			"--config",
+			configFile
+		], project.root, env, 18e4);
+		const durationMs = Date.now() - started;
+		const all = mask(`${stdout}\n${stderr}`).replace(ANSI, "");
+		if (NEEDS_BROWSER.test(all)) return {
+			status: "setup-needed",
+			durationMs,
+			hash,
+			message: "Playwright needs its Chromium browser (one-time, about 150 MB)."
+		};
+		if (/Cannot find module '@playwright\/test'|Cannot find package '@playwright\/test'/.test(all)) return {
+			status: "setup-needed",
+			durationMs,
+			hash,
+			message: `This project needs @playwright/test. Run: ${fs.existsSync(path.join(project.root, "pnpm-lock.yaml")) ? "pnpm add -D" : fs.existsSync(path.join(project.root, "yarn.lock")) ? "yarn add -D" : fs.existsSync(path.join(project.root, "bun.lockb")) || fs.existsSync(path.join(project.root, "bun.lock")) ? "bun add -d" : "npm i -D"} @playwright/test`
+		};
+		let report;
+		try {
+			report = JSON.parse(fs.readFileSync(reportFile, "utf8"));
+		} catch {
+			return {
+				status: "error",
+				durationMs,
+				hash,
+				message: "Couldn’t read the test results.",
+				output: all.slice(-2e3)
+			};
+		}
+		const runs = [];
+		for (const s of report.suites ?? []) collect(s, runs);
+		const first = runs.find((r) => r.length)?.[0];
+		if (!first) return {
 			status: "error",
 			durationMs,
-			message: "Couldn’t read the test results.",
-			output: all.replace(ANSI, "").slice(-2e3)
+			hash,
+			message: mask(report.errors?.[0]?.message?.replace(ANSI, "") ?? `Playwright exited with code ${exit}`).slice(0, 600)
+		};
+		const verdict = judge(first, marksOf(code), mask);
+		const out = {
+			durationMs,
+			hash,
+			...verdict
 		};
+		if (verdict.status === "failed" && verdict.message) Object.assign(out, parseFailure(verdict.message));
+		if (out.verified && opts.baseline && opts.baseline !== hash) {
+			out.verified = false;
+			out.unverified = "The test changed since it failed, so its passing doesn’t show the bug is fixed. Run it once more to judge the test as it is now.";
+		}
+		return out;
+	} finally {
+		for (const f of [configFile, reportFile]) fs.rmSync(f, { force: true });
+		fs.rmSync(outputDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** A run cut short (the studio stopped meanwhile) leaves its files: its configuration, and Playwright's notes, which hold the pages' addresses. Gone the next time. */
+var LEFT_OVER_MS = 18e5;
+function sweepRuns(dir) {
+	let names;
+	try {
+		names = fs.readdirSync(dir).filter((n) => /^run-[a-z0-9]+-[0-9a-f]{6}(?:\.config\.mjs|\.json)?$/.test(n));
+	} catch {
+		return;
+	}
+	for (const n of names) {
+		const p = path.join(dir, n);
+		try {
+			if (Date.now() - fs.statSync(p).mtimeMs > LEFT_OVER_MS) fs.rmSync(p, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
 	}
-	const results = [];
-	for (const s of report.suites ?? []) collect(s, results);
-	if (!results.length) return {
-		status: "error",
-		durationMs,
-		message: (report.errors?.[0]?.message?.replace(ANSI, "") ?? `Playwright exited with code ${code}`).slice(0, 600)
-	};
-	const failed = results.find((r) => r.status !== "passed" && r.status !== "skipped");
-	if (!failed) return {
-		status: "passed",
-		durationMs
-	};
-	const message = (failed.error?.message ?? failed.errors?.[0]?.message ?? failed.status).replace(ANSI, "");
-	return {
-		status: "failed",
-		durationMs,
-		message: message.slice(0, 1200),
-		...parseFailure(message)
-	};
 }
 async function installBrowser(project, onLine) {
 	const { code } = await run([
@@ -54685,6 +56139,57 @@ async function installBrowser(project, onLine) {
 	return code === 0;
 }
 //#endregion
+//#region server/tests/secrets.ts
+/**
+* The values of the secrets an app's tests type (PASSWORD, CARD_NUMBER…), saved when you choose to, so the studio
+* can run its tests and replay its sessions. Kept with the studio's data, outside every app's code (no AI tool and
+* no commit reaches them), in a file only you can read. A test never holds one: it reads SAYWRIGHT_SECRET_PASSWORD,
+* which the studio sets from here when it runs it.
+*/
+/** A secret's name as tests use it: PASSWORD, CARD_NUMBER. */
+var secretKey = (name) => secretEnvName(name).slice(SECRET_ENV_PREFIX.length);
+var TestSecrets = class {
+	file;
+	constructor(file) {
+		this.file = file;
+	}
+	read() {
+		const saved = readJson$1(this.file);
+		const out = {};
+		for (const [k, v] of Object.entries(saved ?? {})) if (typeof v === "string" && v) out[secretKey(k)] = v;
+		return out;
+	}
+	/** The values, by name (only the studio's server ever reads them all). */
+	all() {
+		return this.read();
+	}
+	/** Which secrets have a value, saved here or in the environment the studio was started in. */
+	names() {
+		const environment = Object.keys(process.env).filter((k) => k.startsWith("SAYWRIGHT_SECRET_") && process.env[k]).map((k) => k.slice(SECRET_ENV_PREFIX.length));
+		return {
+			saved: Object.keys(this.read()).sort(),
+			environment: environment.sort()
+		};
+	}
+	/** Save a value (an empty one forgets it). */
+	set(name, value) {
+		const all = this.read();
+		const key = secretKey(name);
+		if (value) all[key] = value;
+		else delete all[key];
+		fs.mkdirSync(path.dirname(this.file), {
+			recursive: true,
+			mode: 448
+		});
+		writeFileAtomic(this.file, JSON.stringify(all, null, 2), { mode: 384 });
+	}
+	/** The value a replay types for this name: saved here, else from the environment. */
+	get(name) {
+		const key = secretKey(name);
+		return this.read()[key] || process.env["SAYWRIGHT_SECRET_" + key] || void 0;
+	}
+};
+//#endregion
 //#region server/index.ts
 var DEFAULT_SETTINGS = {};
 async function discoverRoot(url) {
@@ -54841,6 +56346,7 @@ async function createStudioApi(layout) {
 			console.warn(`[saywright] ${targetUrl}: ${err instanceof Error ? err.message : err}`);
 		}
 	}
+	apps.restoreRecordings();
 	const status = () => {
 		const w = apps.active();
 		const project = w?.project;
@@ -54889,6 +56395,20 @@ async function createStudioApi(layout) {
 		return w ? new Tracer(w.project, w.mapper) : null;
 	};
 	const toSource = async (src) => await tracer()?.toSource(src) ?? null;
+	/** Where a component is used in the app's code (`<Card …`), its tests and stories left out; a quick look, at most USES_LIMIT. */
+	const USES_LIMIT = 20;
+	const usesOf = async (project, component) => {
+		try {
+			const found = await project.search(`<${component.replace(/\$/g, "\\$")}[\\s/>]`, {
+				regex: true,
+				limit: 40,
+				budgetMs: 400
+			});
+			return Math.min(USES_LIMIT, found.hits.filter((h) => !/\.(test|spec|stories)\.[jt]sx?$/.test(h.path)).length);
+		} catch {
+			return 0;
+		}
+	};
 	/** Each ref's source location: as the page said (mapped from bundles), or found in the code by what identifies it (a guess). */
 	const mapRefs = async (raw, pageUrl) => {
 		const list = Array.isArray(raw) ? raw.slice(0, 6) : [];
@@ -54918,6 +56438,7 @@ async function createStudioApi(layout) {
 	sessionRoutes(router, {
 		active: () => apps.active(),
 		forSession: (id) => apps.forSession(id),
+		recording: () => apps.all().find((w) => !!w.sessions.active()) ?? null,
 		speech,
 		saveSpeechChoice: (lang, id) => {
 			settings.speech = {
@@ -54961,10 +56482,19 @@ async function createStudioApi(layout) {
 		});
 		const current = ws();
 		const { project, changes, metrics } = current;
-		context.said = text;
+		if (!brief) Object.assign(context, {
+			said: text,
+			saidApp: current.app.id,
+			saidAt: Date.now()
+		});
 		if (!project.hasCode) return addressOnly(current.app.name);
 		const quick = brief || body.ai === true ? null : quickEdit(text, refs, project);
 		if (quick?.kind === "edit") {
+			const uses = quick.component ? await usesOf(project, quick.component) : 0;
+			if (uses > 1) {
+				if (!refs[0]?.same) quick.title += ` · ${quick.component} is used in ${uses}${uses >= USES_LIMIT ? "+" : ""} places`;
+				quick.summary += ` ${quick.component} is used in ${uses}${uses >= USES_LIMIT ? " or more" : ""} places in your code: it changes in all of them.`;
+			}
 			const change = await changes.preview({
 				title: quick.title,
 				summary: quick.summary,
@@ -55198,16 +56728,24 @@ async function createStudioApi(layout) {
 			guessed: true
 		} : result };
 	});
+	/** The secrets this app's tests type, saved on this computer for runs and replays (with the studio's data, outside the app). */
+	const secretsOf = (w) => new TestSecrets(path.join(dataDir, "secrets", `${w.app.id}.json`));
+	/** Where a test run's configuration and report go: the studio's data, never the app's code. */
+	const runsDir = (w) => path.join(dataDir, "test-runs", w.app.id);
 	router.post("/tests/generate", (req) => {
 		const body = req.body ?? {};
 		if (!Array.isArray(body.expectations) || !body.expectations.length) throw new HttpError(400, "Say what you expected first");
 		const { project, metrics } = ws();
+		if (!project.hasCode) throw new HttpError(409, "A test is saved with your app’s code, and this app has none on this computer: link its folder to write tests.", "no-code");
 		const spec = writeSpec(project, {
 			name: body.name,
 			startUrl: typeof body.startUrl === "string" ? body.startUrl : project.url,
-			steps: Array.isArray(body.steps) ? body.steps.slice(0, 100) : [],
+			steps: sanitizeSteps(Array.isArray(body.steps) ? body.steps.slice(0, 100) : []),
 			expectations: body.expectations.slice(0, 20)
-		});
+		}, typeof body.replace?.path === "string" && typeof body.replace.code === "string" ? {
+			path: body.replace.path,
+			code: body.replace.code
+		} : void 0);
 		metrics.record({
 			type: "test-generated",
 			path: spec.path,
@@ -55216,17 +56754,47 @@ async function createStudioApi(layout) {
 		return spec;
 	});
 	router.post("/tests/run", async (req) => {
-		const rel = asString(req.body?.path, "path", 300);
-		const { project, metrics } = ws();
-		const result = await runSpec(project, rel, project.url);
+		const body = req.body ?? {};
+		const rel = asString(body.path, "path", 300);
+		const baseline = typeof body.baseline === "string" ? body.baseline.slice(0, 64) : void 0;
+		const current = ws();
+		const { project, metrics } = current;
+		const result = await runSpec(project, rel, {
+			baseUrl: project.url,
+			workDir: runsDir(current),
+			secrets: secretsOf(current).all(),
+			baseline
+		});
 		metrics.record({
 			type: "test",
 			path: rel,
 			status: result.status,
-			durationMs: result.durationMs
+			durationMs: result.durationMs,
+			verified: result.verified ?? false
 		});
 		return result;
 	});
+	router.get("/tests/secrets", () => secretsOf(ws()).names());
+	router.put("/tests/secrets", (req) => {
+		const body = req.body ?? {};
+		const name = secretKey(asString(body.name, "name", 60));
+		const value = body.value === void 0 ? "" : asString(body.value, "value", 4e3);
+		const store = secretsOf(ws());
+		store.set(name, value);
+		return store.names();
+	});
+	router.post("/tests/secrets/values", (req) => {
+		const names = req.body?.names;
+		if (!Array.isArray(names)) throw new HttpError(400, "Expected { names }");
+		const store = secretsOf(ws());
+		const out = {};
+		for (const n of names.slice(0, 20)) {
+			if (typeof n !== "string") continue;
+			const v = store.get(n);
+			if (v) out[secretKey(n)] = v;
+		}
+		return { values: out };
+	});
 	router.post("/tests/install", async () => {
 		return { ok: await installBrowser(ws().project, (line) => hub.emit("install", { line })) };
 	});
@@ -55255,13 +56823,14 @@ async function createStudioApi(layout) {
 		inflight.set(requestId, ctl);
 		const started = Date.now();
 		try {
+			const testCode = project.read(rel);
 			const out = await agent.run({
 				text: text || "Fix the bug this test shows.",
 				refs: await mapRefs(body.refs),
 				mode: "fix",
 				test: {
 					path: rel,
-					code: project.read(rel),
+					code: testCode,
 					failure
 				}
 			}, {
@@ -55271,13 +56840,33 @@ async function createStudioApi(layout) {
 			});
 			const latencyMs = Date.now() - started;
 			if (out.kind === "change") {
+				const normalized = (p) => p.replace(/\\/g, "/").replace(/^\.\//, "");
+				const kept = out.edits.filter((e) => normalized(e.path) !== normalized(rel));
+				const dropped = out.edits.length - kept.length;
+				if (!kept.length) {
+					metrics.record({
+						type: "command",
+						text: text || "fix it",
+						input,
+						result: "refused",
+						source: agent.source,
+						latencyMs,
+						fix: true
+					});
+					return {
+						kind: "message",
+						tone: "warn",
+						text: `${aiLabel()} only changed the test, not your app. A fix is checked against the test as you recorded it, so that change was left out. If the test itself is wrong, record it again or edit it yourself.`
+					};
+				}
+				const summary = dropped ? `${out.summary}\n\nIt also changed the test it is checked against; that part was left out, so the test still checks what you recorded.` : out.summary;
 				const change = await changes.preview({
 					title: out.title,
-					summary: out.summary,
+					summary,
 					said: text || "fix it",
 					source: agent.source,
 					model,
-					edits: out.edits,
+					edits: kept,
 					latencyMs
 				});
 				metrics.record({
@@ -55441,7 +57030,11 @@ async function createStudioApi(layout) {
 		context.pageUrl = pageUrl;
 		context.selection = selection;
 		context.pins = pins;
-		if (typeof body.said === "string") context.said = body.said.slice(0, 500);
+		if (typeof body.said === "string") Object.assign(context, {
+			said: body.said.slice(0, 500),
+			saidApp: context.app,
+			saidAt: Date.now()
+		});
 		context.at = Date.now();
 		return { ok: true };
 	});
@@ -55619,7 +57212,7 @@ async function createStudioApi(layout) {
 }
 /**
 * Everything the studio serves besides its interface: the API, the script that makes apps pointable, the
-* accessibility checks, and the WebAssembly runtimes for hand tracking and speech. Vite (`npm run dev`) and the
+* accessibility checks, and the WebAssembly runtime for on-device speech. Vite (`npm run dev`) and the
 * standalone server (`npx @saywright/studio`) mount the same list.
 */
 function studioRoutes(studio, layout) {
@@ -55661,7 +57254,6 @@ function studioRoutes(studio, layout) {
 			return null;
 		}
 	};
-	const mediapipe = devDir("@mediapipe/tasks-vision", "wasm");
 	const ort = devDir("onnxruntime-web/wasm");
 	const models = modelsDir(layout.dataDir);
 	const modelFiles = (req, res, next) => {
@@ -55672,7 +57264,7 @@ function studioRoutes(studio, layout) {
 		} catch {
 			return next();
 		}
-		const stat = file.startsWith(models + path.sep) && /\.(task|onnx)$/.test(file) ? fs.statSync(file, { throwIfNoEntry: false }) : void 0;
+		const stat = file.startsWith(models + path.sep) && /\.onnx$/.test(file) ? fs.statSync(file, { throwIfNoEntry: false }) : void 0;
 		if (!stat?.isFile()) return next();
 		res.setHeader("Content-Type", "application/octet-stream");
 		res.setHeader("Content-Length", stat.size);
@@ -55686,7 +57278,6 @@ function studioRoutes(studio, layout) {
 		["/saywright.js", bridgeScript],
 		["/axe.min.js", axe],
 		["/__open-in-editor", editorRoute(() => studio.apps.active()?.project ?? null)],
-		...mediapipe ? [["/mediapipe/wasm", files(mediapipe)]] : [],
 		...ort ? [["/ort", files(ort)]] : []
 	];
 }