sanity-plugin-jev-fields 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1340 @@
+import { SparklesIcon } from "@sanity/icons/Sparkles";
+import { Translate, defineArrayMember, defineField, defineLocaleResourceBundle, definePlugin, defineType, set, useClient, useDocumentPreviewStore, useFormValue, useTranslation } from "sanity";
+import { Badge, Box, Button, Card, Container, Dialog, Flex, Heading, Spinner, Stack, Text, TextInput } from "@sanity/ui";
+import { createContext, useCallback, useContext, useEffect, useId, useLayoutEffect, useMemo, useState, useSyncExternalStore } from "react";
+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) {
+	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);
+	}
+	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") : "";
+}
+function isBlock(value) {
+	return isRecord$1(value) && value._type === "block" && Array.isArray(value.children);
+}
+function isRecord$1(value) {
+	return !!value && typeof value == "object" && !Array.isArray(value);
+}
+/** FNV-1a: a small, stable fingerprint; collisions only cost a skipped re-evaluation. */
+function fingerprint(input) {
+	let text = JSON.stringify(input), hash = 2166136261;
+	for (let i = 0; i < text.length; i++) hash ^= text.charCodeAt(i), hash = Math.imul(hash, 16777619);
+	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);
+/** 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(() => ({
+		config,
+		writers
+	}), [config, writers]);
+	return <Context.Provider value={value}>{children}</Context.Provider>;
+}
+function useJevForm() {
+	let context = useContext(Context);
+	if (!context) throw Error("Jev signals need the jev() plugin in sanity.config.");
+	return context;
+}
+/**
+* Field component for answer fields: shows nothing (answers appear on the attached field) and
+* 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);
+	}), [
+		writers,
+		key,
+		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);
+/** Red at 0, amber in the middle, green at 1. */
+function trafficColor(fraction) {
+	return `hsl(${Math.round(clamp(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);
+	return <Box flex={1} role="meter" aria-valuemin={0} aria-valuemax={100} aria-valuenow={percent} aria-label={label} style={{
+		height: 4,
+		borderRadius: 4,
+		overflow: "hidden",
+		background: "var(--card-border-color)"
+	}}>
+      <div style={{
+		width: `${percent}%`,
+		height: "100%",
+		borderRadius: 4,
+		background: color,
+		transition: "width 400ms ease, background-color 400ms ease"
+	}} />
+    </Box>;
+}
+/** Schema type names. Stored as `_type` on every value, so frontends query them: keep stable. */
+const TYPE_NAMES = {
+	noul: "jev.noul",
+	score: "jev.score",
+	choice: "jev.choice",
+	choiceProbability: "jev.choiceProbability"
+}, round = (value, digits = 4) => Math.round(value * 10 ** digits) / 10 ** digits;
+function mismatch() {
+	throw Error("Jev answered a different kind of question.");
+}
+const bookkeepingFields = [
+	defineField({
+		name: "evaluatedAt",
+		type: "datetime",
+		readOnly: !0
+	}),
+	defineField({
+		name: "model",
+		type: "string",
+		readOnly: !0
+	}),
+	defineField({
+		name: "sourceHash",
+		type: "string",
+		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;
+}
+/** The bookkeeping fields a stored value has. */
+function bookkeepingOf(stored) {
+	return {
+		evaluatedAt: text(stored.evaluatedAt),
+		model: text(stored.model),
+		sourceHash: text(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"]) {
+		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}.`;
+		}
+	}
+}
+/** How `value` breaks a range rule, e.g. `below 60%`, using `format` for both numbers. */
+function rangeViolation(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 signal can't be asked, if it can't. */
+function choiceProblem(signal, options) {
+	if (options.length < 2) return "A choice signal needs at least two options.";
+	if (options.length > 255) return "A choice signal allows at most 255 options.";
+	for (let level of ["warn", "require"]) {
+		let rule = signal[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.`;
+	}
+}
+/** One option from a named set. @public */
+const choice = (signal) => ({
+	type: "choice",
+	...signal
+}), choiceSchemaTypes = [defineType({
+	name: TYPE_NAMES.choiceProbability,
+	title: "Jev choice probability",
+	type: "object",
+	fields: [defineField({
+		name: "option",
+		type: "string"
+	}), defineField({
+		name: "probability",
+		type: "number"
+	})]
+}), defineType({
+	name: TYPE_NAMES.choice,
+	title: "Jev choice",
+	type: "object",
+	components: { field: AnswerField },
+	fields: [
+		defineField({
+			name: "choice",
+			type: "string",
+			readOnly: !0
+		}),
+		defineField({
+			name: "confidence",
+			type: "number",
+			readOnly: !0
+		}),
+		defineField({
+			name: "probabilities",
+			type: "array",
+			readOnly: !0,
+			of: [defineArrayMember({ type: TYPE_NAMES.choiceProbability })]
+		}),
+		...bookkeepingFields
+	]
+})];
+function bindChoice(signal) {
+	let criteria = signal.criteria ?? {}, problem = choiceProblem(signal, Object.keys(criteria));
+	return {
+		typeName: TYPE_NAMES.choice,
+		question: problem ? void 0 : {
+			type: "choice",
+			instructions: signal.instructions,
+			criteria: signal.criteria
+		},
+		problem,
+		toStored(answer) {
+			return answer.type === "choice" ? {
+				_type: TYPE_NAMES.choice,
+				choice: answer.choice,
+				confidence: round(answer.confidence ?? answer.probabilities[answer.choice] ?? 0),
+				probabilities: Object.keys(criteria).map((option, index) => ({
+					_key: `option-${index}`,
+					_type: TYPE_NAMES.choiceProbability,
+					option,
+					probability: round(answer.probabilities[option] ?? 0)
+				}))
+			} : mismatch();
+		},
+		read(stored) {
+			let record = storedOf(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];
+			return {
+				value: {
+					...bookkeepingOf(record),
+					_type: TYPE_NAMES.choice,
+					choice: record.choice,
+					confidence: number(record.confidence),
+					probabilities
+				},
+				chip: {
+					text: capitalize(record.choice),
+					color: NEUTRAL_COLOR
+				},
+				tone: "default",
+				aside: meaning ? { note: meaning } : void 0,
+				body: <ChoiceBody signal={signal} choice={record.choice} probabilities={probabilities} />
+			};
+		},
+		check(level, stored, title) {
+			let record = storedOf(stored, TYPE_NAMES.choice), rule = signal[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 ")}.`;
+		}
+	};
+}
+function ChoiceBody({ signal, choice, probabilities }) {
+	let options = Object.keys(signal.criteria), nameWidth = `${Math.max(...options.map((name) => name.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);
+		return <Flex key={option} align="center" gap={3}>
+            <Box style={{ width: nameWidth }}>
+              <Text size={1} weight={winner ? "semibold" : "regular"} muted={!winner}>
+                {capitalize(option)}
+              </Text>
+            </Box>
+            <Bar fraction={probability} color={winner ? NEUTRAL_COLOR : "hsl(215 12% 55%)"} label={`${option}: ${percent}%`} />
+            <Box style={{
+			minWidth: "4ch",
+			textAlign: "right"
+		}}>
+              <Text size={1} muted={!winner}>
+                {percent}%
+              </Text>
+            </Box>
+          </Flex>;
+	})}
+    </Stack>;
+}
+/** The plugin's translation namespace: `useTranslation(JEV_NAMESPACE)`. */
+const JEV_NAMESPACE = "jev", jevLocaleBundle = defineLocaleResourceBundle({
+	locale: "en-US",
+	namespace: "jev",
+	resources: {
+		"strip.label": "Jev",
+		"strip.set-up": "Set up Jev",
+		"strip.evaluate-all": "Evaluate all signals now",
+		"chip.empty": "–",
+		"chip.error": "Error",
+		"chip.out-of-date": "Out of date",
+		"detail.empty-field": "Add content to this field to evaluate it.",
+		"detail.not-evaluated": "Not evaluated yet.",
+		"detail.out-of-date": "Out of date: the field changed since this was evaluated.",
+		"detail.update-key": "Update API key",
+		"detail.try-again": "Try again",
+		"field.too-long": "This field is about {{tokens}}k tokens long. Jev reads at most {{limit}}k per question, so longer text may be refused.",
+		"error.auth": "AI Gateway rejected the API key. Check the key in the Jev tool.",
+		"error.invalid": "AI Gateway rejected the question: {{detail}}",
+		"error.busy": "AI Gateway is busy. Try again in a moment.",
+		"error.failed": "AI Gateway responded with {{status}}.",
+		"error.failed-with-detail": "AI Gateway responded with {{status}}: {{detail}}",
+		"error.unexpected": "AI Gateway returned no answer.",
+		"noul.level.low": "Low",
+		"noul.level.medium": "Medium",
+		"noul.level.high": "High",
+		"noul.yes": "Yes",
+		"score.summary": "{{meaning}} (score {{score}} of {{max}}).",
+		"score.next": "To move up: {{next}}.",
+		"key-dialog.title": "AI Gateway API key",
+		"key-dialog.label": "API key",
+		"key-dialog.description": "Create one in the Vercel dashboard under AI Gateway → API Keys, ideally with a spend limit. It is stored in this dataset, so Studio users and API tokens that can read the dataset can see it.",
+		"key-dialog.cancel": "Cancel",
+		"key-dialog.save": "Save",
+		"key-dialog.saving": "Saving…",
+		"key-dialog.save-failed": "Could not save the key: {{error}}",
+		"tool.title": "Jev",
+		"tool.intro": "Jev signals are answered by TypeSafe’s Jev model through Vercel AI Gateway.",
+		"tool.key.heading": "AI Gateway API key",
+		"tool.key.status.config": "From plugin config",
+		"tool.key.status.checking": "Checking",
+		"tool.key.status.set": "Set",
+		"tool.key.status.not-set": "Not set",
+		"tool.key.from-transport": "Requests go through the transport in the plugin config, so no key is needed here.",
+		"tool.key.from-config": "The key comes from apiKey in the plugin config. A key stored here is ignored.",
+		"tool.key.ends-with": "Key ending in <Code>{{last4}}</Code>",
+		"tool.key.changed": "Last changed {{date}}",
+		"tool.key.checking": "Checking for a stored key…",
+		"tool.key.none": "No key is stored, so Jev signals cannot evaluate yet.",
+		"tool.key.set": "Set key",
+		"tool.key.change": "Change key",
+		"tool.key.remove": "Remove key",
+		"tool.key.remove-confirm": "Remove the key? Jev signals stop evaluating until a new one is set.",
+		"tool.key.remove-cancel": "Cancel",
+		"tool.key.remove-confirm-button": "Remove",
+		"tool.key.remove-failed": "Could not remove the key: {{error}}",
+		"tool.test.run": "Test connection",
+		"tool.test.running": "Testing…",
+		"tool.test.passed": "Connection works. {{model}} answered.",
+		"tool.visibility.heading": "Who can see the key",
+		"tool.visibility.body": "The key is stored in this dataset in the document <Code>secrets.jev</Code>. It is not public, but anyone who can read the dataset can see it: every Studio user, and every API token with read access, such as a frontend’s read or preview token. It is also included in dataset exports and backups. Use a dedicated key with a spend limit. If editors and tokens must never see the key, set a <Code>transport</Code> that sends requests through your own server."
+	}
+}), noul = (signal) => ({
+	type: "noul",
+	...signal
+}), noulSchemaTypes = [defineType({
+	name: TYPE_NAMES.noul,
+	title: "Jev yes/no",
+	type: "object",
+	components: { field: AnswerField },
+	fields: [defineField({
+		name: "probability",
+		type: "number",
+		readOnly: !0
+	}), ...bookkeepingFields]
+})], LEVELS$1 = {
+	critical: "low",
+	caution: "medium",
+	positive: "high"
+};
+function bindNoul(signal) {
+	let problem = !signal.true?.trim() || !signal.false?.trim() ? "A noul signal needs both `true` and `false` text." : rangeRuleProblem(signal, 0, 1);
+	return {
+		typeName: TYPE_NAMES.noul,
+		question: problem ? void 0 : {
+			type: "boolean",
+			instructions: signal.instructions,
+			criteria: {
+				true: signal.true,
+				false: signal.false
+			}
+		},
+		problem,
+		toStored(answer) {
+			return answer.type === "boolean" ? {
+				_type: TYPE_NAMES.noul,
+				probability: round(answer.probability)
+			} : mismatch();
+		},
+		read(stored) {
+			let record = storedOf(stored, TYPE_NAMES.noul);
+			if (!record || typeof record.probability != "number") return;
+			let probability = record.probability, tone = trafficTone(probability);
+			return {
+				value: {
+					...bookkeepingOf(record),
+					_type: TYPE_NAMES.noul,
+					probability
+				},
+				chip: {
+					text: `${Math.round(probability * 100)}%`,
+					color: trafficColor(probability)
+				},
+				tone: tone === "positive" ? "default" : tone,
+				aside: {
+					level: LEVELS$1[tone] ?? "medium",
+					tone
+				},
+				body: <NoulBody signal={signal} probability={probability} />
+			};
+		},
+		check(level, stored, title) {
+			let record = storedOf(stored, TYPE_NAMES.noul);
+			if (!record || typeof record.probability != "number") return;
+			let percent = (value) => `${Math.round(value * 100)}%`, broken = rangeViolation(record.probability, signal[level], percent);
+			return broken && `${title} is ${percent(record.probability)}, ${broken}.`;
+		}
+	};
+}
+function NoulBody({ signal, probability }) {
+	let { t } = useTranslation("jev"), percent = Math.round(probability * 100);
+	return <Stack gap={4}>
+      <Flex align="baseline" gap={2}>
+        <Text size={4} weight="medium">
+          {percent}%
+        </Text>
+        {signal.label && <Text size={1} muted>
+            {signal.label}
+          </Text>}
+      </Flex>
+      <Bar fraction={probability} color={trafficColor(probability)} label={`${signal.title ?? t("noul.yes")}: ${percent}%`} />
+      <Text size={1} muted>
+        {probability >= .5 ? signal.true : signal.false}
+      </Text>
+    </Stack>;
+}
+/** A position on an ordered scale. @public */
+const score = (signal) => ({
+	type: "score",
+	...signal
+}), scoreSchemaTypes = [defineType({
+	name: TYPE_NAMES.score,
+	title: "Jev score",
+	type: "object",
+	components: { field: AnswerField },
+	fields: [
+		defineField({
+			name: "score",
+			type: "number",
+			readOnly: !0
+		}),
+		defineField({
+			name: "max",
+			type: "number",
+			readOnly: !0
+		}),
+		defineField({
+			name: "label",
+			type: "string",
+			readOnly: !0
+		}),
+		defineField({
+			name: "confidence",
+			type: "number",
+			readOnly: !0
+		}),
+		...bookkeepingFields
+	]
+})], shortLabel = (criterion) => criterion?.split(":")[0].trim() ?? "";
+/** `'anecdotal: personal experience'` → `'personal experience'`; without a colon, the whole text. */
+function meaningOf(criterion) {
+	if (!criterion) return "";
+	let colon = criterion.indexOf(":");
+	return (colon === -1 ? criterion : criterion.slice(colon + 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)));
+}
+/** Colour and tone of a score, from the criterion it is nearest to. */
+function scoreLook(signal, value, max) {
+	if (signal.colors === "neutral") return {
+		color: NEUTRAL_COLOR,
+		tone: "primary"
+	};
+	let fraction = max > 0 ? Math.round(value) / max : 0, good = signal.colors === "reverse" ? 1 - fraction : fraction;
+	return {
+		color: trafficColor(good),
+		tone: trafficTone(good)
+	};
+}
+function bindScore(signal) {
+	let { criteria } = signal, problem = !Array.isArray(criteria) || criteria.length < 2 ? "A score signal needs at least two criteria." : criteria.length > 10 ? "A score signal allows at most ten criteria." : rangeRuleProblem(signal, 0, criteria.length - 1);
+	return {
+		typeName: TYPE_NAMES.score,
+		question: problem ? void 0 : {
+			type: "score",
+			instructions: signal.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));
+			return {
+				_type: TYPE_NAMES.score,
+				score: round(value),
+				max,
+				label: shortLabel(criteria[Math.round(value)]),
+				...typeof answer.confidence == "number" && { confidence: round(answer.confidence) }
+			};
+		},
+		read(stored) {
+			let record = storedOf(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(signal, value, max);
+			return {
+				value: {
+					...bookkeepingOf(record),
+					_type: TYPE_NAMES.score,
+					score: value,
+					max,
+					label,
+					confidence: number(record.confidence)
+				},
+				chip: {
+					text: `${value.toFixed(1)}/${max}`,
+					color: look.color
+				},
+				tone: look.tone === "critical" || look.tone === "caution" ? look.tone : "default",
+				aside: {
+					badge: capitalize(label ?? shortLabel(criteria?.[Math.round(value)])),
+					tone: look.tone
+				},
+				body: <ScoreBody signal={signal} score={value} max={max} color={look.color} />
+			};
+		},
+		check(level, stored, title) {
+			let record = storedOf(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, signal[level], describe);
+			return broken && `${title} is ${describe(record.score)}, ${broken}.`;
+		}
+	};
+}
+function ScoreBody({ signal, score, max, color }) {
+	let { t } = useTranslation("jev"), nearest = Math.round(score), fills = segmentFills(score, signal.criteria.length), next = signal.criteria[nearest + 1];
+	return <Stack gap={4}>
+      <Flex gap={1}>
+        {signal.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))}
+            </Text>
+          </Stack>)}
+      </Flex>
+      <Text size={1} muted>
+        {t("score.summary", {
+		meaning: capitalize(meaningOf(signal.criteria[nearest])),
+		score: score.toFixed(1),
+		max
+	})}
+        {next ? ` ${t("score.next", { next: meaningOf(next) })}` : ""}
+      </Text>
+    </Stack>;
+}
+/** Where every kind stores its answers. */
+const KIND_SCHEMA_TYPES = [
+	...noulSchemaTypes,
+	...scoreSchemaTypes,
+	...choiceSchemaTypes
+];
+/** Binds a signal to its kind. The one place that tells Noul, Score and Choice apart. */
+function kindOf(signal) {
+	let kind = bind(signal);
+	return signal.instructions?.trim() ? kind : {
+		...kind,
+		question: void 0,
+		problem: "Add instructions to this signal."
+	};
+}
+function bind(signal) {
+	switch (signal.type) {
+		case "noul": return bindNoul(signal);
+		case "score": return bindScore(signal);
+		case "choice": return bindChoice(signal);
+		default: return {
+			typeName: "unknown",
+			problem: "Unknown signal type.",
+			toStored: mismatch,
+			read: () => void 0,
+			check: () => void 0
+		};
+	}
+}
+/** `readable` → `Readable`, `readingLevel` → `Reading level`. */
+function titleOf(key, signal) {
+	if (signal.title) return signal.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 signalsOf(definition) {
+	if (!isRecord(definition) || !isRecord(definition.options)) return;
+	let { jev } = definition.options;
+	return isRecord(jev) ? jev : void 0;
+}
+/**
+* Adds a field that stores each signal's answer next to every field with `options.jev`.
+* Plugins can't see the Studio's own schema types, so wrap them in `sanity.config`:
+*
+* ```ts
+* schema: {types: withJevAnswers(schemaTypes)}
+* ```
+* @public
+*/
+function withJevAnswers(types) {
+	return types.map((type) => withAnswerFields(type));
+}
+/** Rewrites `fields` (and inline object members) of a type or field definition, recursively. */
+function withAnswerFields(definition) {
+	if (!isRecord(definition)) return definition;
+	let result = definition;
+	if (Array.isArray(definition.of) && (result = {
+		...result,
+		of: definition.of.map(withAnswerFields)
+	}), 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), signals = signalsOf(field);
+			return !signals || !isRecord(field) || !isRecord(rewritten) ? [rewritten] : [withRules(rewritten, signals), ...answerFieldsFor(field, signals, existing)];
+		});
+		result = {
+			...result,
+			fields
+		};
+	}
+	return result;
+}
+function answerFieldsFor(field, signals, existing) {
+	return Object.entries(signals).flatMap(([key, signal]) => {
+		let type = TYPE_NAMES[signal.type];
+		if (existing.get(key) === type) return [];
+		if (existing.has(key)) throw Error(`Jev: the signal "${key}" on "${String(field.name)}" needs a field called "${key}" to store its answer, but that name is already taken. Rename the signal.`);
+		return existing.set(key, type), [defineField({
+			name: key,
+			title: titleOf(key, signal),
+			type,
+			group: typeof field.group == "string" || Array.isArray(field.group) ? field.group : void 0,
+			fieldset: typeof field.fieldset == "string" ? field.fieldset : void 0
+		})];
+	});
+}
+const LEVELS = ["warn", "require"];
+/**
+* Adds a validation rule to the attached field for each signal'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, signals) {
+	let checks = Object.entries(signals).flatMap(([key, signal]) => LEVELS.filter((level) => signal[level]).map((level) => ({
+		key,
+		signal,
+		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, signal, level }) => {
+			let kind = kindOf(signal), title = titleOf(key, signal), custom = rule.custom((_value, context) => {
+				let stored = isRecord(context.parent) ? context.parent[key] : void 0;
+				return kind.check(level, stored, title) ?? !0;
+			});
+			return level === "require" ? custom.error() : custom.warning();
+		});
+		return [...ownRules, ...jevRules];
+	};
+	return {
+		...field,
+		validation
+	};
+}
+const SECRETS_ID = "secrets.jev";
+/** 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;
+			setStored({
+				loading: !1,
+				apiKey: typeof apiKey == "string" && apiKey ? apiKey : void 0,
+				updatedAt: document?._updatedAt
+			});
+		});
+		return () => subscription.unsubscribe();
+	}, [documentPreviewStore]), stored;
+}
+/** Stores a new key, or removes the stored one when `apiKey` is undefined. */
+function useSaveKey() {
+	let client = useClient({ apiVersion: "2025-02-19" });
+	return async (apiKey) => {
+		await client.transaction().createIfNotExists({
+			_id: SECRETS_ID,
+			_type: "pluginSecrets"
+		}).patch(SECRETS_ID, (patch) => apiKey ? patch.set({ secrets: { gatewayApiKey: apiKey } }) : patch.unset(["secrets"])).commit({ tag: "jev.secrets" });
+	};
+}
+/** Where the API key comes from: plugin config wins over the stored key. */
+function useKeySource(config) {
+	let stored = useStoredKey();
+	return config.transport || config.apiKey ? {
+		from: "config",
+		apiKey: config.apiKey
+	} : {
+		from: "secrets",
+		loading: stored.loading,
+		apiKey: stored.apiKey
+	};
+}
+/** Dialog for entering or replacing the stored key. Closes once the key is saved. */
+function JevKeyDialog({ onClose }) {
+	let { t } = useTranslation("jev"), saveKey = useSaveKey(), inputId = useId(), [value, setValue] = useState(""), [saving, setSaving] = useState(!1), [error, setError] = useState(null);
+	async function save() {
+		setSaving(!0), setError(null);
+		try {
+			await saveKey(value.trim()), onClose();
+		} catch (saveError) {
+			setSaving(!1), setError(saveError instanceof Error ? saveError.message : String(saveError));
+		}
+	}
+	return <Dialog id="jev-key-dialog" header={t("key-dialog.title")} onClose={onClose} width={1}>
+      <Box as="form" padding={4} onSubmit={(event) => {
+		event.preventDefault(), save();
+	}}>
+        <Stack gap={4}>
+          <Stack gap={3}>
+            <Text as="label" htmlFor={inputId} size={1} weight="semibold">
+              {t("key-dialog.label")}
+            </Text>
+            <Text size={1} muted>
+              {t("key-dialog.description")}
+            </Text>
+            <TextInput id={inputId} type="password" autoComplete="off" value={value} disabled={saving} onChange={(event) => setValue(event.currentTarget.value)} />
+          </Stack>
+
+          {error && <Card padding={3} radius={2} tone="critical">
+              <Text size={1}>{t("key-dialog.save-failed", { error })}</Text>
+            </Card>}
+
+          <Flex gap={2} justify="flex-end">
+            <Button text={t("key-dialog.cancel")} mode="bleed" disabled={saving} onClick={onClose} />
+            <Button type="submit" text={t(saving ? "key-dialog.saving" : "key-dialog.save")} tone="primary" disabled={saving || value.trim() === ""} />
+          </Flex>
+        </Stack>
+      </Box>
+    </Dialog>;
+}
+/** An evaluation error in the Studio's language; errors from outside the Gateway as they are. */
+function errorText(t, error) {
+	switch (error.kind) {
+		case "auth": return t("error.auth");
+		case "invalid": return t("error.invalid", { detail: error.detail ?? error.status });
+		case "busy": return t("error.busy");
+		case "failed": return error.detail ? t("error.failed-with-detail", {
+			status: error.status,
+			detail: error.detail
+		}) : t("error.failed", { status: error.status });
+		case "unexpected": return t("error.unexpected");
+		default: return error.message;
+	}
+}
+const pulse = keyframes`
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.25; }
+`, Dot = styled.span`
+  flex: none;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: ${({ $color }) => $color};
+  animation: ${({ $pulse }) => $pulse ? pulse : "none"} 1s ease-in-out infinite;
+`;
+function Chip({ signal, selected, onSelect }) {
+	let { t } = useTranslation("jev"), { text, color } = signal.reading?.chip ?? {
+		text: t("chip.empty"),
+		color: void 0
+	}, failed = !!signal.error || !!signal.problem;
+	return <Card as="button" type="button" radius={2} paddingX={2} paddingY={2} onClick={onSelect} aria-pressed={selected} title={signal.stale ? t("chip.out-of-date") : void 0} style={{
+		display: "inline-flex",
+		flex: "none",
+		width: "auto",
+		border: 0,
+		cursor: "pointer",
+		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={signal.loading} />
+        {}
+        <Text size={1}>
+          {signal.title}
+          <span style={{
+		marginLeft: "0.6em",
+		fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+		color: failed ? "#f03e2f" : color,
+		opacity: signal.stale ? .5 : 1
+	}}>
+            {failed ? t("chip.error") : text}
+          </span>
+        </Text>
+      </Flex>
+    </Card>;
+}
+/** The row of signal chips under an attached field. */
+function SignalStrip({ signals, selected, onSelect, setup, canRun, loading, onRunAll, onSetUp }) {
+	let { t } = useTranslation("jev");
+	return <Card border padding={1} style={{
+		borderTop: 0,
+		marginTop: -2,
+		borderBottomLeftRadius: 3,
+		borderBottomRightRadius: 3
+	}}>
+      <Flex align="center" gap={2}>
+        <Flex flex={1} align="center" gap={1} wrap="wrap">
+          {signals.map((signal) => <Chip key={signal.key} signal={signal} selected={selected === signal.key} onSelect={() => onSelect(selected === signal.key ? null : signal.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}>
+            <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} />}
+          </Flex>}
+      </Flex>
+    </Card>;
+}
+/** Expanded view of the selected chip. */
+function SignalDetail({ signal, empty, onRetry, onUpdateKey }) {
+	let { t } = useTranslation("jev"), { reading } = signal, body = signal.problem ? <Text size={1}>{signal.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={signal.problem ? "critical" : reading?.tone ?? "default"}>
+      <Stack gap={4}>
+        <Flex align="center" gap={3}>
+          <Box flex={1}>
+            <Text size={1} weight="semibold">
+              {signal.title}
+            </Text>
+          </Box>
+          {aside}
+        </Flex>
+        {body}
+        {signal.stale && !signal.loading && <Text size={0} muted>
+            {t("detail.out-of-date")}
+          </Text>}
+        {signal.error && <Card padding={3} radius={2} tone="critical" border>
+            <Flex align="center" gap={3} wrap="wrap">
+              <Box flex={1}>
+                <Text size={1}>{errorText(t, signal.error)}</Text>
+              </Box>
+              {signal.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>
+          </Card>}
+      </Stack>
+    </Card>;
+}
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if (_typeof(t) != "object" || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (e !== void 0) {
+		var i = e.call(t, r || "default");
+		if (_typeof(i) != "object") return i;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (r === "string" ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return _typeof(i) == "symbol" ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+const DEFAULT_TAGS = ["feature:jev-fields"], RETRY_STATUSES = /* @__PURE__ */ new Set([
+	429,
+	502,
+	503,
+	504,
+	529
+]), DEFAULT_RETRY_DELAYS = [
+	500,
+	1e3,
+	2e3
+];
+/**
+* An evaluation that failed. `message` is in English; the Studio shows a translated text built
+* from `kind`, `status` and `detail` (the Gateway's own explanation).
+*/
+var JevError = class extends Error {
+	constructor(kind, message, status, detail) {
+		super(message), _defineProperty(this, "kind", void 0), _defineProperty(this, "status", void 0), _defineProperty(this, "detail", void 0), this.name = "JevError", this.kind = kind, this.status = status, this.detail = detail;
+	}
+};
+/** 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") {
+	return (request, { signal }) => fetch(endpoint, {
+		method: "POST",
+		signal,
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(request)
+	});
+}
+/**
+* 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.
+*/
+async function evaluateQuestion({ transport, model, state, question, tags, signal, retryDelays = DEFAULT_RETRY_DELAYS }) {
+	let request = {
+		model,
+		state,
+		questions: { q: question },
+		providerOptions: { gateway: { tags: normalizeTags(tags) } }
+	}, send = async (attempt) => {
+		let response = await transport(request, { signal }), body = await response.json().catch(() => ({}));
+		if (response.ok) {
+			let answer = body.answers?.q;
+			if (answer?.type !== question.type) throw new JevError("unexpected", "AI Gateway returned no answer.", response.status);
+			return {
+				answer,
+				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));
+	};
+	return send(0);
+}
+function toError(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) {
+	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 sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason);
+		let timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout), reject(signal.reason);
+		}, { once: !0 });
+	});
+}
+function normalizeTags(tags) {
+	let cleaned = tags.map((tag) => tag.trim().slice(0, 64)).filter(Boolean);
+	return [...new Set(cleaned)].slice(0, 10);
+}
+const realClock = {
+	now: () => /* @__PURE__ */ new Date(),
+	after(ms, callback) {
+		let timeout = setTimeout(callback, ms);
+		return () => clearTimeout(timeout);
+	}
+}, EMPTY = {
+	signals: [],
+	canRun: !1,
+	empty: !0,
+	loading: !1
+};
+/**
+* The Evaluation lifecycle of the signals on one attached field. Signals evaluate on their own
+* shortly after a local edit, only while the field's state is one this Studio produced; work for
+* 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() !== "";
+	function update(next) {
+		let previous = inputs;
+		inputs = next, next.state !== previous?.state && (localState = expectLocal ? next.state : void 0, expectLocal = !1), (!previous || next.signals !== previous.signals || next.state !== previous.state || next.model !== previous.model) && (entries = Object.entries(next.signals).map(([key, signal]) => {
+			let kind = kindOf(signal);
+			return {
+				key,
+				signal,
+				kind,
+				title: titleOf(key, signal),
+				hash: fingerprint([
+					next.state,
+					kind.question ?? null,
+					next.model
+				])
+			};
+		}), forgetObsoleteWork(), dirty = !0), previous && (canRun(next) !== canRun(previous) || entries.some(({ key }) => next.answers[key] !== previous.answers[key])) && (dirty = !0), refresh();
+	}
+	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);
+	}
+	/** Signals 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.question && (!view.reading || view.stale) && attempted.get(entry.key) !== entry.hash;
+		}).map(({ key }) => key);
+	}
+	/** Rebuilds the snapshot and the debounce after anything they depend on changed. */
+	function refresh() {
+		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);
+			return {
+				key: entry.key,
+				signal: entry.signal,
+				title: entry.title,
+				problem: entry.kind.problem,
+				reading,
+				stale: !!reading && reading.value.sourceHash !== entry.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);
+		snapshot = {
+			signals: views,
+			canRun: canRun(current),
+			empty: current.state.trim() === "",
+			loading: views.some((view) => view.loading)
+		}, schedule(pending, 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 = {
+			signature,
+			cancel: clock.after(debounceMs, () => run(keys))
+		}));
+	}
+	function setStatus(key, status) {
+		status ? statuses.set(key, status) : statuses.delete(key), dirty = !0, refresh();
+	}
+	function run(keys) {
+		let current = inputs;
+		if (!current?.transport || !canRun(current)) return;
+		let { transport, model, state } = current;
+		for (let entry of entries) {
+			let question = entry.kind.question;
+			if (keys && !keys.includes(entry.key) || !question) continue;
+			requests.get(entry.key)?.controller.abort();
+			let controller = new AbortController();
+			requests.set(entry.key, {
+				controller,
+				hash: entry.hash
+			}), attempted.set(entry.key, entry.hash), setStatus(entry.key, {
+				state: "loading",
+				hash: entry.hash
+			});
+			let tag = `${entry.kind.typeName}:${[...current.tagPath, entry.key].filter(Boolean).join(".")}`, evaluate = async () => {
+				try {
+					let result = await evaluateQuestion({
+						transport,
+						model,
+						state,
+						question,
+						tags: [...current.tags, tag],
+						signal: controller.signal
+					});
+					if (controller.signal.aborted) return;
+					inputs?.store(entry.key, {
+						...entry.kind.toStored(result.answer),
+						evaluatedAt: clock.now().toISOString(),
+						model: result.model,
+						sourceHash: entry.hash
+					}), requests.delete(entry.key), setStatus(entry.key, void 0);
+				} catch (error) {
+					if (controller.signal.aborted) return;
+					requests.delete(entry.key), setStatus(entry.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) }
+					});
+				}
+			};
+			evaluate();
+		}
+	}
+	return {
+		update,
+		localEdit() {
+			expectLocal = !0;
+		},
+		run,
+		subscribe(listener) {
+			return listeners.add(listener), () => {
+				listeners.delete(listener);
+			};
+		},
+		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;
+		}
+	};
+}
+const NO_ANSWERS = {};
+/** Connects the Evaluation lifecycle of one attached field to the Studio's form. */
+function useSignals({ signals, 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), [
+		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());
+	return useLayoutEffect(() => {
+		lifecycle.update({
+			signals,
+			state,
+			answers: isRecord$1(parent) ? parent : NO_ANSWERS,
+			transport,
+			store,
+			model: config.model ?? "typesafe-ai/jev",
+			tags: config.tags ?? DEFAULT_TAGS,
+			tagPath,
+			readOnly,
+			debounceMs: config.debounceMs ?? 500
+		});
+	}), 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(),
+		localEdit: lifecycle.localEdit
+	};
+}
+/** Renders a field with `options.jev` as usual, with its signal strip and details below. */
+function AttachedInput({ signals, ...props }) {
+	let { t } = useTranslation("jev"), parentOnChange = props.onChange, { value } = props, state = toText(value), jev = useSignals({
+		signals,
+		path: props.path,
+		state,
+		readOnly: !!props.readOnly
+	}), onChange = (patch) => {
+		jev.localEdit(), parentOnChange(patch);
+	}, inputProps = {
+		...props,
+		onChange
+	}, [selected, setSelected] = useState(null), [keyDialogOpen, setKeyDialogOpen] = useState(!1), selectedSignal = jev.signals.find((signal) => signal.key === selected);
+	return <Stack gap={2}>
+      <div>
+        {props.renderDefault(inputProps)}
+        <SignalStrip signals={jev.signals} selected={selected} onSelect={setSelected} setup={jev.setup} canRun={jev.canRun} loading={jev.loading} onRunAll={jev.runAll} onSetUp={() => setKeyDialogOpen(!0)} />
+      </div>
+      {nearTokenLimit(state) && <Card padding={3} radius={2} tone="caution" border>
+          <Text size={1}>
+            {t("field.too-long", {
+		tokens: Math.round(estimateTokens(state) / 1e3),
+		limit: 32
+	})}
+          </Text>
+        </Card>}
+      {selectedSignal && <SignalDetail signal={selectedSignal} empty={jev.empty} onRetry={() => jev.run(selectedSignal.key)} onUpdateKey={jev.keyInSecrets ? () => setKeyDialogOpen(!0) : void 0} />}
+      {keyDialogOpen && <JevKeyDialog onClose={() => setKeyDialogOpen(!1)} />}
+    </Stack>;
+}
+const Code = ({ children }) => <code>{children}</code>, CONNECTION_TEST = kindOf(noul({
+	instructions: "Is this text a connection test?",
+	true: "It is a test",
+	false: "It is not a test"
+})).question, asSignalError = (error) => error instanceof JevError ? {
+	message: error.message,
+	kind: error.kind,
+	status: error.status,
+	detail: error.detail
+} : { message: error instanceof Error ? error.message : String(error) };
+/** 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);
+	async function testConnection() {
+		if (transport && CONNECTION_TEST) {
+			setTest({ state: "running" });
+			try {
+				let result = await evaluateQuestion({
+					transport,
+					model: config.model ?? "typesafe-ai/jev",
+					state: "This is a connection test.",
+					question: CONNECTION_TEST,
+					tags: [...config.tags ?? DEFAULT_TAGS, "jev:connection-test"]
+				});
+				setTest({
+					state: "passed",
+					model: result.model
+				});
+			} catch (error) {
+				setTest({
+					state: "failed",
+					error: asSignalError(error)
+				});
+			}
+		}
+	}
+	return <Container width={1} padding={4}>
+      <Stack gap={5}>
+        <Stack gap={3}>
+          <Heading size={2}>{t("tool.title")}</Heading>
+          <Text muted size={1}>
+            {t("tool.intro")}
+          </Text>
+        </Stack>
+
+        <Card padding={4} radius={2} border>
+          <Stack gap={4}>
+            <Flex align="center" gap={3}>
+              <Box flex={1}>
+                <Heading size={0} as="h2">
+                  {t("tool.key.heading")}
+                </Heading>
+              </Box>
+              <KeyStatus fromConfig={fromConfig} loading={stored.loading} stored={stored.apiKey} />
+            </Flex>
+
+            {fromConfig ? <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}>
+                  <Translate t={t} i18nKey="tool.key.ends-with" values={{ last4: stored.apiKey.slice(-4) }} components={{ Code }} />
+                </Text>
+                {stored.updatedAt && <Text size={1} muted>
+                    {t("tool.key.changed", { date: new Date(stored.updatedAt).toLocaleString() })}
+                  </Text>}
+              </Stack> : <Text size={1} muted>
+                {stored.loading ? t("tool.key.checking") : t("tool.key.none")}
+              </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)} />}
+            </Flex>
+
+            {confirmRemove && <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 }) }
+			});
+		}
+	}} />
+                </Flex>
+              </Card>}
+
+            {test.state === "passed" && <Card padding={3} radius={2} tone="positive">
+                <Text size={1}>{t("tool.test.passed", { model: test.model })}</Text>
+              </Card>}
+            {test.state === "failed" && <Card padding={3} radius={2} tone="critical">
+                <Text size={1}>{errorText(t, test.error)}</Text>
+              </Card>}
+          </Stack>
+        </Card>
+
+        <Stack gap={3}>
+          <Heading size={0} as="h2">
+            {t("tool.visibility.heading")}
+          </Heading>
+          <Text size={1} muted>
+            <Translate t={t} i18nKey="tool.visibility.body" components={{ Code }} />
+          </Text>
+        </Stack>
+      </Stack>
+
+      {settingsOpen && <JevKeyDialog onClose={() => {
+		setSettingsOpen(!1), setTest({ state: "idle" });
+	}} />}
+    </Container>;
+}
+function KeyStatus({ fromConfig, loading, stored }) {
+	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>;
+}
+/**
+* Jev signals for Sanity Studio: yes/no, score and choice questions attached to a field with
+* `options.jev`, answered by TypeSafe's Jev model through Vercel AI Gateway. Pair it with
+* `withJevAnswers(schemaTypes)` in `schema.types`.
+* @public
+*/
+const jev = definePlugin((config) => {
+	let pluginConfig = config ?? {};
+	return {
+		name: "jev",
+		tools: pluginConfig.tool === !1 ? [] : [{
+			name: "jev",
+			title: "Jev",
+			icon: SparklesIcon,
+			component: () => <JevTool config={pluginConfig} />
+		}],
+		form: { components: { input: (props) => {
+			if (props.path.length === 0) return <JevFormProvider config={pluginConfig}>{props.renderDefault(props)}</JevFormProvider>;
+			let signals = signalsOf(props.schemaType);
+			return signals ? <AttachedInput {...props} signals={signals} /> : props.renderDefault(props);
+		} } },
+		schema: { types: KIND_SCHEMA_TYPES },
+		i18n: { bundles: [jevLocaleBundle] }
+	};
+});
+export { JEV_NAMESPACE, choice, jev, noul, score, withJevAnswers };
+
+//# sourceMappingURL=index.js.map