sanity-plugin-jev-fields 0.2.0 → 0.2.1

package/dist/index.js

@@ -5,20 +5,20 @@ import { createContext, useCallback, useContext, useEffect, useId, useLayoutEffe
 import { RefreshIcon } from "@sanity/icons/Refresh";
 import { keyframes, styled } from "styled-components";
 /** Flattens a field's value into the plain text Jev evaluates. */
-function toText(value) {
+function flattenToText(value) {
 	if (value == null) return "";
 	if (typeof value == "string") return value;
 	if (typeof value == "number" || typeof value == "boolean") return String(value);
 	if (Array.isArray(value)) {
-		let separator = value.some(isBlock) ? "\n\n" : "\n";
-		return value.map(toText).filter((text) => text !== "").join(separator);
+		let separator = value.some(isPortableTextBlock) ? "\n\n" : "\n";
+		return value.map(flattenToText).filter((text) => text !== "").join(separator);
 	}
-	return isRecord$1(value) ? isBlock(value) ? value.children.map((child) => child.text ?? "").join("") : value._type === "slug" ? toText(value.current) : Object.entries(value).filter(([key]) => !key.startsWith("_")).map(([, child]) => toText(child)).filter((text) => text !== "").join("\n") : "";
+	return isRecord(value) ? isPortableTextBlock(value) ? value.children.map((child) => child.text ?? "").join("") : value._type === "slug" ? flattenToText(value.current) : Object.entries(value).filter(([key]) => !key.startsWith("_")).map(([, child]) => flattenToText(child)).filter((text) => text !== "").join("\n") : "";
 }
-function isBlock(value) {
-	return isRecord$1(value) && value._type === "block" && Array.isArray(value.children);
+function isPortableTextBlock(value) {
+	return isRecord(value) && value._type === "block" && Array.isArray(value.children);
 }
-function isRecord$1(value) {
+function isRecord(value) {
 	return !!value && typeof value == "object" && !Array.isArray(value);
 }
 /** FNV-1a: a small, stable fingerprint; collisions only cost a skipped re-evaluation. */
@@ -28,17 +28,17 @@ function fingerprint(input) {
 	return (hash >>> 0).toString(16).padStart(8, "0");
 }
 /** Jev reads at most this many tokens of state (plus the longest question) per request. */
-const estimateTokens = (text) => Math.ceil(text.length / 4), nearTokenLimit = (text) => estimateTokens(text) > 28e3, Context = createContext(null), pathKey = (path) => JSON.stringify(path);
+const estimateTokenCount = (text) => Math.ceil(text.length / 4), isNearTokenLimit = (text) => estimateTokenCount(text) > 28e3, JevFormContext = createContext(null), toPathKey = (path) => JSON.stringify(path);
 /** Wraps a document form, so attached fields can reach the plugin config and answer fields. */
 function JevFormProvider({ config, children }) {
-	let [writers] = useState(() => /* @__PURE__ */ new Map()), value = useMemo(() => ({
+	let [answerWriters] = useState(() => /* @__PURE__ */ new Map()), value = useMemo(() => ({
 		config,
-		writers
-	}), [config, writers]);
-	return <Context.Provider value={value}>{children}</Context.Provider>;
+		answerWriters
+	}), [config, answerWriters]);
+	return <JevFormContext.Provider value={value}>{children}</JevFormContext.Provider>;
 }
 function useJevForm() {
-	let context = useContext(Context);
+	let context = useContext(JevFormContext);
 	if (!context) throw Error("Jev questions need the jev() plugin in sanity.config.");
 	return context;
 }
@@ -47,26 +47,26 @@ function useJevForm() {
 * registers the field's own `onChange`, so the attached field can store answers through it.
 */
 function AnswerField(props) {
-	let { writers } = useJevForm(), key = pathKey(props.path), onChange = props.inputProps.onChange;
-	return useEffect(() => (writers.set(key, (value) => onChange(set(value))), () => {
-		writers.delete(key);
+	let { answerWriters } = useJevForm(), pathKey = toPathKey(props.path), onChange = props.inputProps.onChange;
+	return useEffect(() => (answerWriters.set(pathKey, (value) => onChange(set(value))), () => {
+		answerWriters.delete(pathKey);
 	}), [
-		writers,
-		key,
+		answerWriters,
+		pathKey,
 		onChange
 	]), null;
 }
-const NEUTRAL_COLOR = "hsl(230 80% 66%)", clamp = (value) => Math.min(1, Math.max(0, value)), capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+const NEUTRAL_COLOR = "hsl(230 80% 66%)", ERROR_COLOR = "#f03e2f", clampToFraction = (value) => Math.min(1, Math.max(0, value)), capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
 /** Red at 0, amber in the middle, green at 1. */
 function trafficColor(fraction) {
-	return `hsl(${Math.round(clamp(fraction) * 120)} 70% 52%)`;
+	return `hsl(${Math.round(clampToFraction(fraction) * 120)} 70% 52%)`;
 }
 function trafficTone(fraction) {
 	return fraction < 1 / 3 ? "critical" : fraction < 2 / 3 ? "caution" : "positive";
 }
 /** A thin rounded bar. `fraction` is 0–1. */
 function Bar({ fraction, color, label }) {
-	let percent = Math.round(clamp(fraction) * 100);
+	let percent = Math.round(clampToFraction(fraction) * 100);
 	return <Box flex={1} role="meter" aria-valuemin={0} aria-valuemax={100} aria-valuenow={percent} aria-label={label} style={{
 		height: 4,
 		borderRadius: 4,
@@ -88,11 +88,11 @@ const TYPE_NAMES = {
 	score: "jev.score",
 	choice: "jev.choice",
 	choiceProbability: "jev.choiceProbability"
-}, round = (value, digits = 4) => Math.round(value * 10 ** digits) / 10 ** digits;
-function mismatch() {
+}, RULE_LEVELS = ["warn", "require"], roundToDigits = (value, digits = 4) => Math.round(value * 10 ** digits) / 10 ** digits;
+function throwAnswerKindMismatch() {
 	throw Error("Jev answered a different kind of question.");
 }
-const bookkeepingFields = [
+const evaluationFields = [
 	defineField({
 		name: "evaluatedAt",
 		type: "datetime",
@@ -109,44 +109,41 @@ const bookkeepingFields = [
 		hidden: !0
 	})
 ];
-/** The stored value as a record of the given `_type`, or nothing. */
-function storedOf(stored, typeName) {
-	return isRecord$1(stored) && stored._type === typeName ? stored : void 0;
+function asRecordOfType(stored, typeName) {
+	return isRecord(stored) && stored._type === typeName ? stored : void 0;
 }
-/** The bookkeeping fields a stored value has. */
-function bookkeepingOf(stored) {
+function readEvaluationFields(stored) {
 	return {
-		evaluatedAt: text(stored.evaluatedAt),
-		model: text(stored.model),
-		sourceHash: text(stored.sourceHash)
+		evaluatedAt: stringOrUndefined(stored.evaluatedAt),
+		model: stringOrUndefined(stored.model),
+		sourceHash: stringOrUndefined(stored.sourceHash)
 	};
 }
-const text = (value) => typeof value == "string" ? value : void 0, number = (value) => typeof value == "number" ? value : void 0;
-/** Why a range rule is invalid for values from `min` to `max`, if it is. */
-function rangeRuleProblem(rules, min, max) {
-	for (let level of ["warn", "require"]) {
+const stringOrUndefined = (value) => typeof value == "string" ? value : void 0, numberOrUndefined = (value) => typeof value == "number" ? value : void 0;
+function findRangeRuleConfigError(rules, min, max) {
+	for (let level of RULE_LEVELS) {
 		let rule = rules[level];
 		if (rule) for (let bound of ["atLeast", "atMost"]) {
 			let value = rule[bound];
-			if (value !== void 0 && (typeof value != "number" || value < min || value > max)) return `\`${level}.${bound}\` must be a number from ${min} to ${max}.`;
+			if (value !== void 0 && !(typeof value == "number" && value >= min && value <= max)) return `\`${level}.${bound}\` must be a number from ${min} to ${max}.`;
 		}
 	}
 }
-/** How `value` breaks a range rule, e.g. `below 60%`, using `format` for both numbers. */
-function rangeViolation(value, rule, format) {
+/** E.g. `below 60%`, using `format` for both numbers. */
+function describeRangeViolation(value, rule, format) {
 	if (rule?.atLeast !== void 0 && value < rule.atLeast) return `below ${format(rule.atLeast)}`;
 	if (rule?.atMost !== void 0 && value > rule.atMost) return `above ${format(rule.atMost)}`;
 }
-/** Why a choice question can't be asked, if it can't. */
-function choiceProblem(question, options) {
+function findChoiceConfigError(question) {
+	let options = Object.keys(question.criteria ?? {});
 	if (options.length < 2) return "A choice question needs at least two options.";
 	if (options.length > 255) return "A choice question allows at most 255 options.";
-	for (let level of ["warn", "require"]) {
+	for (let level of RULE_LEVELS) {
 		let rule = question[level];
 		if (!rule) continue;
 		if (!Array.isArray(rule.oneOf) || rule.oneOf.length === 0) return `\`${level}.oneOf\` must list at least one option.`;
-		let unknown = rule.oneOf.find((option) => !options.includes(option));
-		if (unknown !== void 0) return `\`${level}.oneOf\` names "${unknown}", which is not an option.`;
+		let unknownOption = rule.oneOf.find((option) => !options.includes(option));
+		if (unknownOption !== void 0) return `\`${level}.oneOf\` names "${unknownOption}", which is not an option.`;
 	}
 }
 /** One option from a named set. @public */
@@ -186,47 +183,52 @@ const choice = (question) => ({
 			readOnly: !0,
 			of: [defineArrayMember({ type: TYPE_NAMES.choiceProbability })]
 		}),
-		...bookkeepingFields
+		...evaluationFields
 	]
 })];
+function readStoredProbabilities(stored) {
+	return Array.isArray(stored) ? stored.filter(isRecord).map((entry) => ({
+		_key: String(entry._key),
+		_type: TYPE_NAMES.choiceProbability,
+		option: stringOrUndefined(entry.option),
+		probability: numberOrUndefined(entry.probability)
+	})) : [];
+}
 function bindChoice(question) {
-	let criteria = question.criteria ?? {}, problem = choiceProblem(question, Object.keys(criteria));
+	let configError = findChoiceConfigError(question), gatewayQuestion = {
+		type: "choice",
+		instructions: question.instructions,
+		criteria: question.criteria
+	};
 	return {
 		typeName: TYPE_NAMES.choice,
-		gatewayQuestion: problem ? void 0 : {
-			type: "choice",
-			instructions: question.instructions,
-			criteria: question.criteria
-		},
-		problem,
-		toStored(answer) {
-			return answer.type === "choice" ? {
+		gatewayQuestion: configError ? void 0 : gatewayQuestion,
+		configError,
+		toStoredValue(answer) {
+			if (answer.type !== "choice") return throwAnswerKindMismatch();
+			let confidence = answer.confidence ?? answer.probabilities[answer.choice] ?? 0;
+			return {
 				_type: TYPE_NAMES.choice,
 				choice: answer.choice,
-				confidence: round(answer.confidence ?? answer.probabilities[answer.choice] ?? 0),
-				probabilities: Object.keys(criteria).map((option, index) => ({
+				confidence: roundToDigits(confidence),
+				probabilities: Object.keys(question.criteria).map((option, index) => ({
 					_key: `option-${index}`,
 					_type: TYPE_NAMES.choiceProbability,
 					option,
-					probability: round(answer.probabilities[option] ?? 0)
+					probability: roundToDigits(answer.probabilities[option] ?? 0)
 				}))
-			} : mismatch();
+			};
 		},
-		read(stored) {
-			let record = storedOf(stored, TYPE_NAMES.choice);
+		readStoredValue(stored) {
+			let record = asRecordOfType(stored, TYPE_NAMES.choice);
 			if (!record || typeof record.choice != "string") return;
-			let probabilities = Array.isArray(record.probabilities) ? record.probabilities.filter(isRecord$1).map((entry) => ({
-				_key: String(entry._key),
-				_type: TYPE_NAMES.choiceProbability,
-				option: text(entry.option),
-				probability: number(entry.probability)
-			})) : [], meaning = criteria[record.choice];
+			let probabilities = readStoredProbabilities(record.probabilities), meaningOfChoice = question.criteria?.[record.choice];
 			return {
 				value: {
-					...bookkeepingOf(record),
+					...readEvaluationFields(record),
 					_type: TYPE_NAMES.choice,
 					choice: record.choice,
-					confidence: number(record.confidence),
+					confidence: numberOrUndefined(record.confidence),
 					probabilities
 				},
 				chip: {
@@ -234,33 +236,35 @@ function bindChoice(question) {
 					color: NEUTRAL_COLOR
 				},
 				tone: "default",
-				aside: meaning ? { note: meaning } : void 0,
+				aside: meaningOfChoice ? { note: meaningOfChoice } : void 0,
 				body: <ChoiceBody question={question} choice={record.choice} probabilities={probabilities} />
 			};
 		},
-		check(level, stored, title) {
-			let record = storedOf(stored, TYPE_NAMES.choice), rule = question[level];
-			if (record && typeof record.choice == "string" && rule?.oneOf && !rule.oneOf.includes(record.choice)) return `${title} is "${record.choice}", not ${rule.oneOf.map((option) => `"${option}"`).join(" or ")}.`;
+		describeRuleViolation(level, stored, title) {
+			let record = asRecordOfType(stored, TYPE_NAMES.choice), rule = question[level];
+			if (!record || typeof record.choice != "string" || !rule?.oneOf || rule.oneOf.includes(record.choice)) return;
+			let allowedOptions = rule.oneOf.map((option) => `"${option}"`).join(" or ");
+			return `${title} is "${record.choice}", not ${allowedOptions}.`;
 		}
 	};
 }
 function ChoiceBody({ question, choice, probabilities }) {
-	let options = Object.keys(question.criteria), nameWidth = `${Math.max(...options.map((name) => name.length), 4) + 2}ch`;
+	let options = Object.keys(question.criteria), optionColumnWidth = `${Math.max(...options.map((option) => option.length), 4) + 2}ch`;
 	return <Stack gap={3}>
       {options.map((option) => {
-		let probability = probabilities.find((entry) => entry.option === option)?.probability ?? 0, winner = option === choice, percent = Math.round(probability * 100);
+		let probability = probabilities.find((entry) => entry.option === option)?.probability ?? 0, isChosen = option === choice, percent = Math.round(probability * 100);
 		return <Flex key={option} align="center" gap={3}>
-            <Box style={{ width: nameWidth }}>
-              <Text size={1} weight={winner ? "semibold" : "regular"} muted={!winner}>
+            <Box style={{ width: optionColumnWidth }}>
+              <Text size={1} weight={isChosen ? "semibold" : "regular"} muted={!isChosen}>
                 {capitalize(option)}
               </Text>
             </Box>
-            <Bar fraction={probability} color={winner ? NEUTRAL_COLOR : "hsl(215 12% 55%)"} label={`${option}: ${percent}%`} />
+            <Bar fraction={probability} color={isChosen ? NEUTRAL_COLOR : "hsl(215 12% 55%)"} label={`${option}: ${percent}%`} />
             <Box style={{
 			minWidth: "4ch",
 			textAlign: "right"
 		}}>
-              <Text size={1} muted={!winner}>
+              <Text size={1} muted={!isChosen}>
                 {percent}%
               </Text>
             </Box>
@@ -342,73 +346,76 @@ const JEV_NAMESPACE = "jev", jevLocaleBundle = defineLocaleResourceBundle({
 		name: "probability",
 		type: "number",
 		readOnly: !0
-	}), ...bookkeepingFields]
-})], LEVELS$1 = {
+	}), ...evaluationFields]
+})], LEVEL_BY_TONE = {
 	critical: "low",
 	caution: "medium",
 	positive: "high"
-};
+}, formatAsPercent = (probability) => `${Math.round(probability * 100)}%`;
+function findNoulConfigError(question) {
+	return !question.true?.trim() || !question.false?.trim() ? "A noul question needs both `true` and `false` text." : findRangeRuleConfigError(question, 0, 1);
+}
 function bindNoul(question) {
-	let problem = !question.true?.trim() || !question.false?.trim() ? "A noul question needs both `true` and `false` text." : rangeRuleProblem(question, 0, 1);
+	let configError = findNoulConfigError(question), gatewayQuestion = {
+		type: "boolean",
+		instructions: question.instructions,
+		criteria: {
+			true: question.true,
+			false: question.false
+		}
+	};
 	return {
 		typeName: TYPE_NAMES.noul,
-		gatewayQuestion: problem ? void 0 : {
-			type: "boolean",
-			instructions: question.instructions,
-			criteria: {
-				true: question.true,
-				false: question.false
-			}
-		},
-		problem,
-		toStored(answer) {
+		gatewayQuestion: configError ? void 0 : gatewayQuestion,
+		configError,
+		toStoredValue(answer) {
 			return answer.type === "boolean" ? {
 				_type: TYPE_NAMES.noul,
-				probability: round(answer.probability)
-			} : mismatch();
+				probability: roundToDigits(answer.probability)
+			} : throwAnswerKindMismatch();
 		},
-		read(stored) {
-			let record = storedOf(stored, TYPE_NAMES.noul);
+		readStoredValue(stored) {
+			let record = asRecordOfType(stored, TYPE_NAMES.noul);
 			if (!record || typeof record.probability != "number") return;
 			let probability = record.probability, tone = trafficTone(probability);
 			return {
 				value: {
-					...bookkeepingOf(record),
+					...readEvaluationFields(record),
 					_type: TYPE_NAMES.noul,
 					probability
 				},
 				chip: {
-					text: `${Math.round(probability * 100)}%`,
+					text: formatAsPercent(probability),
 					color: trafficColor(probability)
 				},
 				tone: tone === "positive" ? "default" : tone,
 				aside: {
-					level: LEVELS$1[tone] ?? "medium",
+					level: LEVEL_BY_TONE[tone] ?? "medium",
 					tone
 				},
 				body: <NoulBody question={question} probability={probability} />
 			};
 		},
-		check(level, stored, title) {
-			let record = storedOf(stored, TYPE_NAMES.noul);
+		describeRuleViolation(level, stored, title) {
+			let record = asRecordOfType(stored, TYPE_NAMES.noul);
 			if (!record || typeof record.probability != "number") return;
-			let percent = (value) => `${Math.round(value * 100)}%`, broken = rangeViolation(record.probability, question[level], percent);
-			return broken && `${title} is ${percent(record.probability)}, ${broken}.`;
+			let violation = describeRangeViolation(record.probability, question[level], formatAsPercent);
+			return violation && `${title} is ${formatAsPercent(record.probability)}, ${violation}.`;
 		}
 	};
 }
 function NoulBody({ question, probability }) {
-	let { t } = useTranslation("jev"), percent = Math.round(probability * 100);
+	let { t } = useTranslation("jev"), percent = formatAsPercent(probability);
 	return <Stack gap={4}>
       <Flex align="baseline" gap={2}>
         <Text size={4} weight="medium">
-          {percent}%
+          {percent}
         </Text>
         {question.label && <Text size={1} muted>
             {question.label}
           </Text>}
       </Flex>
-      <Bar fraction={probability} color={trafficColor(probability)} label={`${question.title ?? t("noul.yes")}: ${percent}%`} />
+      <Bar fraction={probability} color={trafficColor(probability)} label={`${question.title ?? t("noul.yes")}: ${percent}`} />
       <Text size={1} muted>
         {probability >= .5 ? question.true : question.false}
       </Text>
@@ -444,109 +451,115 @@ const score = (question) => ({
 			type: "number",
 			readOnly: !0
 		}),
-		...bookkeepingFields
+		...evaluationFields
 	]
-})], shortLabel = (criterion) => criterion?.split(":")[0].trim() ?? "";
+})], getCriterionShortLabel = (criterion) => criterion?.split(":")[0].trim() ?? "";
 /** `'anecdotal: personal experience'` → `'personal experience'`; without a colon, the whole text. */
-function meaningOf(criterion) {
+function getCriterionMeaning(criterion) {
 	if (!criterion) return "";
-	let colon = criterion.indexOf(":");
-	return (colon === -1 ? criterion : criterion.slice(colon + 1)).trim();
+	let colonIndex = criterion.indexOf(":");
+	return (colonIndex === -1 ? criterion : criterion.slice(colonIndex + 1)).trim();
 }
 /**
 * How full each segment of a score bar is, 0–1. Segment `i` stands for reaching criterion
 * `i`: a score of 0.8 fills the first segment and 80% of the second.
 */
-function segmentFills(score, count) {
-	return Array.from({ length: count }, (_, index) => Math.min(1, Math.max(0, score - index + 1)));
+function getSegmentFillFractions(score, segmentCount) {
+	return Array.from({ length: segmentCount }, (_, index) => Math.min(1, Math.max(0, score - index + 1)));
 }
-/** Colour and tone of a score, from the criterion it is nearest to. */
-function scoreLook(question, value, max) {
+/** From the criterion the score is nearest to. */
+function getScoreColorAndTone(question, score, max) {
 	if (question.colors === "neutral") return {
 		color: NEUTRAL_COLOR,
 		tone: "primary"
 	};
-	let fraction = max > 0 ? Math.round(value) / max : 0, good = question.colors === "reverse" ? 1 - fraction : fraction;
+	let fractionOfMax = max > 0 ? Math.round(score) / max : 0, goodness = question.colors === "reverse" ? 1 - fractionOfMax : fractionOfMax;
 	return {
-		color: trafficColor(good),
-		tone: trafficTone(good)
+		color: trafficColor(goodness),
+		tone: trafficTone(goodness)
 	};
 }
+function findScoreConfigError(question) {
+	let { criteria } = question;
+	return !Array.isArray(criteria) || criteria.length < 2 ? "A score question needs at least two criteria." : criteria.length > 10 ? "A score question allows at most ten criteria." : findRangeRuleConfigError(question, 0, criteria.length - 1);
+}
 function bindScore(question) {
-	let { criteria } = question, problem = !Array.isArray(criteria) || criteria.length < 2 ? "A score question needs at least two criteria." : criteria.length > 10 ? "A score question allows at most ten criteria." : rangeRuleProblem(question, 0, criteria.length - 1);
+	let configError = findScoreConfigError(question), gatewayQuestion = {
+		type: "score",
+		instructions: question.instructions,
+		criteria: question.criteria
+	};
+	/** E.g. `0.6 (anecdotal)`: a position on the scale and the criterion nearest to it. */
+	function describeScorePosition(position) {
+		let label = getCriterionShortLabel(question.criteria[Math.round(position)]), formattedPosition = Number.isInteger(position) ? String(position) : position.toFixed(1);
+		return label ? `${formattedPosition} (${label})` : formattedPosition;
+	}
 	return {
 		typeName: TYPE_NAMES.score,
-		gatewayQuestion: problem ? void 0 : {
-			type: "score",
-			instructions: question.instructions,
-			criteria
-		},
-		problem,
-		toStored(answer) {
-			if (answer.type !== "score") return mismatch();
-			let max = criteria.length - 1, value = Math.min(max, Math.max(0, answer.score));
+		gatewayQuestion: configError ? void 0 : gatewayQuestion,
+		configError,
+		toStoredValue(answer) {
+			if (answer.type !== "score") return throwAnswerKindMismatch();
+			let max = question.criteria.length - 1, clampedScore = Math.min(max, Math.max(0, answer.score));
 			return {
 				_type: TYPE_NAMES.score,
-				score: round(value),
+				score: roundToDigits(clampedScore),
 				max,
-				label: shortLabel(criteria[Math.round(value)]),
-				...typeof answer.confidence == "number" && { confidence: round(answer.confidence) }
+				label: getCriterionShortLabel(question.criteria[Math.round(clampedScore)]),
+				...typeof answer.confidence == "number" && { confidence: roundToDigits(answer.confidence) }
 			};
 		},
-		read(stored) {
-			let record = storedOf(stored, TYPE_NAMES.score);
+		readStoredValue(stored) {
+			let record = asRecordOfType(stored, TYPE_NAMES.score);
 			if (!record || typeof record.score != "number" || typeof record.max != "number") return;
-			let { score: value, max } = record, label = text(record.label), look = scoreLook(question, value, max);
+			let { score, max } = record, label = stringOrUndefined(record.label), { color, tone } = getScoreColorAndTone(question, score, max), nearestCriterion = question.criteria?.[Math.round(score)];
 			return {
 				value: {
-					...bookkeepingOf(record),
+					...readEvaluationFields(record),
 					_type: TYPE_NAMES.score,
-					score: value,
+					score,
 					max,
 					label,
-					confidence: number(record.confidence)
+					confidence: numberOrUndefined(record.confidence)
 				},
 				chip: {
-					text: `${value.toFixed(1)}/${max}`,
-					color: look.color
+					text: `${score.toFixed(1)}/${max}`,
+					color
 				},
-				tone: look.tone === "critical" || look.tone === "caution" ? look.tone : "default",
+				tone: tone === "critical" || tone === "caution" ? tone : "default",
 				aside: {
-					badge: capitalize(label ?? shortLabel(criteria?.[Math.round(value)])),
-					tone: look.tone
+					badge: capitalize(label ?? getCriterionShortLabel(nearestCriterion)),
+					tone
 				},
-				body: <ScoreBody question={question} score={value} max={max} color={look.color} />
+				body: <ScoreBody question={question} score={score} max={max} color={color} />
 			};
 		},
-		check(level, stored, title) {
-			let record = storedOf(stored, TYPE_NAMES.score);
+		describeRuleViolation(level, stored, title) {
+			let record = asRecordOfType(stored, TYPE_NAMES.score);
 			if (!record || typeof record.score != "number") return;
-			let describe = (position) => {
-				let label = shortLabel(criteria[Math.round(position)]), number = Number.isInteger(position) ? String(position) : position.toFixed(1);
-				return label ? `${number} (${label})` : number;
-			}, broken = rangeViolation(record.score, question[level], describe);
-			return broken && `${title} is ${describe(record.score)}, ${broken}.`;
+			let violation = describeRangeViolation(record.score, question[level], describeScorePosition);
+			return violation && `${title} is ${describeScorePosition(record.score)}, ${violation}.`;
 		}
 	};
 }
 function ScoreBody({ question, score, max, color }) {
-	let { t } = useTranslation("jev"), nearest = Math.round(score), fills = segmentFills(score, question.criteria.length), next = question.criteria[nearest + 1];
+	let { t } = useTranslation("jev"), nearestIndex = Math.round(score), segmentFillFractions = getSegmentFillFractions(score, question.criteria.length), nextCriterion = question.criteria[nearestIndex + 1];
 	return <Stack gap={4}>
       <Flex gap={1}>
         {question.criteria.map((criterion, index) => <Stack key={index} gap={2} flex={1}>
-            <Bar fraction={fills[index]} color={color} label={`${index}: ${shortLabel(criterion)}`} />
-            <Text size={1} weight={index === nearest ? "medium" : "regular"} muted={index > nearest} style={index < nearest ? { color } : void 0} textOverflow="ellipsis">
-              {index} · {capitalize(shortLabel(criterion))}
+            <Bar fraction={segmentFillFractions[index]} color={color} label={`${index}: ${getCriterionShortLabel(criterion)}`} />
+            <Text size={1} weight={index === nearestIndex ? "medium" : "regular"} muted={index > nearestIndex} style={index < nearestIndex ? { color } : void 0} textOverflow="ellipsis">
+              {index} · {capitalize(getCriterionShortLabel(criterion))}
             </Text>
           </Stack>)}
       </Flex>
       <Text size={1} muted>
         {t("score.summary", {
-		meaning: capitalize(meaningOf(question.criteria[nearest])),
+		meaning: capitalize(getCriterionMeaning(question.criteria[nearestIndex])),
 		score: score.toFixed(1),
 		max
 	})}
-        {next ? ` ${t("score.next", { next: meaningOf(next) })}` : ""}
+        {nextCriterion ? ` ${t("score.next", { next: getCriterionMeaning(nextCriterion) })}` : ""}
       </Text>
     </Stack>;
 }
@@ -556,37 +569,36 @@ const KIND_SCHEMA_TYPES = [
 	...scoreSchemaTypes,
 	...choiceSchemaTypes
 ];
-/** Binds a question to its kind. The one place that tells Noul, Score and Choice apart. */
-function kindOf(question) {
-	let kind = bind(question);
+/** The one place that tells Noul, Score and Choice apart. */
+function bindQuestionToKind(question) {
+	let kind = bindQuestionByType(question);
 	return question.instructions?.trim() ? kind : {
 		...kind,
 		gatewayQuestion: void 0,
-		problem: "Add instructions to this question."
+		configError: "Add instructions to this question."
 	};
 }
-function bind(question) {
+function bindQuestionByType(question) {
 	switch (question.type) {
 		case "noul": return bindNoul(question);
 		case "score": return bindScore(question);
 		case "choice": return bindChoice(question);
 		default: return {
 			typeName: "unknown",
-			problem: "Unknown question type.",
-			toStored: mismatch,
-			read: () => void 0,
-			check: () => void 0
+			configError: "Unknown question type.",
+			toStoredValue: throwAnswerKindMismatch,
+			readStoredValue: () => void 0,
+			describeRuleViolation: () => void 0
 		};
 	}
 }
-/** `readable` → `Readable`, `readingLevel` → `Reading level`. */
-function titleOf(key, question) {
+/** The question's own `title`, or one made from its key: `readingLevel` → `Reading level`. */
+function getQuestionTitle(key, question) {
 	if (question.title) return question.title;
 	let words = key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ");
 	return words.charAt(0).toUpperCase() + words.slice(1).toLowerCase();
 }
-const isRecord = (value) => !!value && typeof value == "object" && !Array.isArray(value);
-function questionsOf(definition) {
+function getQuestionsFromDefinition(definition) {
 	if (!isRecord(definition) || !isRecord(definition.options)) return;
 	let { jev } = definition.options;
 	return isRecord(jev) ? jev : void 0;
@@ -601,19 +613,19 @@ function questionsOf(definition) {
 * @public
 */
 function withJevAnswers(types) {
-	return types.map((type) => withAnswerFields(type));
+	return types.map((type) => addAnswerFieldsRecursively(type));
 }
-/** Rewrites `fields` (and inline object members) of a type or field definition, recursively. */
-function withAnswerFields(definition) {
+/** Rewrites `fields` (and inline object members) of a type or field definition. */
+function addAnswerFieldsRecursively(definition) {
 	if (!isRecord(definition)) return definition;
 	let result = definition;
 	if (Array.isArray(definition.of) && (result = {
 		...result,
-		of: definition.of.map(withAnswerFields)
+		of: definition.of.map(addAnswerFieldsRecursively)
 	}), Array.isArray(definition.fields)) {
-		let existing = new Map(definition.fields.filter(isRecord).map((field) => [field.name, field.type])), fields = definition.fields.flatMap((field) => {
-			let rewritten = withAnswerFields(field), questions = questionsOf(field);
-			return !questions || !isRecord(field) || !isRecord(rewritten) ? [rewritten] : [withRules(rewritten, questions), ...answerFieldsFor(field, questions, existing)];
+		let existingFieldTypesByName = new Map(definition.fields.filter(isRecord).map((field) => [field.name, field.type])), fields = definition.fields.flatMap((field) => {
+			let rewrittenField = addAnswerFieldsRecursively(field), questions = getQuestionsFromDefinition(field);
+			return !questions || !isRecord(field) || !isRecord(rewrittenField) ? [rewrittenField] : [addRuleValidation(rewrittenField, questions), ...createAnswerFields(field, questions, existingFieldTypesByName)];
 		});
 		result = {
 			...result,
@@ -622,61 +634,66 @@ function withAnswerFields(definition) {
 	}
 	return result;
 }
-function answerFieldsFor(field, questions, existing) {
+function createAnswerFields(attachedField, questions, existingFieldTypesByName) {
 	return Object.entries(questions).flatMap(([key, question]) => {
-		let type = TYPE_NAMES[question.type];
-		if (existing.get(key) === type) return [];
-		if (existing.has(key)) throw Error(`Jev: the question "${key}" on "${String(field.name)}" needs a field called "${key}" to store its answer, but that name is already taken. Rename the question.`);
-		return existing.set(key, type), [defineField({
+		let answerType = TYPE_NAMES[question.type];
+		if (existingFieldTypesByName.get(key) === answerType) return [];
+		if (existingFieldTypesByName.has(key)) throw Error(`Jev: the question "${key}" on "${String(attachedField.name)}" needs a field called "${key}" to store its answer, but that name is already taken. Rename the question.`);
+		existingFieldTypesByName.set(key, answerType);
+		let { group, fieldset } = attachedField;
+		return [defineField({
 			name: key,
-			title: titleOf(key, question),
-			type,
-			group: typeof field.group == "string" || Array.isArray(field.group) ? field.group : void 0,
-			fieldset: typeof field.fieldset == "string" ? field.fieldset : void 0
+			title: getQuestionTitle(key, question),
+			type: answerType,
+			group: typeof group == "string" || Array.isArray(group) ? group : void 0,
+			fieldset: typeof fieldset == "string" ? fieldset : void 0
 		})];
 	});
 }
-const LEVELS = ["warn", "require"];
+/** `undefined` → `[]`, a value → `[value]`, an array as it is. */
+function toArray(value) {
+	return Array.isArray(value) ? value : value ? [value] : [];
+}
 /**
 * Adds a validation rule to the attached field for each question's `warn` and `require`, after
 * the field's own validation. Rules judge the stored answer, so they say nothing until there is
 * one.
 */
-function withRules(field, questions) {
-	let checks = Object.entries(questions).flatMap(([key, question]) => LEVELS.filter((level) => question[level]).map((level) => ({
+function addRuleValidation(attachedField, questions) {
+	let rulesToValidate = Object.entries(questions).flatMap(([key, question]) => RULE_LEVELS.filter((level) => question[level]).map((level) => ({
 		key,
 		question,
 		level
 	})));
-	if (checks.length === 0) return field;
-	let own = field.validation, validation = (rule) => {
-		let ownRules = (Array.isArray(own) ? own : own ? [own] : []).flatMap((entry) => {
-			let result = typeof entry == "function" ? entry(rule) : entry;
-			return Array.isArray(result) ? result : result ? [result] : [];
-		}), jevRules = checks.map(({ key, question, level }) => {
-			let kind = kindOf(question), title = titleOf(key, question), custom = rule.custom((_value, context) => {
+	if (rulesToValidate.length === 0) return attachedField;
+	let ownValidation = attachedField.validation, validation = (rule) => {
+		let ownRules = toArray(ownValidation).flatMap((entry) => toArray(typeof entry == "function" ? entry(rule) : entry)), jevRules = rulesToValidate.map(({ key, question, level }) => {
+			let kind = bindQuestionToKind(question), title = getQuestionTitle(key, question), customRule = rule.custom((_value, context) => {
 				let stored = isRecord(context.parent) ? context.parent[key] : void 0;
-				return kind.check(level, stored, title) ?? !0;
+				return kind.describeRuleViolation(level, stored, title) ?? !0;
 			});
-			return level === "require" ? custom.error() : custom.warning();
+			return level === "require" ? customRule.error() : customRule.warning();
 		});
 		return [...ownRules, ...jevRules];
 	};
 	return {
-		...field,
+		...attachedField,
 		validation
 	};
 }
-const SECRETS_ID = "secrets.jev";
+const SECRETS_DOCUMENT_ID = "secrets.jev";
+function readApiKeyFromSecrets(secrets) {
+	let apiKey = secrets && typeof secrets == "object" && "gatewayApiKey" in secrets ? secrets.gatewayApiKey : void 0;
+	return typeof apiKey == "string" && apiKey ? apiKey : void 0;
+}
 /** The AI Gateway key stored in `secrets.jev`, kept up to date as it changes. */
 function useStoredKey() {
 	let documentPreviewStore = useDocumentPreviewStore(), [stored, setStored] = useState({ loading: !0 });
 	return useEffect(() => {
-		let subscription = documentPreviewStore.unstable_observeDocument(SECRETS_ID).subscribe((document) => {
-			let secrets = document?.secrets, apiKey = secrets && typeof secrets == "object" && "gatewayApiKey" in secrets ? secrets.gatewayApiKey : void 0;
+		let subscription = documentPreviewStore.unstable_observeDocument(SECRETS_DOCUMENT_ID).subscribe((document) => {
 			setStored({
 				loading: !1,
-				apiKey: typeof apiKey == "string" && apiKey ? apiKey : void 0,
+				apiKey: readApiKeyFromSecrets(document?.secrets),
 				updatedAt: document?._updatedAt
 			});
 		});
@@ -688,15 +705,17 @@ function useSaveKey() {
 	let client = useClient({ apiVersion: "2025-02-19" });
 	return async (apiKey) => {
 		await client.transaction().createIfNotExists({
-			_id: SECRETS_ID,
+			_id: SECRETS_DOCUMENT_ID,
 			_type: "pluginSecrets"
-		}).patch(SECRETS_ID, (patch) => apiKey ? patch.set({ secrets: { gatewayApiKey: apiKey } }) : patch.unset(["secrets"])).commit({ tag: "jev.secrets" });
+		}).patch(SECRETS_DOCUMENT_ID, (patch) => apiKey ? patch.set({ secrets: { gatewayApiKey: apiKey } }) : patch.unset(["secrets"])).commit({ tag: "jev.secrets" });
 	};
 }
+/** With a `transport` or `apiKey` in the plugin config, the stored key is ignored. */
+const isKeyFromConfig = (config) => !!(config.transport || config.apiKey);
 /** Where the API key comes from: plugin config wins over the stored key. */
 function useKeySource(config) {
 	let stored = useStoredKey();
-	return config.transport || config.apiKey ? {
+	return isKeyFromConfig(config) ? {
 		from: "config",
 		apiKey: config.apiKey
 	} : {
@@ -743,8 +762,8 @@ function JevKeyDialog({ onClose }) {
       </Box>
     </Dialog>;
 }
-/** An evaluation error in the Studio's language; errors from outside the Gateway as they are. */
-function errorText(t, error) {
+/** Errors from outside the Gateway are shown as they are. */
+function translateQuestionError(t, error) {
 	switch (error.kind) {
 		case "auth": return t("error.auth");
 		case "invalid": return t("error.invalid", { detail: error.detail ?? error.status });
@@ -760,7 +779,7 @@ function errorText(t, error) {
 const pulse = keyframes`
   0%, 100% { opacity: 1; }
   50% { opacity: 0.25; }
-`, Dot = styled.span`
+`, ChipStatusDot = styled.span`
   flex: none;
   width: 6px;
   height: 6px;
@@ -768,11 +787,11 @@ const pulse = keyframes`
   background: ${({ $color }) => $color};
   animation: ${({ $pulse }) => $pulse ? pulse : "none"} 1s ease-in-out infinite;
 `;
-function Chip({ question, selected, onSelect }) {
+function QuestionChip({ question, selected, onSelect }) {
 	let { t } = useTranslation("jev"), { text, color } = question.reading?.chip ?? {
 		text: t("chip.empty"),
 		color: void 0
-	}, failed = !!question.error || !!question.problem;
+	}, hasError = !!question.error || !!question.configError;
 	return <Card as="button" type="button" radius={2} paddingX={2} paddingY={2} onClick={onSelect} aria-pressed={selected} title={question.stale ? t("chip.out-of-date") : void 0} style={{
 		display: "inline-flex",
 		flex: "none",
@@ -782,24 +801,24 @@ function Chip({ question, selected, onSelect }) {
 		background: selected ? "rgba(128, 128, 128, 0.16)" : void 0
 	}}>
       <Flex align="center" gap={2}>
-        <Dot aria-hidden $color={failed ? "#f03e2f" : color ?? "hsl(215 12% 55%)"} $pulse={question.loading} />
+        <ChipStatusDot aria-hidden $color={hasError ? ERROR_COLOR : color ?? "hsl(215 12% 55%)"} $pulse={question.loading} />
         {}
         <Text size={1}>
           {question.title}
           <span style={{
 		marginLeft: "0.6em",
 		fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-		color: failed ? "#f03e2f" : color,
+		color: hasError ? ERROR_COLOR : color,
 		opacity: question.stale ? .5 : 1
 	}}>
-            {failed ? t("chip.error") : text}
+            {hasError ? t("chip.error") : text}
           </span>
         </Text>
       </Flex>
     </Card>;
 }
 /** The row of question chips under an attached field. */
-function QuestionStrip({ questions, selected, onSelect, setup, canRun, loading, onRunAll, onSetUp }) {
+function QuestionStrip({ questions, selectedKey, onSelect, setupStatus, canRun, loading, onEvaluateAll, onSetUp }) {
 	let { t } = useTranslation("jev");
 	return <Card border padding={1} style={{
 		borderTop: 0,
@@ -809,27 +828,38 @@ function QuestionStrip({ questions, selected, onSelect, setup, canRun, loading,
 	}}>
       <Flex align="center" gap={2}>
         <Flex flex={1} align="center" gap={1} wrap="wrap">
-          {questions.map((question) => <Chip key={question.key} question={question} selected={selected === question.key} onSelect={() => onSelect(selected === question.key ? null : question.key)} />)}
+          {questions.map((question) => {
+		let isSelected = selectedKey === question.key;
+		return <QuestionChip key={question.key} question={question} selected={isSelected} onSelect={() => onSelect(isSelected ? null : question.key)} />;
+	})}
         </Flex>
-        {setup === "missing" ? <Button text={t("strip.set-up")} mode="ghost" tone="primary" fontSize={1} padding={2} onClick={onSetUp} /> : <Flex align="center" gap={1}>
+        {setupStatus === "missing" ? <Button text={t("strip.set-up")} mode="ghost" tone="primary" fontSize={1} padding={2} onClick={onSetUp} /> : <Flex align="center" gap={1}>
             <Text size={0} muted>
               {t("strip.label")}
             </Text>
             {loading ? <Box padding={2}>
                 <Spinner muted />
-              </Box> : <Button icon={RefreshIcon} mode="bleed" fontSize={1} padding={2} title={t("strip.evaluate-all")} aria-label={t("strip.evaluate-all")} disabled={!canRun} onClick={onRunAll} />}
+              </Box> : <Button icon={RefreshIcon} mode="bleed" fontSize={1} padding={2} title={t("strip.evaluate-all")} aria-label={t("strip.evaluate-all")} disabled={!canRun} onClick={onEvaluateAll} />}
           </Flex>}
       </Flex>
     </Card>;
 }
+function QuestionDetailBody({ question, empty }) {
+	let { t } = useTranslation("jev");
+	return question.configError ? <Text size={1}>{question.configError}</Text> : question.reading ? question.reading.body : <Text size={1} muted>
+      {t(empty ? "detail.empty-field" : "detail.not-evaluated")}
+    </Text>;
+}
+function QuestionDetailAside({ aside }) {
+	let { t } = useTranslation("jev");
+	return "badge" in aside ? <Badge tone={aside.tone}>{aside.badge}</Badge> : "level" in aside ? <Badge tone={aside.tone}>{t(`noul.level.${aside.level}`)}</Badge> : <Text size={1} muted>
+      {aside.note}
+    </Text>;
+}
 /** Expanded view of the selected chip. */
 function QuestionDetail({ question, empty, onRetry, onUpdateKey }) {
-	let { t } = useTranslation("jev"), { reading } = question, body = question.problem ? <Text size={1}>{question.problem}</Text> : reading ? reading.body : <Text size={1} muted>
-      {t(empty ? "detail.empty-field" : "detail.not-evaluated")}
-    </Text>, aside = reading?.aside ? "badge" in reading.aside ? <Badge tone={reading.aside.tone}>{reading.aside.badge}</Badge> : "level" in reading.aside ? <Badge tone={reading.aside.tone}>{t(`noul.level.${reading.aside.level}`)}</Badge> : <Text size={1} muted>
-      {reading.aside.note}
-    </Text> : null;
-	return <Card padding={4} radius={2} border tone={question.problem ? "critical" : reading?.tone ?? "default"}>
+	let { t } = useTranslation("jev"), aside = question.reading?.aside, tone = question.configError ? "critical" : question.reading?.tone ?? "default";
+	return <Card padding={4} radius={2} border tone={tone}>
       <Stack gap={4}>
         <Flex align="center" gap={3}>
           <Box flex={1}>
@@ -837,16 +867,16 @@ function QuestionDetail({ question, empty, onRetry, onUpdateKey }) {
               {question.title}
             </Text>
           </Box>
-          {aside}
+          {aside && <QuestionDetailAside aside={aside} />}
         </Flex>
-        {body}
+        <QuestionDetailBody question={question} empty={empty} />
         {question.stale && !question.loading && <Text size={0} muted>
             {t("detail.out-of-date")}
           </Text>}
         {question.error && <Card padding={3} radius={2} tone="critical" border>
             <Flex align="center" gap={3} wrap="wrap">
               <Box flex={1}>
-                <Text size={1}>{errorText(t, question.error)}</Text>
+                <Text size={1}>{translateQuestionError(t, question.error)}</Text>
               </Box>
               {question.keyRejected && onUpdateKey ? <Button text={t("detail.update-key")} mode="ghost" fontSize={1} onClick={onUpdateKey} /> : <Button text={t("detail.try-again")} mode="ghost" fontSize={1} onClick={onRetry} />}
             </Flex>
@@ -905,7 +935,7 @@ var JevError = class extends Error {
 	}
 };
 /** The default transport: calls AI Gateway directly from the browser with the API key. */
-function gatewayTransport(apiKey, endpoint = "https://ai-gateway.vercel.sh/v1/evaluate") {
+function createGatewayTransport(apiKey, endpoint = "https://ai-gateway.vercel.sh/v1/evaluate") {
 	return (request, { signal }) => fetch(endpoint, {
 		method: "POST",
 		signal,
@@ -916,6 +946,11 @@ function gatewayTransport(apiKey, endpoint = "https://ai-gateway.vercel.sh/v1/ev
 		body: JSON.stringify(request)
 	});
 }
+/** A `transport` in the plugin config wins; otherwise the API key, if there is one. */
+function resolveTransport(config, apiKey) {
+	if (config.transport) return config.transport;
+	if (apiKey) return createGatewayTransport(apiKey, config.endpoint);
+}
 /**
 * Asks the decision model a single typed question about the state. Resolves with the answer
 * and the model that gave it, as the Gateway names it.
@@ -926,7 +961,7 @@ async function evaluateQuestion({ transport, model, state, question, tags, signa
 		state,
 		questions: { q: question },
 		providerOptions: { gateway: { tags: normalizeTags(tags) } }
-	}, send = async (attempt) => {
+	}, sendWithRetries = async (attempt) => {
 		let response = await transport(request, { signal }), body = await response.json().catch(() => ({}));
 		if (response.ok) {
 			let answer = body.answers?.q;
@@ -936,21 +971,21 @@ async function evaluateQuestion({ transport, model, state, question, tags, signa
 				model: body.model ?? model
 			};
 		}
-		if (RETRY_STATUSES.has(response.status) && attempt < retryDelays.length) return await sleep(retryDelay(response, retryDelays[attempt]), signal), send(attempt + 1);
-		throw toError(response.status, errorMessage(body));
+		if (RETRY_STATUSES.has(response.status) && attempt < retryDelays.length) return await sleep(getRetryDelayMs(response, retryDelays[attempt]), signal), sendWithRetries(attempt + 1);
+		throw toJevError(response.status, readGatewayErrorMessage(body));
 	};
-	return send(0);
+	return sendWithRetries(0);
 }
-function toError(status, message) {
+function toJevError(status, message) {
 	return status === 401 || status === 403 ? new JevError("auth", "AI Gateway rejected the API key. Check the key in the Jev tool.", status, message) : status === 400 || status === 422 ? new JevError("invalid", `AI Gateway rejected the question: ${message ?? status}`, status, message) : RETRY_STATUSES.has(status) ? new JevError("busy", "AI Gateway is busy. Try again in a moment.", status, message) : new JevError("failed", `AI Gateway responded with ${status}${message ? `: ${message}` : ""}`, status, message);
 }
-function errorMessage(body) {
+function readGatewayErrorMessage(body) {
 	return (typeof body.error == "string" ? body.error : body.error?.message) || void 0;
 }
 /** Honours a short `Retry-After` (in seconds) when it asks for longer than our own backoff. */
-function retryDelay(response, backoff) {
-	let seconds = Number(response.headers.get("retry-after"));
-	return !Number.isFinite(seconds) || seconds <= 0 ? backoff : Math.min(Math.max(backoff, seconds * 1e3), 1e4);
+function getRetryDelayMs(response, backoffMs) {
+	let retryAfterSeconds = Number(response.headers.get("retry-after"));
+	return !Number.isFinite(retryAfterSeconds) || retryAfterSeconds <= 0 ? backoffMs : Math.min(Math.max(backoffMs, retryAfterSeconds * 1e3), 1e4);
 }
 function sleep(ms, signal) {
 	return new Promise((resolve, reject) => {
@@ -962,8 +997,8 @@ function sleep(ms, signal) {
 	});
 }
 function normalizeTags(tags) {
-	let cleaned = tags.map((tag) => tag.trim().slice(0, 64)).filter(Boolean);
-	return [...new Set(cleaned)].slice(0, 10);
+	let trimmedTags = tags.map((tag) => tag.trim().slice(0, 64)).filter(Boolean);
+	return [...new Set(trimmedTags)].slice(0, 10);
 }
 const realClock = {
 	now: () => /* @__PURE__ */ new Date(),
@@ -971,7 +1006,16 @@ const realClock = {
 		let timeout = setTimeout(callback, ms);
 		return () => clearTimeout(timeout);
 	}
-}, EMPTY = {
+};
+function toQuestionError(error) {
+	return error instanceof JevError ? {
+		message: error.message,
+		kind: error.kind,
+		status: error.status,
+		detail: error.detail
+	} : { message: error instanceof Error ? error.message : String(error) };
+}
+const EMPTY_SNAPSHOT = {
 	questions: [],
 	canRun: !1,
 	empty: !0,
@@ -983,129 +1027,125 @@ const realClock = {
 * a fingerprint that has since changed is cancelled and its answer dropped.
 */
 function createLifecycle(clock = realClock) {
-	let inputs, entries = [], localState, expectLocal = !1, requests = /* @__PURE__ */ new Map(), statuses = /* @__PURE__ */ new Map(), attempted = /* @__PURE__ */ new Map(), scheduled, snapshot = EMPTY, dirty = !0, listeners = /* @__PURE__ */ new Set(), canRun = (current) => !!current.transport && !current.readOnly && current.state.trim() !== "";
+	let inputs, boundQuestions = [], stateFromLastLocalEdit, nextStateIsFromLocalEdit = !1, requestsInFlight = /* @__PURE__ */ new Map(), evaluationStatuses = /* @__PURE__ */ new Map(), lastAttemptedHashes = /* @__PURE__ */ new Map(), scheduledEvaluation, snapshot = EMPTY_SNAPSHOT, snapshotIsOutdated = !0, listeners = /* @__PURE__ */ new Set(), canRun = (current) => !!current.transport && !current.readOnly && current.state.trim() !== "", getHashesByKey = () => new Map(boundQuestions.map(({ key, hash }) => [key, hash]));
 	function update(next) {
 		let previous = inputs;
-		inputs = next, next.state !== previous?.state && (localState = expectLocal ? next.state : void 0, expectLocal = !1), (!previous || next.questions !== previous.questions || next.state !== previous.state || next.model !== previous.model) && (entries = Object.entries(next.questions).map(([key, question]) => {
-			let kind = kindOf(question);
+		inputs = next, next.state !== previous?.state && (stateFromLastLocalEdit = nextStateIsFromLocalEdit ? next.state : void 0, nextStateIsFromLocalEdit = !1), (!previous || next.questions !== previous.questions || next.state !== previous.state || next.model !== previous.model) && (boundQuestions = Object.entries(next.questions).map(([key, question]) => {
+			let kind = bindQuestionToKind(question);
 			return {
 				key,
 				question,
 				kind,
-				title: titleOf(key, question),
+				title: getQuestionTitle(key, question),
 				hash: fingerprint([
 					next.state,
 					kind.gatewayQuestion ?? null,
 					next.model
 				])
 			};
-		}), forgetObsoleteWork(), dirty = !0), previous && (canRun(next) !== canRun(previous) || entries.some(({ key }) => next.answers[key] !== previous.answers[key])) && (dirty = !0), refresh();
+		}), cancelWorkForChangedHashes(), snapshotIsOutdated = !0);
+		let canRunChanged = previous && canRun(next) !== canRun(previous), answersChanged = previous && boundQuestions.some(({ key }) => next.answers[key] !== previous.answers[key]);
+		(canRunChanged || answersChanged) && (snapshotIsOutdated = !0), rebuildSnapshotIfOutdated();
 	}
-	function forgetObsoleteWork() {
-		let hashes = new Map(entries.map(({ key, hash }) => [key, hash]));
-		for (let [key, request] of requests) hashes.get(key) !== request.hash && (request.controller.abort(), requests.delete(key));
-		for (let [key, status] of statuses) hashes.get(key) !== status.hash && statuses.delete(key);
-		for (let [key, hash] of attempted) hashes.get(key) !== hash && attempted.delete(key);
+	function cancelWorkForChangedHashes() {
+		let hashesByKey = getHashesByKey();
+		for (let [key, request] of requestsInFlight) hashesByKey.get(key) !== request.hash && (request.controller.abort(), requestsInFlight.delete(key));
+		for (let [key, status] of evaluationStatuses) hashesByKey.get(key) !== status.hash && evaluationStatuses.delete(key);
+		for (let [key, hash] of lastAttemptedHashes) hashesByKey.get(key) !== hash && lastAttemptedHashes.delete(key);
 	}
-	/** Questions that would evaluate on their own: unanswered or stale, and not tried yet. */
-	function pendingKeys(current, views) {
-		return !canRun(current) || localState !== current.state ? [] : entries.filter((entry, index) => {
-			let view = views[index];
-			return entry.kind.gatewayQuestion && (!view.reading || view.stale) && attempted.get(entry.key) !== entry.hash;
+	/** Unanswered or stale, and not tried yet for the current fingerprint. */
+	function getKeysToEvaluateAutomatically(current, views) {
+		return !canRun(current) || stateFromLastLocalEdit !== current.state ? [] : boundQuestions.filter((boundQuestion, index) => {
+			let view = views[index], needsAnswer = !view.reading || view.stale, alreadyAttempted = lastAttemptedHashes.get(boundQuestion.key) === boundQuestion.hash;
+			return boundQuestion.kind.gatewayQuestion && needsAnswer && !alreadyAttempted;
 		}).map(({ key }) => key);
 	}
-	/** Rebuilds the snapshot and the debounce after anything they depend on changed. */
-	function refresh() {
+	function rebuildSnapshotIfOutdated() {
 		let current = inputs;
-		if (!current || !dirty) return;
-		dirty = !1;
-		let views = entries.map((entry) => {
-			let reading = entry.kind.read(current.answers[entry.key]), status = statuses.get(entry.key);
+		if (!current || !snapshotIsOutdated) return;
+		snapshotIsOutdated = !1;
+		let views = boundQuestions.map((boundQuestion) => {
+			let reading = boundQuestion.kind.readStoredValue(current.answers[boundQuestion.key]), status = evaluationStatuses.get(boundQuestion.key);
 			return {
-				key: entry.key,
-				question: entry.question,
-				title: entry.title,
-				problem: entry.kind.problem,
+				key: boundQuestion.key,
+				question: boundQuestion.question,
+				title: boundQuestion.title,
+				configError: boundQuestion.kind.configError,
 				reading,
-				stale: !!reading && reading.value.sourceHash !== entry.hash,
+				stale: !!reading && reading.value.sourceHash !== boundQuestion.hash,
 				loading: status?.state === "loading",
 				error: status?.state === "error" ? status.error : null,
 				keyRejected: status?.state === "error" && status.error.kind === "auth"
 			};
-		}), pending = pendingKeys(current, views);
-		for (let view of views) pending.includes(view.key) && (view.loading = !0);
+		}), keysToEvaluate = getKeysToEvaluateAutomatically(current, views);
+		for (let view of views) keysToEvaluate.includes(view.key) && (view.loading = !0);
 		snapshot = {
 			questions: views,
 			canRun: canRun(current),
 			empty: current.state.trim() === "",
 			loading: views.some((view) => view.loading)
-		}, schedule(pending, current.debounceMs);
+		}, scheduleEvaluationAfterDebounce(keysToEvaluate, current.debounceMs);
 		for (let listener of listeners) listener();
 	}
-	function schedule(keys, debounceMs) {
-		let hashes = new Map(entries.map(({ key, hash }) => [key, hash])), signature = keys.map((key) => `${key}:${hashes.get(key)}`).join("\n");
-		signature !== scheduled?.signature && (scheduled?.cancel(), scheduled = void 0, signature && (scheduled = {
+	function scheduleEvaluationAfterDebounce(keys, debounceMs) {
+		let hashesByKey = getHashesByKey(), signature = keys.map((key) => `${key}:${hashesByKey.get(key)}`).join("\n");
+		signature !== scheduledEvaluation?.signature && (scheduledEvaluation?.cancel(), scheduledEvaluation = void 0, signature && (scheduledEvaluation = {
 			signature,
 			cancel: clock.after(debounceMs, () => run(keys))
 		}));
 	}
-	function setStatus(key, status) {
-		status ? statuses.set(key, status) : statuses.delete(key), dirty = !0, refresh();
+	function setEvaluationStatus(key, status) {
+		status ? evaluationStatuses.set(key, status) : evaluationStatuses.delete(key), snapshotIsOutdated = !0, rebuildSnapshotIfOutdated();
 	}
 	function run(keys) {
 		let current = inputs;
 		if (!current?.transport || !canRun(current)) return;
 		let { transport, model, state } = current;
-		for (let entry of entries) {
-			let gatewayQuestion = entry.kind.gatewayQuestion;
-			if (keys && !keys.includes(entry.key) || !gatewayQuestion) continue;
-			requests.get(entry.key)?.controller.abort();
+		for (let boundQuestion of boundQuestions) {
+			let { key, kind, hash } = boundQuestion, gatewayQuestion = kind.gatewayQuestion;
+			if (keys && !keys.includes(key) || !gatewayQuestion) continue;
+			requestsInFlight.get(key)?.controller.abort();
 			let controller = new AbortController();
-			requests.set(entry.key, {
+			requestsInFlight.set(key, {
 				controller,
-				hash: entry.hash
-			}), attempted.set(entry.key, entry.hash), setStatus(entry.key, {
+				hash
+			}), lastAttemptedHashes.set(key, hash), setEvaluationStatus(key, {
 				state: "loading",
-				hash: entry.hash
+				hash
 			});
-			let tag = `${entry.kind.typeName}:${[...current.tagPath, entry.key].filter(Boolean).join(".")}`, evaluate = async () => {
+			let fieldPath = [...current.tagPath, key].filter(Boolean).join("."), questionTag = `${kind.typeName}:${fieldPath}`, evaluateAndStore = async () => {
 				try {
 					let result = await evaluateQuestion({
 						transport,
 						model,
 						state,
 						question: gatewayQuestion,
-						tags: [...current.tags, tag],
+						tags: [...current.tags, questionTag],
 						signal: controller.signal
 					});
 					if (controller.signal.aborted) return;
-					inputs?.store(entry.key, {
-						...entry.kind.toStored(result.answer),
+					inputs?.store(key, {
+						...kind.toStoredValue(result.answer),
 						evaluatedAt: clock.now().toISOString(),
 						model: result.model,
-						sourceHash: entry.hash
-					}), requests.delete(entry.key), setStatus(entry.key, void 0);
+						sourceHash: hash
+					}), requestsInFlight.delete(key), setEvaluationStatus(key, void 0);
 				} catch (error) {
 					if (controller.signal.aborted) return;
-					requests.delete(entry.key), setStatus(entry.key, {
+					requestsInFlight.delete(key), setEvaluationStatus(key, {
 						state: "error",
-						hash: entry.hash,
-						error: error instanceof JevError ? {
-							message: error.message,
-							kind: error.kind,
-							status: error.status,
-							detail: error.detail
-						} : { message: error instanceof Error ? error.message : String(error) }
+						hash,
+						error: toQuestionError(error)
 					});
 				}
 			};
-			evaluate();
+			evaluateAndStore();
 		}
 	}
 	return {
 		update,
 		localEdit() {
-			expectLocal = !0;
+			nextStateIsFromLocalEdit = !0;
 		},
 		run,
 		subscribe(listener) {
@@ -1115,29 +1155,35 @@ function createLifecycle(clock = realClock) {
 		},
 		getSnapshot: () => snapshot,
 		dispose() {
-			scheduled?.cancel(), scheduled = void 0;
-			for (let [key, request] of requests) request.controller.abort(), statuses.delete(key), attempted.delete(key);
-			requests.clear(), dirty = !0;
+			scheduledEvaluation?.cancel(), scheduledEvaluation = void 0;
+			for (let [key, request] of requestsInFlight) request.controller.abort(), evaluationStatuses.delete(key), lastAttemptedHashes.delete(key);
+			requestsInFlight.clear(), snapshotIsOutdated = !0;
 		}
 	};
 }
 const NO_ANSWERS = {};
+function getSetupStatus(hasTransport, keySource) {
+	return hasTransport ? "ready" : keySource.from === "secrets" && keySource.loading ? "loading" : "missing";
+}
 /** Connects the Evaluation lifecycle of one attached field to the Studio's form. */
 function useQuestions({ questions, path, state, readOnly }) {
-	let { config, writers } = useJevForm(), parentPath = useMemo(() => path.slice(0, -1), [path]), keySource = useKeySource(config), apiKey = keySource.apiKey, transport = useMemo(() => config.transport ?? (apiKey ? gatewayTransport(apiKey, config.endpoint) : void 0), [
+	let { config, answerWriters } = useJevForm(), parentPath = useMemo(() => path.slice(0, -1), [path]), keySource = useKeySource(config), { apiKey } = keySource, transport = useMemo(() => resolveTransport({
+		transport: config.transport,
+		endpoint: config.endpoint
+	}, apiKey), [
 		config.transport,
-		apiKey,
-		config.endpoint
-	]), setup = transport ? "ready" : keySource.from === "secrets" && keySource.loading ? "loading" : "missing", parent = useFormValue(parentPath), documentType = useFormValue(["_type"]), store = useCallback((key, value) => {
-		let write = writers.get(pathKey([...parentPath, key]));
-		if (!write) throw Error(`There is no "${key}" field to store this answer in. Wrap your schema types with withJevAnswers() in sanity.config.`);
-		write(value);
-	}, [writers, parentPath]), tagPath = useMemo(() => [typeof documentType == "string" ? documentType : "", ...parentPath.map((segment) => typeof segment == "string" ? segment : "[]")], [documentType, parentPath]), [lifecycle] = useState(() => createLifecycle());
+		config.endpoint,
+		apiKey
+	]), parent = useFormValue(parentPath), documentType = useFormValue(["_type"]), store = useCallback((key, value) => {
+		let writeAnswer = answerWriters.get(toPathKey([...parentPath, key]));
+		if (!writeAnswer) throw Error(`There is no "${key}" field to store this answer in. Wrap your schema types with withJevAnswers() in sanity.config.`);
+		writeAnswer(value);
+	}, [answerWriters, parentPath]), tagPath = useMemo(() => [typeof documentType == "string" ? documentType : "", ...parentPath.map((segment) => typeof segment == "string" ? segment : "[]")], [documentType, parentPath]), [lifecycle] = useState(() => createLifecycle());
 	return useLayoutEffect(() => {
 		lifecycle.update({
 			questions,
 			state,
-			answers: isRecord$1(parent) ? parent : NO_ANSWERS,
+			answers: isRecord(parent) ? parent : NO_ANSWERS,
 			transport,
 			store,
 			model: config.model ?? "typesafe-ai/jev",
@@ -1148,17 +1194,17 @@ function useQuestions({ questions, path, state, readOnly }) {
 		});
 	}), useEffect(() => () => lifecycle.dispose(), [lifecycle]), {
 		...useSyncExternalStore(lifecycle.subscribe, lifecycle.getSnapshot),
-		setup,
-		/** The key is stored with Studio secrets, so editors can set and change it here. */
-		keyInSecrets: keySource.from === "secrets",
-		run: (key) => lifecycle.run([key]),
-		runAll: () => lifecycle.run(),
+		setupStatus: getSetupStatus(!!transport, keySource),
+		/** Editors can set and change the key here, since it is stored with Studio secrets. */
+		isKeyStoredInSecrets: keySource.from === "secrets",
+		evaluateNow: (key) => lifecycle.run([key]),
+		evaluateAllNow: () => lifecycle.run(),
 		localEdit: lifecycle.localEdit
 	};
 }
 /** Renders a field with `options.jev` as usual, with its question strip and details below. */
 function AttachedInput({ questions, ...props }) {
-	let { t } = useTranslation("jev"), parentOnChange = props.onChange, { value } = props, state = toText(value), jev = useQuestions({
+	let { t } = useTranslation("jev"), parentOnChange = props.onChange, state = flattenToText(props.value), jev = useQuestions({
 		questions,
 		path: props.path,
 		state,
@@ -1168,60 +1214,77 @@ function AttachedInput({ questions, ...props }) {
 	}, inputProps = {
 		...props,
 		onChange
-	}, [selected, setSelected] = useState(null), [keyDialogOpen, setKeyDialogOpen] = useState(!1), selectedQuestion = jev.questions.find((question) => question.key === selected);
+	};
+	if ("elementProps" in inputProps && "onChange" in inputProps.elementProps) {
+		let elementProps = inputProps.elementProps;
+		inputProps.elementProps = {
+			...elementProps,
+			onChange: (event) => {
+				jev.localEdit(), elementProps.onChange(event);
+			}
+		};
+	}
+	let [selectedKey, setSelectedKey] = useState(null), [keyDialogOpen, setKeyDialogOpen] = useState(!1), selectedQuestion = jev.questions.find((question) => question.key === selectedKey);
 	return <Stack gap={2}>
       <div>
         {props.renderDefault(inputProps)}
-        <QuestionStrip questions={jev.questions} selected={selected} onSelect={setSelected} setup={jev.setup} canRun={jev.canRun} loading={jev.loading} onRunAll={jev.runAll} onSetUp={() => setKeyDialogOpen(!0)} />
+        <QuestionStrip questions={jev.questions} selectedKey={selectedKey} onSelect={setSelectedKey} setupStatus={jev.setupStatus} canRun={jev.canRun} loading={jev.loading} onEvaluateAll={jev.evaluateAllNow} onSetUp={() => setKeyDialogOpen(!0)} />
       </div>
-      {nearTokenLimit(state) && <Card padding={3} radius={2} tone="caution" border>
+      {isNearTokenLimit(state) && <Card padding={3} radius={2} tone="caution" border>
           <Text size={1}>
             {t("field.too-long", {
-		tokens: Math.round(estimateTokens(state) / 1e3),
+		tokens: Math.round(estimateTokenCount(state) / 1e3),
 		limit: 32
 	})}
           </Text>
         </Card>}
-      {selectedQuestion && <QuestionDetail question={selectedQuestion} empty={jev.empty} onRetry={() => jev.run(selectedQuestion.key)} onUpdateKey={jev.keyInSecrets ? () => setKeyDialogOpen(!0) : void 0} />}
+      {selectedQuestion && <QuestionDetail question={selectedQuestion} empty={jev.empty} onRetry={() => jev.evaluateNow(selectedQuestion.key)} onUpdateKey={jev.isKeyStoredInSecrets ? () => setKeyDialogOpen(!0) : void 0} />}
       {keyDialogOpen && <JevKeyDialog onClose={() => setKeyDialogOpen(!1)} />}
     </Stack>;
 }
-const Code = ({ children }) => <code>{children}</code>, CONNECTION_TEST = kindOf(noul({
+const Code = ({ children }) => <code>{children}</code>, CONNECTION_TEST_QUESTION = bindQuestionToKind(noul({
 	instructions: "Is this text a connection test?",
 	true: "It is a test",
 	false: "It is not a test"
-})).gatewayQuestion, asQuestionError = (error) => error instanceof JevError ? {
-	message: error.message,
-	kind: error.kind,
-	status: error.status,
-	detail: error.detail
-} : { message: error instanceof Error ? error.message : String(error) };
+})).gatewayQuestion;
 /** Studio tool for setting, checking and removing the stored AI Gateway key. */
 function JevTool({ config }) {
-	let { t } = useTranslation("jev"), stored = useStoredKey(), saveKey = useSaveKey(), [settingsOpen, setSettingsOpen] = useState(!1), [confirmRemove, setConfirmRemove] = useState(!1), [test, setTest] = useState({ state: "idle" }), fromConfig = !!(config.transport || config.apiKey), apiKey = config.apiKey ?? stored.apiKey, transport = config.transport ?? (apiKey ? gatewayTransport(apiKey, config.endpoint) : void 0);
+	let { t } = useTranslation("jev"), stored = useStoredKey(), saveKey = useSaveKey(), [keyDialogOpen, setKeyDialogOpen] = useState(!1), [isConfirmingRemove, setIsConfirmingRemove] = useState(!1), [connectionTest, setConnectionTest] = useState({ state: "idle" }), keyIsFromConfig = isKeyFromConfig(config), transport = resolveTransport(config, config.apiKey ?? stored.apiKey);
 	async function testConnection() {
-		if (transport && CONNECTION_TEST) {
-			setTest({ state: "running" });
+		if (transport && CONNECTION_TEST_QUESTION) {
+			setConnectionTest({ state: "running" });
 			try {
 				let result = await evaluateQuestion({
 					transport,
 					model: config.model ?? "typesafe-ai/jev",
 					state: "This is a connection test.",
-					question: CONNECTION_TEST,
+					question: CONNECTION_TEST_QUESTION,
 					tags: [...config.tags ?? DEFAULT_TAGS, "jev:connection-test"]
 				});
-				setTest({
+				setConnectionTest({
 					state: "passed",
 					model: result.model
 				});
 			} catch (error) {
-				setTest({
+				setConnectionTest({
 					state: "failed",
-					error: asQuestionError(error)
+					error: toQuestionError(error)
 				});
 			}
 		}
 	}
+	async function removeStoredKey() {
+		setIsConfirmingRemove(!1);
+		try {
+			await saveKey(void 0), setConnectionTest({ state: "idle" });
+		} catch (error) {
+			let message = error instanceof Error ? error.message : String(error);
+			setConnectionTest({
+				state: "failed",
+				error: { message: t("tool.key.remove-failed", { error: message }) }
+			});
+		}
+	}
 	return <Container width={1} padding={4}>
       <Stack gap={5}>
         <Stack gap={3}>
@@ -1239,10 +1302,10 @@ function JevTool({ config }) {
                   {t("tool.key.heading")}
                 </Heading>
               </Box>
-              <KeyStatus fromConfig={fromConfig} loading={stored.loading} stored={stored.apiKey} />
+              <KeyStatusBadge keyIsFromConfig={keyIsFromConfig} loading={stored.loading} storedKey={stored.apiKey} />
             </Flex>
 
-            {fromConfig ? <Text size={1} muted>
+            {keyIsFromConfig ? <Text size={1} muted>
                 {config.transport ? t("tool.key.from-transport") : t("tool.key.from-config")}
               </Text> : stored.apiKey ? <Stack gap={3}>
                 <Text size={1}>
@@ -1256,37 +1319,26 @@ function JevTool({ config }) {
               </Text>}
 
             <Flex gap={2} wrap="wrap">
-              {!fromConfig && <Button text={stored.apiKey ? t("tool.key.change") : t("tool.key.set")} tone="primary" disabled={stored.loading} onClick={() => setSettingsOpen(!0)} />}
-              <Button text={test.state === "running" ? t("tool.test.running") : t("tool.test.run")} mode="ghost" disabled={!transport || test.state === "running"} onClick={testConnection} />
-              {!fromConfig && stored.apiKey && !confirmRemove && <Button text={t("tool.key.remove")} mode="bleed" tone="critical" onClick={() => setConfirmRemove(!0)} />}
+              {!keyIsFromConfig && <Button text={stored.apiKey ? t("tool.key.change") : t("tool.key.set")} tone="primary" disabled={stored.loading} onClick={() => setKeyDialogOpen(!0)} />}
+              <Button text={connectionTest.state === "running" ? t("tool.test.running") : t("tool.test.run")} mode="ghost" disabled={!transport || connectionTest.state === "running"} onClick={testConnection} />
+              {!keyIsFromConfig && stored.apiKey && !isConfirmingRemove && <Button text={t("tool.key.remove")} mode="bleed" tone="critical" onClick={() => setIsConfirmingRemove(!0)} />}
             </Flex>
 
-            {confirmRemove && <Card padding={3} radius={2} tone="critical">
+            {isConfirmingRemove && <Card padding={3} radius={2} tone="critical">
                 <Flex align="center" gap={2} wrap="wrap">
                   <Box flex={1}>
                     <Text size={1}>{t("tool.key.remove-confirm")}</Text>
                   </Box>
-                  <Button text={t("tool.key.remove-cancel")} mode="bleed" onClick={() => setConfirmRemove(!1)} />
-                  <Button text={t("tool.key.remove-confirm-button")} tone="critical" onClick={async () => {
-		setConfirmRemove(!1);
-		try {
-			await saveKey(void 0), setTest({ state: "idle" });
-		} catch (error) {
-			let message = error instanceof Error ? error.message : String(error);
-			setTest({
-				state: "failed",
-				error: { message: t("tool.key.remove-failed", { error: message }) }
-			});
-		}
-	}} />
+                  <Button text={t("tool.key.remove-cancel")} mode="bleed" onClick={() => setIsConfirmingRemove(!1)} />
+                  <Button text={t("tool.key.remove-confirm-button")} tone="critical" onClick={removeStoredKey} />
                 </Flex>
               </Card>}
 
-            {test.state === "passed" && <Card padding={3} radius={2} tone="positive">
-                <Text size={1}>{t("tool.test.passed", { model: test.model })}</Text>
+            {connectionTest.state === "passed" && <Card padding={3} radius={2} tone="positive">
+                <Text size={1}>{t("tool.test.passed", { model: connectionTest.model })}</Text>
               </Card>}
-            {test.state === "failed" && <Card padding={3} radius={2} tone="critical">
-                <Text size={1}>{errorText(t, test.error)}</Text>
+            {connectionTest.state === "failed" && <Card padding={3} radius={2} tone="critical">
+                <Text size={1}>{translateQuestionError(t, connectionTest.error)}</Text>
               </Card>}
           </Stack>
         </Card>
@@ -1301,14 +1353,14 @@ function JevTool({ config }) {
         </Stack>
       </Stack>
 
-      {settingsOpen && <JevKeyDialog onClose={() => {
-		setSettingsOpen(!1), setTest({ state: "idle" });
+      {keyDialogOpen && <JevKeyDialog onClose={() => {
+		setKeyDialogOpen(!1), setConnectionTest({ state: "idle" });
 	}} />}
     </Container>;
 }
-function KeyStatus({ fromConfig, loading, stored }) {
+function KeyStatusBadge({ keyIsFromConfig, loading, storedKey }) {
 	let { t } = useTranslation("jev");
-	return fromConfig ? <Badge tone="primary">{t("tool.key.status.config")}</Badge> : loading ? <Badge>{t("tool.key.status.checking")}</Badge> : stored ? <Badge tone="positive">{t("tool.key.status.set")}</Badge> : <Badge tone="caution">{t("tool.key.status.not-set")}</Badge>;
+	return keyIsFromConfig ? <Badge tone="primary">{t("tool.key.status.config")}</Badge> : loading ? <Badge>{t("tool.key.status.checking")}</Badge> : storedKey ? <Badge tone="positive">{t("tool.key.status.set")}</Badge> : <Badge tone="caution">{t("tool.key.status.not-set")}</Badge>;
 }
 /**
 * Jev questions for Sanity Studio: yes/no, score and choice questions attached to a field with
@@ -1317,18 +1369,18 @@ function KeyStatus({ fromConfig, loading, stored }) {
 * @public
 */
 const jev = definePlugin((config) => {
-	let pluginConfig = config ?? {};
+	let pluginConfig = config ?? {}, jevTool = {
+		name: "jev",
+		title: "Jev",
+		icon: SparklesIcon,
+		component: () => <JevTool config={pluginConfig} />
+	};
 	return {
 		name: "jev",
-		tools: pluginConfig.tool === !1 ? [] : [{
-			name: "jev",
-			title: "Jev",
-			icon: SparklesIcon,
-			component: () => <JevTool config={pluginConfig} />
-		}],
+		tools: pluginConfig.tool === !1 ? [] : [jevTool],
 		form: { components: { input: (props) => {
 			if (props.path.length === 0) return <JevFormProvider config={pluginConfig}>{props.renderDefault(props)}</JevFormProvider>;
-			let questions = questionsOf(props.schemaType);
+			let questions = getQuestionsFromDefinition(props.schemaType);
 			return questions ? <AttachedInput {...props} questions={questions} /> : props.renderDefault(props);
 		} } },
 		schema: { types: KIND_SCHEMA_TYPES },