@case-framework/survey-assistant 0.1.0

package/dist/engine-sPvuixWg.mjs

@@ -0,0 +1,4857 @@
+import { N as rawSurveyDocumentSchema, c as surveyAssistantTurnFinalSchema, u as surveyChangeSetSchema } from "./protocol-DV0ka9WT.mjs";
+import { n as assertSurveyAssistantCapabilities } from "./capabilities-B6tvE7fK.mjs";
+import { z } from "zod";
+import { ContentType, Expression, ExpressionType, FunctionExpressionNames, JsonPatchError, ReservedSurveyItemTypes, SurveyTranslations, ValueReferenceMethod, ValueType, applyJsonPatch, generateId, getContentPlainText, isContentEmpty, parseJsonPointer, structuredCloneMethod } from "@case-framework/survey-core";
+//#region src/engine/context.ts
+const isRecord$6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const asString$1 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const asArray$1 = (value) => Array.isArray(value) ? value : [];
+const getChildIds = (item) => {
+	return asArray$1((isRecord$6(item.config) ? item.config : void 0)?.items).filter((entry) => typeof entry === "string");
+};
+const getFieldValueType = (field) => {
+	switch (field.type) {
+		case "number":
+		case "slider": return ValueType.number;
+		case "datepicker": return ValueType.date;
+		case "switch": return ValueType.boolean;
+		default: return ValueType.string;
+	}
+};
+const addResponseSlot = (lookup, itemId, slotId, valueType) => {
+	lookup[`${itemId}...${ValueReferenceMethod.get}...${slotId}`] = valueType;
+	lookup[`${itemId}...${ValueReferenceMethod.isDefined}...${slotId}`] = ValueType.boolean;
+};
+const addFormResponseSlots = ({ config, itemId, lookup, slotPrefix }) => {
+	if (!isRecord$6(config)) return;
+	for (const group of asArray$1(config.fieldGroups).filter(isRecord$6)) for (const field of asArray$1(group.fields).filter(isRecord$6)) {
+		const key = asString$1(field.key);
+		if (!key) continue;
+		addResponseSlot(lookup, itemId, slotPrefix ? `${slotPrefix}.${key}` : key, getFieldValueType(field));
+	}
+};
+const deriveResponseSlotTypes = (survey, trustedCapabilities) => {
+	const lookup = {};
+	for (const item of survey.surveyItems) {
+		const deriveResponseSlots = trustedCapabilities?.byItemType.get(item.itemType)?.deriveResponseSlots;
+		if (deriveResponseSlots) {
+			for (const [slotId, valueType] of Object.entries(deriveResponseSlots(item))) addResponseSlot(lookup, item.id, slotId, valueType);
+			continue;
+		}
+		if (item.itemType === "choiceItem") {
+			const config = isRecord$6(item.config) ? item.config : {};
+			const slotId = asString$1(config.id) ?? item.id;
+			addResponseSlot(lookup, item.id, slotId, config.maxSelection === 1 ? ValueType.reference : ValueType.referenceArray);
+			for (const option of asArray$1(config.options).filter(isRecord$6)) {
+				const optionId = asString$1(option.id);
+				if (optionId && option.embeddedForm) addFormResponseSlots({
+					config: option.embeddedForm,
+					itemId: item.id,
+					lookup,
+					slotPrefix: `embedded.${optionId}`
+				});
+			}
+		} else if (item.itemType === "formItem") addFormResponseSlots({
+			config: item.config,
+			itemId: item.id,
+			lookup
+		});
+	}
+	return lookup;
+};
+const buildDerivedContext = (snapshot, trustedCapabilities, requestedFocusItemId) => {
+	const rawItems = snapshot.survey.surveyItems;
+	const itemsById = new Map(rawItems.map((item) => [item.id, item]));
+	const parentById = /* @__PURE__ */ new Map();
+	for (const item of rawItems) for (const childId of getChildIds(item)) if (itemsById.has(childId) && !parentById.has(childId)) parentById.set(childId, item.id);
+	const fullKeyCache = /* @__PURE__ */ new Map();
+	const getFullKey = (itemId, stack = /* @__PURE__ */ new Set()) => {
+		const cached = fullKeyCache.get(itemId);
+		if (cached) return cached;
+		const item = itemsById.get(itemId);
+		if (!item) return itemId;
+		if (stack.has(itemId)) return item.key;
+		const parentId = parentById.get(itemId);
+		if (!parentId) return item.key;
+		stack.add(itemId);
+		const fullKey = `${getFullKey(parentId, stack)}.${item.key}`;
+		stack.delete(itemId);
+		fullKeyCache.set(itemId, fullKey);
+		return fullKey;
+	};
+	const outline = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (itemId, depth) => {
+		if (visited.has(itemId)) return;
+		const item = itemsById.get(itemId);
+		if (!item) return;
+		visited.add(itemId);
+		outline.push({
+			itemId,
+			parentId: parentById.get(itemId),
+			depth,
+			itemType: item.itemType,
+			key: item.key,
+			fullKey: getFullKey(itemId),
+			itemLabel: item.metadata?.itemLabel,
+			childCount: getChildIds(item).length
+		});
+		for (const childId of getChildIds(item)) visit(childId, depth + 1);
+	};
+	const explicitRoot = rawItems.find((item) => isRecord$6(item.config) && item.config.isRoot === true);
+	if (explicitRoot) visit(explicitRoot.id, 0);
+	for (const item of [...rawItems].sort((left, right) => left.id.localeCompare(right.id))) if (!visited.has(item.id)) visit(item.id, 0);
+	const keyIndex = outline.map((node) => ({
+		itemId: node.itemId,
+		itemType: node.itemType,
+		key: node.key,
+		fullKey: node.fullKey,
+		itemLabel: node.itemLabel,
+		path: node.fullKey.split(".")
+	}));
+	const translations = new SurveyTranslations(snapshot.survey.translations);
+	const buildFocusNode = (itemId, budget) => {
+		const item = itemsById.get(itemId);
+		budget.remaining -= 1;
+		const itemTranslations = translations.getItemTranslations(itemId);
+		const translationSnippets = (itemTranslations?.locales ?? []).flatMap((locale) => Object.entries(itemTranslations?.getAllForLocale(locale) ?? {}).slice(0, 8).map(([contentKey, content]) => ({
+			locale,
+			contentKey,
+			text: getContentPlainText(content).slice(0, 120)
+		})));
+		return {
+			itemId,
+			itemType: item.itemType,
+			itemKey: item.key,
+			fullKey: getFullKey(itemId),
+			itemLabel: item.metadata?.itemLabel,
+			siblingKeys: rawItems.filter((candidate) => candidate.id !== itemId && parentById.get(candidate.id) === parentById.get(itemId)).map((candidate) => candidate.key),
+			translations: translationSnippets,
+			descendants: getChildIds(item).filter((childId) => itemsById.has(childId) && budget.remaining > 0).map((childId) => buildFocusNode(childId, budget))
+		};
+	};
+	const focusItemId = requestedFocusItemId ?? snapshot.ui.focusItemId ?? snapshot.ui.selectedItemId;
+	let focus;
+	let focusItem;
+	let focusItemTreeTruncated = false;
+	if (focusItemId && itemsById.has(focusItemId)) {
+		const pathItemIds = [];
+		let currentId = focusItemId;
+		const pathSeen = /* @__PURE__ */ new Set();
+		while (currentId && !pathSeen.has(currentId)) {
+			pathSeen.add(currentId);
+			pathItemIds.unshift(currentId);
+			currentId = parentById.get(currentId);
+		}
+		const parentItemId = parentById.get(focusItemId);
+		focus = {
+			focusItemId,
+			parentItemId,
+			pathItemIds,
+			siblingItemIds: rawItems.filter((candidate) => candidate.id !== focusItemId && parentById.get(candidate.id) === parentItemId).map((candidate) => candidate.id),
+			childItemIds: getChildIds(itemsById.get(focusItemId))
+		};
+		const budget = { remaining: 120 };
+		focusItem = buildFocusNode(focusItemId, budget);
+		focusItemTreeTruncated = budget.remaining === 0;
+	}
+	const responseSlotTypes = deriveResponseSlotTypes(snapshot.survey, trustedCapabilities);
+	const locales = [snapshot.ui.selectedLocale, ...Object.keys(snapshot.survey.translations ?? {}).filter((locale) => locale !== snapshot.ui.selectedLocale)].filter((locale, index, values) => locale.length > 0 && values.indexOf(locale) === index);
+	return {
+		inspection: {
+			surveyKey: explicitRoot?.key,
+			locales,
+			itemCount: rawItems.length,
+			outline,
+			focus,
+			focusItem,
+			keyIndex,
+			responseSlots: Object.keys(responseSlotTypes),
+			focusItemTreeTruncated
+		},
+		responseSlotTypes
+	};
+};
+const createSurveyAssistantEngineContext = (document, trustedCapabilities, options) => {
+	assertSurveyAssistantCapabilities({
+		manifest: document.capabilities,
+		trustedCapabilities,
+		versionDigest: document.version.capabilityDigest
+	});
+	const { inspection, responseSlotTypes } = buildDerivedContext(document, trustedCapabilities, options?.focusItemId);
+	return {
+		document,
+		version: document.version,
+		survey: document.survey,
+		ui: document.ui,
+		capabilities: document.capabilities,
+		responseSlotTypes,
+		inspection,
+		trustedCapabilities
+	};
+};
+//#endregion
+//#region src/engine/expression-validation.ts
+const createIssue$2 = ({ severity = "error", ...input }) => ({
+	severity,
+	...input
+});
+const formatValueType = (valueType) => valueType ?? "unknown";
+const addFunctionSignatureIssue = ({ issues, message, operationIndex, scope }) => {
+	issues.push(createIssue$2({
+		code: "expression-function-signature-mismatch",
+		message: `${scope} has an invalid function expression: ${message}`,
+		operationIndex
+	}));
+};
+const validateArgumentCount = ({ actual, expected, functionName, issues, operationIndex, scope }) => {
+	if (actual === expected) return;
+	addFunctionSignatureIssue({
+		issues,
+		operationIndex,
+		scope,
+		message: `${functionName} expects ${expected} argument${expected === 1 ? "" : "s"}, got ${actual}.`
+	});
+};
+const inferExpressionReturnType = (expression, responseSlotTypes) => {
+	if (!expression) return;
+	if (expression.type === ExpressionType.Const) return expression.value?.type;
+	if (expression.type === ExpressionType.ResponseVariable) return responseSlotTypes[expression.variableRef];
+	if (expression.type === ExpressionType.ContextVariable) {
+		if (expression.contextType === "locale") return ValueType.string;
+		return expression.asType;
+	}
+	switch (expression.functionName) {
+		case FunctionExpressionNames.and:
+		case FunctionExpressionNames.or:
+		case FunctionExpressionNames.not:
+		case FunctionExpressionNames.eq:
+		case FunctionExpressionNames.gt:
+		case FunctionExpressionNames.gte:
+		case FunctionExpressionNames.lt:
+		case FunctionExpressionNames.lte:
+		case FunctionExpressionNames.in_range:
+		case FunctionExpressionNames.list_contains:
+		case FunctionExpressionNames.str_eq:
+		case FunctionExpressionNames.date_eq: return ValueType.boolean;
+		case FunctionExpressionNames.sum:
+		case FunctionExpressionNames.min:
+		case FunctionExpressionNames.max: return ValueType.number;
+	}
+};
+const validateExpressionFunctionSignatures = ({ expression, issues, operationIndex, responseSlotTypes, scope }) => {
+	if (!expression || expression.type !== ExpressionType.Function) return;
+	expression.arguments.forEach((argument, argumentIndex) => {
+		validateExpressionFunctionSignatures({
+			expression: argument,
+			issues,
+			operationIndex,
+			responseSlotTypes,
+			scope: `${scope} argument ${argumentIndex + 1}`
+		});
+	});
+	const argumentTypes = expression.arguments.map((argument) => inferExpressionReturnType(argument, responseSlotTypes));
+	const requireBooleanArguments = () => {
+		argumentTypes.forEach((argumentType, argumentIndex) => {
+			if (argumentType && argumentType !== ValueType.boolean) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `${expression.functionName} argument ${argumentIndex + 1} must be boolean, got ${formatValueType(argumentType)}.`
+			});
+		});
+	};
+	const requireNumericArguments = () => {
+		argumentTypes.forEach((argumentType, argumentIndex) => {
+			if (argumentType && argumentType !== ValueType.number) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `${expression.functionName} argument ${argumentIndex + 1} must be number, got ${formatValueType(argumentType)}.`
+			});
+		});
+	};
+	const requireSameKnownType = () => {
+		if (argumentTypes.length < 2 || !argumentTypes[0] || !argumentTypes[1]) return;
+		if (argumentTypes[0] !== argumentTypes[1]) addFunctionSignatureIssue({
+			issues,
+			operationIndex,
+			scope,
+			message: `${expression.functionName} arguments must have the same type, got ${formatValueType(argumentTypes[0])} and ${formatValueType(argumentTypes[1])}.`
+		});
+	};
+	switch (expression.functionName) {
+		case FunctionExpressionNames.and:
+		case FunctionExpressionNames.or:
+			requireBooleanArguments();
+			break;
+		case FunctionExpressionNames.not:
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 1,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			requireBooleanArguments();
+			break;
+		case FunctionExpressionNames.str_eq:
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 2,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			argumentTypes.forEach((argumentType, argumentIndex) => {
+				if (argumentType && argumentType !== ValueType.string) addFunctionSignatureIssue({
+					issues,
+					operationIndex,
+					scope,
+					message: `str_eq argument ${argumentIndex + 1} must be string, got ${formatValueType(argumentType)}.`
+				});
+			});
+			break;
+		case FunctionExpressionNames.date_eq:
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 2,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			argumentTypes.forEach((argumentType, argumentIndex) => {
+				if (argumentType && argumentType !== ValueType.date) addFunctionSignatureIssue({
+					issues,
+					operationIndex,
+					scope,
+					message: `date_eq argument ${argumentIndex + 1} must be date, got ${formatValueType(argumentType)}.`
+				});
+			});
+			break;
+		case FunctionExpressionNames.eq:
+		case FunctionExpressionNames.gt:
+		case FunctionExpressionNames.gte:
+		case FunctionExpressionNames.lt:
+		case FunctionExpressionNames.lte:
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 2,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			requireSameKnownType();
+			break;
+		case FunctionExpressionNames.in_range:
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 4,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			argumentTypes.slice(0, 3).forEach((argumentType, argumentIndex) => {
+				if (argumentType && argumentType !== ValueType.number) addFunctionSignatureIssue({
+					issues,
+					operationIndex,
+					scope,
+					message: `in_range argument ${argumentIndex + 1} must be number, got ${formatValueType(argumentType)}.`
+				});
+			});
+			if (argumentTypes[3] && argumentTypes[3] !== ValueType.boolean) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `in_range argument 4 must be boolean, got ${formatValueType(argumentTypes[3])}.`
+			});
+			break;
+		case FunctionExpressionNames.sum:
+		case FunctionExpressionNames.min:
+		case FunctionExpressionNames.max:
+			if (expression.arguments.length < 1) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `${expression.functionName} expects at least 1 argument, got 0.`
+			});
+			requireNumericArguments();
+			break;
+		case FunctionExpressionNames.list_contains: {
+			validateArgumentCount({
+				actual: expression.arguments.length,
+				expected: 2,
+				functionName: expression.functionName,
+				issues,
+				operationIndex,
+				scope
+			});
+			const listType = argumentTypes[0];
+			const itemType = argumentTypes[1];
+			if (listType && listType !== ValueType.stringArray && listType !== ValueType.referenceArray) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `list_contains argument 1 must be string[] or reference[], got ${formatValueType(listType)}. Use eq for single-choice reference responses.`
+			});
+			if (listType === ValueType.stringArray && itemType && itemType !== ValueType.string) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `list_contains with string[] needs a string item, got ${formatValueType(itemType)}.`
+			});
+			if (listType === ValueType.referenceArray && itemType && itemType !== ValueType.reference) addFunctionSignatureIssue({
+				issues,
+				operationIndex,
+				scope,
+				message: `list_contains with reference[] needs a reference item, got ${formatValueType(itemType)}.`
+			});
+			break;
+		}
+	}
+};
+const validateExpression = ({ expression, expectedReturnType, issues, operationIndex, responseSlotTypes, scope }) => {
+	if (!expression) {
+		issues.push(createIssue$2({
+			code: "missing-expression",
+			message: `${scope} needs an expression.`,
+			operationIndex
+		}));
+		return;
+	}
+	let parsed;
+	try {
+		parsed = Expression.deserialize(expression);
+	} catch (error) {
+		issues.push(createIssue$2({
+			code: "invalid-expression",
+			message: `${scope} contains invalid expression JSON: ${error instanceof Error ? error.message : String(error)}`,
+			operationIndex
+		}));
+		return;
+	}
+	for (const ref of parsed?.responseVariableRefs ?? []) if (!(ref.toString() in responseSlotTypes)) issues.push(createIssue$2({
+		code: "unknown-response-ref",
+		message: `${scope} references unknown response slot "${ref.toString()}". Inspect response slots before using it.`,
+		operationIndex
+	}));
+	validateExpressionFunctionSignatures({
+		expression,
+		issues,
+		operationIndex,
+		responseSlotTypes,
+		scope
+	});
+	const inferred = inferExpressionReturnType(expression, responseSlotTypes);
+	if (expectedReturnType && inferred && inferred !== expectedReturnType) issues.push(createIssue$2({
+		code: "expression-return-type-mismatch",
+		message: `${scope} must return ${expectedReturnType}, but this expression appears to return ${inferred}.`,
+		operationIndex
+	}));
+};
+//#endregion
+//#region src/engine/inspection.ts
+const DEFAULT_LIMIT = 12;
+const MAX_LIMIT = 50;
+const itemSummarySchema = z.object({
+	itemId: z.string(),
+	itemType: z.string(),
+	key: z.string(),
+	fullKey: z.string(),
+	itemLabel: z.string().optional(),
+	parentId: z.string().optional(),
+	depth: z.number().int().nonnegative().optional(),
+	childCount: z.number().int().nonnegative().optional(),
+	path: z.array(z.string()).optional(),
+	siblingKeys: z.array(z.string()).optional()
+});
+const translationEntrySchema = z.object({
+	locale: z.string(),
+	contentKey: z.string(),
+	text: z.string()
+});
+const choiceOptionDetailsSchema = z.object({
+	id: z.string(),
+	key: z.string().optional(),
+	labelContentKey: z.string(),
+	hasDisplayCondition: z.boolean().optional(),
+	embeddedFormItemId: z.string().optional(),
+	embeddedFormFieldGroupCount: z.number().int().nonnegative().optional(),
+	embeddedFormTranslationPrefix: z.string().optional(),
+	embeddedFormResponseSlotPrefix: z.string().optional()
+});
+const formSelectOptionDetailsSchema = z.object({
+	id: z.string(),
+	value: z.string().optional(),
+	labelContentKey: z.string()
+});
+const formFieldGroupLayoutSchema = z.object({
+	base: z.number().int().positive(),
+	xs: z.number().int().positive(),
+	sm: z.number().int().positive(),
+	md: z.number().int().positive(),
+	xl: z.number().int().positive()
+});
+const formFieldDetailsSchema = z.object({
+	id: z.string(),
+	key: z.string(),
+	type: z.string(),
+	responseSlotId: z.string(),
+	labelContentKey: z.string(),
+	descriptionContentKey: z.string(),
+	errorContentKey: z.string(),
+	placeholderContentKey: z.string().optional(),
+	unitContentKey: z.string().optional(),
+	checkedLabelContentKey: z.string().optional(),
+	uncheckedLabelContentKey: z.string().optional(),
+	required: z.boolean().optional(),
+	controllerType: z.string().optional(),
+	validationTypes: z.array(z.string()).optional(),
+	validationMessageContentKeys: z.array(z.string()).optional(),
+	selectOptions: z.array(formSelectOptionDetailsSchema).optional()
+});
+const formFieldGroupDetailsSchema = z.object({
+	id: z.string(),
+	titleContentKey: z.string(),
+	descriptionContentKey: z.string(),
+	hasDisplayCondition: z.boolean().optional(),
+	layout: formFieldGroupLayoutSchema,
+	fieldCount: z.number().int().nonnegative(),
+	fields: z.array(formFieldDetailsSchema)
+});
+const itemConfigDetailsSchema = z.object({
+	kind: z.enum([
+		"choice",
+		"form",
+		"generic"
+	]),
+	summary: z.array(z.string()),
+	mainResponseSlotId: z.string().optional(),
+	choiceOptions: z.array(choiceOptionDetailsSchema).optional(),
+	formFieldGroups: z.array(formFieldGroupDetailsSchema).optional()
+});
+const normalizeText = (value) => value?.trim().toLowerCase() ?? "";
+const clampLimit = (limit) => Math.min(50, Math.max(1, limit ?? 12));
+const parseCursor = (cursor) => {
+	if (!cursor) return 0;
+	const parsed = Number.parseInt(cursor, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+};
+const unique = (values) => Array.from(new Set(values));
+const isRecord$5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const asString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const asBoolean = (value) => typeof value === "boolean" ? value : void 0;
+const asArray = (value) => Array.isArray(value) ? value : [];
+const createContentKey = (...segments) => segments.filter(Boolean).join(".");
+const getChoiceOptionLabelContentKey = (optionId) => createContentKey("options", optionId, "label");
+const getChoiceEmbeddedFormTranslationPrefix = (optionId) => createContentKey("embeddedForms", optionId);
+const getChoiceEmbeddedFormResponseSlotPrefix = (optionId) => createContentKey("embedded", optionId);
+const withFormTranslationNamespace = (contentKey, translationNamespace) => translationNamespace ? createContentKey(translationNamespace, contentKey) : contentKey;
+const getFormFieldGroupContentKey = (groupId, contentKey, translationNamespace) => withFormTranslationNamespace(createContentKey("fieldGroups", groupId, contentKey), translationNamespace);
+const getFormFieldContentKey = (fieldId, contentKey, translationNamespace) => withFormTranslationNamespace(createContentKey("fields", fieldId, contentKey), translationNamespace);
+const getFormFieldOptionLabelContentKey = (fieldId, optionId, translationNamespace) => withFormTranslationNamespace(createContentKey("fields", fieldId, "options", optionId, "label"), translationNamespace);
+const getFormFieldResponseSlotId = (fieldKey, responseSlotPrefix) => responseSlotPrefix ? createContentKey(responseSlotPrefix, fieldKey) : fieldKey;
+const getRoundedPositiveInt = (value, fallback = 1) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	return Math.max(1, Math.round(value));
+};
+const sliceWithCursor = (values, input) => {
+	const offset = parseCursor(input.cursor);
+	const nextOffset = offset + clampLimit(input.limit);
+	return {
+		items: values.slice(offset, nextOffset),
+		nextCursor: nextOffset < values.length ? String(nextOffset) : void 0,
+		truncated: nextOffset < values.length
+	};
+};
+const mapOutlineById = (snapshot) => new Map(snapshot.inspection.outline.map((item) => [item.itemId, item]));
+const mapKeyIndexById = (snapshot) => new Map(snapshot.inspection.keyIndex.map((item) => [item.itemId, item]));
+/** The full-survey key index, regardless of the (possibly focus-scoped) outline. */
+const getKeyIndexEntries = (snapshot) => snapshot.inspection.keyIndex;
+const getRawSurvey$1 = (snapshot) => snapshot.survey;
+const getRawSurveyItems = (snapshot) => {
+	const rawItems = getRawSurvey$1(snapshot).surveyItems;
+	return Array.isArray(rawItems) ? rawItems : [];
+};
+const mapRawItemsById = (snapshot) => new Map(getRawSurveyItems(snapshot).map((item) => [item.id, item]));
+const buildSurveyTranslations = (snapshot) => new SurveyTranslations(getRawSurvey$1(snapshot).translations);
+const summarizeRawItem = (item) => ({
+	itemId: item.id,
+	itemType: item.itemType,
+	key: item.key,
+	fullKey: item.key,
+	itemLabel: item.metadata?.itemLabel
+});
+const buildItemTranslationEntries = (snapshot, itemId, input) => {
+	const itemTranslations = buildSurveyTranslations(snapshot).getItemTranslations(itemId);
+	if (!itemTranslations) return [];
+	const localeFilter = input.locales?.length ? new Set(input.locales) : void 0;
+	const textLimit = input.textLimit ?? 400;
+	const entries = [];
+	for (const locale of itemTranslations.locales) {
+		if (localeFilter && !localeFilter.has(locale)) continue;
+		const localeContent = itemTranslations.getAllForLocale(locale);
+		if (!localeContent) continue;
+		for (const [contentKey, content] of Object.entries(localeContent)) {
+			const text = getContentPlainText(content).trim();
+			if (!text) continue;
+			entries.push({
+				locale,
+				contentKey,
+				text: text.length > textLimit ? `${text.slice(0, textLimit)}...` : text
+			});
+		}
+	}
+	return entries;
+};
+const summarizeOutlineNode = (node) => ({
+	itemId: node.itemId,
+	itemType: node.itemType,
+	key: node.key,
+	fullKey: node.fullKey,
+	itemLabel: node.itemLabel,
+	parentId: node.parentId,
+	depth: node.depth,
+	childCount: node.childCount
+});
+const summarizeKeyIndexEntry = (entry, outlineById) => {
+	const outlineNode = outlineById.get(entry.itemId);
+	return {
+		itemId: entry.itemId,
+		itemType: entry.itemType,
+		key: entry.key,
+		fullKey: entry.fullKey,
+		itemLabel: entry.itemLabel,
+		parentId: outlineNode?.parentId,
+		depth: outlineNode?.depth,
+		childCount: outlineNode?.childCount,
+		path: entry.path
+	};
+};
+const getParentFullKey = (fullKey) => {
+	const segments = fullKey.split(".");
+	if (segments.length <= 1) return;
+	return segments.slice(0, -1).join(".");
+};
+const summarizeKeyIndexEntries = (entries, outlineById) => {
+	const byFullKey = new Map(entries.map((entry) => [entry.fullKey, entry]));
+	const childCountByFullKey = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const parentFullKey = getParentFullKey(entry.fullKey);
+		if (!parentFullKey) continue;
+		childCountByFullKey.set(parentFullKey, (childCountByFullKey.get(parentFullKey) ?? 0) + 1);
+	}
+	return entries.map((entry) => {
+		const outlineNode = outlineById.get(entry.itemId);
+		const parentFullKey = getParentFullKey(entry.fullKey);
+		const parentEntry = parentFullKey ? byFullKey.get(parentFullKey) : void 0;
+		return {
+			itemId: entry.itemId,
+			itemType: entry.itemType,
+			key: entry.key,
+			fullKey: entry.fullKey,
+			itemLabel: entry.itemLabel,
+			parentId: outlineNode?.parentId ?? parentEntry?.itemId,
+			depth: outlineNode?.depth ?? Math.max(0, entry.fullKey.split(".").length - 1),
+			childCount: outlineNode?.childCount ?? childCountByFullKey.get(entry.fullKey) ?? 0,
+			path: entry.path
+		};
+	});
+};
+const buildChoiceConfigDetails = (rawItem) => {
+	const config = isRecord$5(rawItem.config) ? rawItem.config : void 0;
+	const rawOptions = asArray(config?.options);
+	const mainResponseSlotId = asString(config?.id) ?? rawItem.id;
+	if (rawItem.itemType !== "choiceItem" && rawOptions.length === 0) return;
+	const choiceOptions = rawOptions.filter(isRecord$5).map((option) => {
+		const id = asString(option.id);
+		if (!id) return;
+		const embeddedFormFieldGroups = asArray((isRecord$5(option.embeddedForm) ? option.embeddedForm : void 0)?.fieldGroups);
+		const details = {
+			id,
+			labelContentKey: getChoiceOptionLabelContentKey(id)
+		};
+		const key = asString(option.key);
+		if (key) details.key = key;
+		const hasDisplayCondition = asBoolean(option.hasDisplayCondition);
+		if (hasDisplayCondition !== void 0) details.hasDisplayCondition = hasDisplayCondition;
+		const embeddedFormItemId = asString(option.embeddedFormItemId);
+		if (embeddedFormItemId) details.embeddedFormItemId = embeddedFormItemId;
+		if (embeddedFormFieldGroups.length > 0) {
+			details.embeddedFormFieldGroupCount = embeddedFormFieldGroups.length;
+			details.embeddedFormTranslationPrefix = getChoiceEmbeddedFormTranslationPrefix(id);
+			details.embeddedFormResponseSlotPrefix = getChoiceEmbeddedFormResponseSlotPrefix(id);
+		}
+		return details;
+	}).filter((option) => Boolean(option));
+	const maxSelection = config?.maxSelection === null ? "unlimited" : typeof config?.maxSelection === "number" ? String(config.maxSelection) : "default";
+	return {
+		kind: "choice",
+		summary: [
+			`choice item config: ${choiceOptions.length} option(s)`,
+			`maxSelection=${maxSelection}`,
+			`shuffleOptions=${config?.shuffleOptions === true ? "true" : "false"}`,
+			`responseSlot=${mainResponseSlotId}`
+		],
+		mainResponseSlotId,
+		choiceOptions
+	};
+};
+const buildFormFieldDetails = (field, translationNamespace, responseSlotPrefix) => {
+	const id = asString(field.id);
+	const key = asString(field.key);
+	const type = asString(field.type);
+	if (!id || !key || !type) return;
+	const controller = isRecord$5(field.controller) ? field.controller : void 0;
+	const controllerType = asString(controller?.type);
+	const validations = asArray(field.validations).filter(isRecord$5);
+	const validationMessageContentKeys = validations.map((validation) => asString(validation.id)).filter((validationId) => Boolean(validationId)).map((validationId) => getFormFieldContentKey(id, createContentKey("validations", validationId, "message"), translationNamespace));
+	const selectOptions = controllerType === "select" ? asArray(controller?.options).filter(isRecord$5).map((option) => {
+		const optionId = asString(option.id);
+		if (!optionId) return;
+		const details = {
+			id: optionId,
+			labelContentKey: getFormFieldOptionLabelContentKey(id, optionId, translationNamespace)
+		};
+		const value = asString(option.value);
+		if (value) details.value = value;
+		return details;
+	}).filter((option) => Boolean(option)) : void 0;
+	return {
+		id,
+		key,
+		type,
+		responseSlotId: getFormFieldResponseSlotId(key, responseSlotPrefix),
+		labelContentKey: getFormFieldContentKey(id, "label", translationNamespace),
+		descriptionContentKey: getFormFieldContentKey(id, "description", translationNamespace),
+		errorContentKey: getFormFieldContentKey(id, "error", translationNamespace),
+		placeholderContentKey: type === "input" || type === "textarea" || type === "number" || type === "datepicker" || type === "select" ? getFormFieldContentKey(id, "placeholder", translationNamespace) : void 0,
+		unitContentKey: type === "number" ? getFormFieldContentKey(id, "unit", translationNamespace) : void 0,
+		checkedLabelContentKey: type === "switch" ? getFormFieldContentKey(id, "checkedLabel", translationNamespace) : void 0,
+		uncheckedLabelContentKey: type === "switch" ? getFormFieldContentKey(id, "uncheckedLabel", translationNamespace) : void 0,
+		required: asBoolean(field.required),
+		controllerType,
+		validationTypes: validations.map((validation) => asString(validation.type)).filter((type) => Boolean(type)),
+		validationMessageContentKeys: validationMessageContentKeys.length > 0 ? validationMessageContentKeys : void 0,
+		selectOptions
+	};
+};
+const buildFormConfigDetails = (rawItem, configOverride, translationNamespace, responseSlotPrefix) => {
+	const configCandidate = configOverride ?? rawItem.config;
+	const rawGroups = asArray((isRecord$5(configCandidate) ? configCandidate : void 0)?.fieldGroups);
+	if (rawItem.itemType !== "formItem" && rawGroups.length === 0) return;
+	const formFieldGroups = rawGroups.filter(isRecord$5).map((group) => {
+		const id = asString(group.id);
+		if (!id) return;
+		const fields = asArray(group.fields).filter(isRecord$5).map((field) => buildFormFieldDetails(field, translationNamespace, responseSlotPrefix)).filter((field) => Boolean(field));
+		const layout = isRecord$5(group.layout) ? group.layout : void 0;
+		return {
+			id,
+			titleContentKey: getFormFieldGroupContentKey(id, "title", translationNamespace),
+			descriptionContentKey: getFormFieldGroupContentKey(id, "description", translationNamespace),
+			hasDisplayCondition: asBoolean(group.hasDisplayCondition),
+			layout: {
+				base: getRoundedPositiveInt(layout?.base ?? layout?.xs ?? layout?.sm),
+				xs: getRoundedPositiveInt(layout?.xs ?? layout?.sm),
+				sm: getRoundedPositiveInt(layout?.sm),
+				md: getRoundedPositiveInt(layout?.md ?? layout?.lg),
+				xl: getRoundedPositiveInt(layout?.xl ?? layout?.lg)
+			},
+			fieldCount: fields.length,
+			fields
+		};
+	}).filter((group) => Boolean(group));
+	const fieldCount = formFieldGroups.reduce((sum, group) => sum + group.fieldCount, 0);
+	return {
+		kind: "form",
+		summary: [`form item config: ${formFieldGroups.length} group(s), ${fieldCount} field(s)`],
+		formFieldGroups
+	};
+};
+const buildItemConfigDetails = (rawItem) => {
+	const choiceDetails = buildChoiceConfigDetails(rawItem);
+	if (choiceDetails) return choiceDetails;
+	const formDetails = buildFormConfigDetails(rawItem);
+	if (formDetails) return formDetails;
+	if (!isRecord$5(rawItem.config)) return;
+	const configKeys = Object.keys(rawItem.config);
+	return {
+		kind: "generic",
+		summary: [configKeys.length > 0 ? `generic config keys: ${configKeys.join(", ")}` : "generic config has no enumerable keys"]
+	};
+};
+const buildEmbeddedFormDetails = (choiceOption, embeddedForm) => {
+	if (!isRecord$5(embeddedForm)) return;
+	return buildFormConfigDetails({
+		id: choiceOption.embeddedFormItemId ?? choiceOption.id,
+		key: choiceOption.key ?? choiceOption.id,
+		itemType: "formItem",
+		config: embeddedForm
+	}, embeddedForm, getChoiceEmbeddedFormTranslationPrefix(choiceOption.id), getChoiceEmbeddedFormResponseSlotPrefix(choiceOption.id));
+};
+const buildConfigSearchText = (rawItem) => {
+	const details = buildItemConfigDetails(rawItem);
+	if (!details) return [];
+	const values = [...details.summary];
+	for (const option of details.choiceOptions ?? []) values.push(option.id, option.key ?? "", option.labelContentKey, option.embeddedFormItemId ?? "", option.embeddedFormTranslationPrefix ?? "", option.embeddedFormResponseSlotPrefix ?? "");
+	for (const group of details.formFieldGroups ?? []) {
+		values.push(group.id, group.titleContentKey, group.descriptionContentKey, String(group.layout.base), String(group.layout.xs), String(group.layout.sm), String(group.layout.md), String(group.layout.xl), group.hasDisplayCondition === true ? "hasDisplayCondition" : "");
+		for (const field of group.fields) {
+			values.push(field.id, field.key, field.type, field.responseSlotId, field.labelContentKey, field.descriptionContentKey, field.errorContentKey, field.placeholderContentKey ?? "", field.unitContentKey ?? "", field.checkedLabelContentKey ?? "", field.uncheckedLabelContentKey ?? "", field.controllerType ?? "", ...field.validationTypes ?? [], ...field.validationMessageContentKeys ?? []);
+			for (const option of field.selectOptions ?? []) values.push(option.id, option.value ?? "", option.labelContentKey);
+		}
+	}
+	return values.filter((value) => value.trim().length > 0);
+};
+const summarizeFocusItemNode = (node, outlineById) => {
+	const outlineNode = outlineById.get(node.itemId);
+	return {
+		itemId: node.itemId,
+		itemType: node.itemType,
+		key: node.itemKey,
+		fullKey: node.fullKey,
+		itemLabel: node.itemLabel,
+		parentId: outlineNode?.parentId,
+		depth: outlineNode?.depth,
+		childCount: outlineNode?.childCount ?? node.descendants.length,
+		siblingKeys: node.siblingKeys
+	};
+};
+const summarizeItemById = (itemId, indexById, outlineById) => {
+	const outlineNode = outlineById.get(itemId);
+	if (outlineNode) return summarizeOutlineNode(outlineNode);
+	const indexEntry = indexById.get(itemId);
+	if (indexEntry) return summarizeKeyIndexEntry(indexEntry, outlineById);
+};
+/**
+* Resolve an item by internal itemId, or fall back to matching on `key` /
+* `fullKey`. Model-facing text (outline rows, fullKey paths) only ever shows
+* key/fullKey, not the internal itemId, so models often pass a key like
+* "info_1" where an itemId is expected — this keeps that usage working.
+*/
+const resolveItemSummary = (identifier, indexById, outlineById) => {
+	const direct = summarizeItemById(identifier, indexById, outlineById);
+	if (direct) return direct;
+	const normalized = identifier.trim().toLowerCase();
+	if (!normalized) return;
+	for (const entry of indexById.values()) if (entry.key.toLowerCase() === normalized || entry.fullKey.toLowerCase() === normalized) return summarizeKeyIndexEntry(entry, outlineById);
+	for (const node of outlineById.values()) if (node.key.toLowerCase() === normalized || node.fullKey.toLowerCase() === normalized) return summarizeOutlineNode(node);
+};
+const itemMatchesQuery = (item, query) => {
+	return [
+		item.itemId,
+		item.itemType,
+		item.key,
+		item.fullKey,
+		item.itemLabel,
+		...item.path ?? [],
+		...item.siblingKeys ?? []
+	].filter(Boolean).join(" ").toLowerCase().includes(query);
+};
+/**
+* Direct children of `parentFullKey` derived from the full-survey key index.
+* This works for any item, selected or not.
+*/
+const findDirectChildrenByFullKey = (entries, outlineById, parentFullKey) => {
+	const prefix = `${parentFullKey}.`;
+	return entries.filter((entry) => entry.fullKey.startsWith(prefix) && !entry.fullKey.slice(prefix.length).includes(".")).map((entry) => summarizeKeyIndexEntry(entry, outlineById));
+};
+//#endregion
+//#region src/engine/expression-mutations.ts
+const jsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(jsonValueSchema),
+	z.record(z.string(), jsonValueSchema)
+]));
+const responseValueSchema = z.object({
+	type: z.enum([
+		ValueType.string,
+		ValueType.duration,
+		ValueType.reference,
+		ValueType.number,
+		ValueType.boolean,
+		ValueType.date,
+		ValueType.stringArray,
+		ValueType.durationArray,
+		ValueType.referenceArray,
+		ValueType.numberArray,
+		ValueType.dateArray
+	]),
+	value: jsonValueSchema.optional(),
+	unit: z.string().optional(),
+	precision: z.string().optional()
+}).passthrough();
+const expressionSchema = z.lazy(() => z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal(ExpressionType.Const),
+		value: responseValueSchema.optional(),
+		editorConfig: z.record(z.string(), jsonValueSchema).optional()
+	}),
+	z.object({
+		type: z.literal(ExpressionType.ResponseVariable),
+		variableRef: z.string().min(1),
+		editorConfig: z.record(z.string(), jsonValueSchema).optional()
+	}),
+	z.object({
+		type: z.literal(ExpressionType.ContextVariable),
+		contextType: z.enum([
+			"locale",
+			"participantFlag",
+			"customValue",
+			"customExpression"
+		]),
+		key: expressionSchema.optional(),
+		arguments: z.array(expressionSchema.optional()).optional(),
+		asType: z.enum([
+			ValueType.string,
+			ValueType.duration,
+			ValueType.reference,
+			ValueType.number,
+			ValueType.boolean,
+			ValueType.date,
+			ValueType.stringArray,
+			ValueType.durationArray,
+			ValueType.referenceArray,
+			ValueType.numberArray,
+			ValueType.dateArray
+		]).optional(),
+		editorConfig: z.record(z.string(), jsonValueSchema).optional()
+	}),
+	z.object({
+		type: z.literal(ExpressionType.Function),
+		functionName: z.nativeEnum(FunctionExpressionNames),
+		arguments: z.array(expressionSchema.optional()),
+		editorConfig: z.record(z.string(), jsonValueSchema).optional()
+	})
+]));
+const prefillTargetSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("itemResponse") }),
+	z.object({
+		type: z.literal("field"),
+		fieldId: z.string().min(1).max(240)
+	}),
+	z.object({
+		type: z.literal("embeddedField"),
+		optionId: z.string().min(1).max(240),
+		fieldId: z.string().min(1).max(240)
+	})
+]);
+const prefillSourceSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("static"),
+		value: responseValueSchema
+	}),
+	z.object({
+		type: z.literal("expression"),
+		expression: expressionSchema
+	}),
+	z.object({
+		type: z.literal("templateValue"),
+		key: z.string().min(1).max(240)
+	}),
+	z.object({
+		type: z.literal("previousResponse"),
+		ref: z.object({
+			surveyKey: z.string().min(1).max(240).optional(),
+			itemId: z.string().min(1).max(240),
+			target: prefillTargetSchema.optional()
+		}),
+		ifUnsupported: z.literal("skip").optional()
+	})
+]);
+const prefillSchema = z.object({
+	id: z.string().min(1).max(240),
+	target: prefillTargetSchema,
+	when: expressionSchema.optional(),
+	apply: z.literal("ifEmpty").optional(),
+	source: prefillSourceSchema
+});
+const valueTypeSchema = z.enum([
+	ValueType.string,
+	ValueType.duration,
+	ValueType.reference,
+	ValueType.number,
+	ValueType.boolean,
+	ValueType.date,
+	ValueType.stringArray,
+	ValueType.durationArray,
+	ValueType.referenceArray,
+	ValueType.numberArray,
+	ValueType.dateArray
+]);
+const templateValueSchema = z.object({
+	type: z.enum(["default", "date2string"]),
+	returnType: valueTypeSchema,
+	expression: expressionSchema.optional(),
+	dateFormat: z.string().min(1).max(120).optional()
+});
+const expressionMutationSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("set-item-display-condition"),
+		itemId: z.string().min(1).max(240),
+		expression: expressionSchema
+	}),
+	z.object({
+		kind: z.literal("clear-item-display-condition"),
+		itemId: z.string().min(1).max(240)
+	}),
+	z.object({
+		kind: z.literal("set-component-display-condition"),
+		itemId: z.string().min(1).max(240),
+		componentId: z.string().min(1).max(240),
+		expression: expressionSchema
+	}),
+	z.object({
+		kind: z.literal("clear-component-display-condition"),
+		itemId: z.string().min(1).max(240),
+		componentId: z.string().min(1).max(240)
+	}),
+	z.object({
+		kind: z.literal("set-component-disabled-condition"),
+		itemId: z.string().min(1).max(240),
+		componentId: z.string().min(1).max(240),
+		expression: expressionSchema
+	}),
+	z.object({
+		kind: z.literal("clear-component-disabled-condition"),
+		itemId: z.string().min(1).max(240),
+		componentId: z.string().min(1).max(240)
+	}),
+	z.object({
+		kind: z.literal("set-validation-expression"),
+		itemId: z.string().min(1).max(240),
+		validationKey: z.string().min(1).max(240),
+		expression: expressionSchema
+	}),
+	z.object({
+		kind: z.literal("clear-validation-expression"),
+		itemId: z.string().min(1).max(240),
+		validationKey: z.string().min(1).max(240)
+	}),
+	z.object({
+		kind: z.literal("set-prefill"),
+		itemId: z.string().min(1).max(240),
+		prefill: prefillSchema
+	}),
+	z.object({
+		kind: z.literal("clear-prefill"),
+		itemId: z.string().min(1).max(240),
+		prefillId: z.string().min(1).max(240)
+	}),
+	z.object({
+		kind: z.literal("set-template-value"),
+		templateKey: z.string().min(1).max(240),
+		templateValue: templateValueSchema
+	}),
+	z.object({
+		kind: z.literal("clear-template-value"),
+		templateKey: z.string().min(1).max(240)
+	})
+]);
+const createIssue$1 = ({ severity = "error", ...input }) => ({
+	severity,
+	...input
+});
+const pointerEscape = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
+const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getRawSurvey = (snapshot) => snapshot.survey;
+const toJsonValue = (value) => value;
+const resolveItemId = (snapshot, itemRef) => {
+	const rawItems = getRawSurveyItems(snapshot);
+	if (new Map(rawItems.map((item) => [item.id, item])).has(itemRef)) return { itemId: itemRef };
+	const keyIndexMatch = getKeyIndexEntries(snapshot).find((entry) => entry.itemId === itemRef || entry.key === itemRef || entry.fullKey === itemRef);
+	if (keyIndexMatch) return { itemId: keyIndexMatch.itemId };
+	const rawKeyMatch = rawItems.find((item) => item.key === itemRef);
+	if (rawKeyMatch) return { itemId: rawKeyMatch.id };
+	return { issue: createIssue$1({
+		code: "item-not-found",
+		message: `Could not resolve item "${itemRef}". Inspect current context or item details first.`,
+		itemId: itemRef
+	}) };
+};
+const getRawItemLocation = (snapshot, itemRef) => {
+	const resolved = resolveItemId(snapshot, itemRef);
+	if (resolved.issue || !resolved.itemId) return { issue: resolved.issue };
+	const rawItems = getRawSurveyItems(snapshot);
+	const rawIndex = rawItems.findIndex((item) => item.id === resolved.itemId);
+	if (rawIndex < 0) return { issue: createIssue$1({
+		code: "item-not-found",
+		message: `Item "${resolved.itemId}" is not present in raw survey items.`,
+		itemId: resolved.itemId
+	}) };
+	return {
+		itemId: resolved.itemId,
+		rawIndex,
+		rawItem: rawItems[rawIndex]
+	};
+};
+const addOrReplacePropertyPatch = ({ patches, parentPath, parentValue, property, value }) => {
+	const exists = isRecord$4(parentValue) && Object.prototype.hasOwnProperty.call(parentValue, property);
+	patches.push({
+		op: exists ? "replace" : "add",
+		path: `${parentPath}/${pointerEscape(property)}`,
+		value
+	});
+};
+const removePropertyPatch = ({ issues, operationIndex, patches, parentPath, parentValue, property, scope }) => {
+	if (!(isRecord$4(parentValue) && Object.prototype.hasOwnProperty.call(parentValue, property))) {
+		issues.push(createIssue$1({
+			severity: "warning",
+			code: "expression-location-already-empty",
+			message: `${scope} is already empty.`,
+			operationIndex
+		}));
+		return;
+	}
+	patches.push({
+		op: "remove",
+		path: `${parentPath}/${pointerEscape(property)}`
+	});
+};
+const addNestedConditionPatch = ({ branch, expression, patches, rawIndex, rawItem, componentId }) => {
+	const basePath = `/surveyItems/${rawIndex}/${branch}`;
+	const currentBranch = rawItem[branch];
+	if (branch === "displayConditions" && !componentId) {
+		if (!isRecord$4(currentBranch)) {
+			patches.push({
+				op: "add",
+				path: basePath,
+				value: toJsonValue({ root: expression })
+			});
+			return;
+		}
+		addOrReplacePropertyPatch({
+			patches,
+			parentPath: basePath,
+			parentValue: currentBranch,
+			property: "root",
+			value: toJsonValue(expression)
+		});
+		return;
+	}
+	if (!componentId) return;
+	if (!isRecord$4(currentBranch)) {
+		patches.push({
+			op: "add",
+			path: basePath,
+			value: toJsonValue({ components: { [componentId]: expression } })
+		});
+		return;
+	}
+	if (!isRecord$4(currentBranch.components)) {
+		patches.push({
+			op: "add",
+			path: `${basePath}/components`,
+			value: toJsonValue({ [componentId]: expression })
+		});
+		return;
+	}
+	addOrReplacePropertyPatch({
+		patches,
+		parentPath: `${basePath}/components`,
+		parentValue: currentBranch.components,
+		property: componentId,
+		value: toJsonValue(expression)
+	});
+};
+const removeNestedConditionPatch = ({ branch, componentId, issues, operationIndex, patches, rawIndex, rawItem, scope }) => {
+	const currentBranch = rawItem[branch];
+	const basePath = `/surveyItems/${rawIndex}/${branch}`;
+	if (!isRecord$4(currentBranch)) {
+		issues.push(createIssue$1({
+			severity: "warning",
+			code: "expression-location-already-empty",
+			message: `${scope} is already empty.`,
+			operationIndex
+		}));
+		return;
+	}
+	if (branch === "displayConditions" && !componentId) {
+		removePropertyPatch({
+			issues,
+			operationIndex,
+			patches,
+			parentPath: basePath,
+			parentValue: currentBranch,
+			property: "root",
+			scope
+		});
+		return;
+	}
+	removePropertyPatch({
+		issues,
+		operationIndex,
+		patches,
+		parentPath: `${basePath}/components`,
+		parentValue: currentBranch.components,
+		property: componentId ?? "",
+		scope
+	});
+};
+const buildExpressionMutationPatches = ({ mutation, operationIndex, issues, patches, responseSlotTypes, snapshot }) => {
+	if (mutation.kind === "set-template-value" || mutation.kind === "clear-template-value") {
+		const templateValues = getRawSurvey(snapshot).templateValues;
+		const basePath = "/templateValues";
+		if (mutation.kind === "clear-template-value") {
+			removePropertyPatch({
+				issues,
+				operationIndex,
+				patches,
+				parentPath: basePath,
+				parentValue: templateValues,
+				property: mutation.templateKey,
+				scope: `template value ${mutation.templateKey}`
+			});
+			return;
+		}
+		if (mutation.templateValue.expression) validateExpression({
+			expression: mutation.templateValue.expression,
+			expectedReturnType: mutation.templateValue.returnType,
+			issues,
+			operationIndex,
+			responseSlotTypes,
+			scope: `template value ${mutation.templateKey}`
+		});
+		if (mutation.templateValue.type === "date2string" && !mutation.templateValue.dateFormat) issues.push(createIssue$1({
+			code: "missing-date-format",
+			message: `Template value "${mutation.templateKey}" uses date2string and needs dateFormat.`,
+			operationIndex
+		}));
+		if (!isRecord$4(templateValues)) {
+			patches.push({
+				op: "add",
+				path: basePath,
+				value: toJsonValue({ [mutation.templateKey]: mutation.templateValue })
+			});
+			return;
+		}
+		addOrReplacePropertyPatch({
+			patches,
+			parentPath: basePath,
+			parentValue: templateValues,
+			property: mutation.templateKey,
+			value: toJsonValue(mutation.templateValue)
+		});
+		return;
+	}
+	const location = getRawItemLocation(snapshot, mutation.itemId);
+	if (location.issue || location.rawIndex === void 0 || !location.rawItem) {
+		issues.push(location.issue ?? createIssue$1({
+			code: "item-not-found",
+			message: "Item not found."
+		}));
+		return;
+	}
+	const { rawIndex, rawItem } = location;
+	const itemPath = `/surveyItems/${rawIndex}`;
+	switch (mutation.kind) {
+		case "set-item-display-condition":
+			validateExpression({
+				expression: mutation.expression,
+				expectedReturnType: ValueType.boolean,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `display condition for ${location.itemId}`
+			});
+			addNestedConditionPatch({
+				branch: "displayConditions",
+				expression: mutation.expression,
+				patches,
+				rawIndex,
+				rawItem
+			});
+			break;
+		case "clear-item-display-condition":
+			removeNestedConditionPatch({
+				branch: "displayConditions",
+				issues,
+				operationIndex,
+				patches,
+				rawIndex,
+				rawItem,
+				scope: `display condition for ${location.itemId}`
+			});
+			break;
+		case "set-component-display-condition":
+			validateExpression({
+				expression: mutation.expression,
+				expectedReturnType: ValueType.boolean,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `display condition for ${location.itemId}.${mutation.componentId}`
+			});
+			addNestedConditionPatch({
+				branch: "displayConditions",
+				componentId: mutation.componentId,
+				expression: mutation.expression,
+				patches,
+				rawIndex,
+				rawItem
+			});
+			break;
+		case "clear-component-display-condition":
+			removeNestedConditionPatch({
+				branch: "displayConditions",
+				componentId: mutation.componentId,
+				issues,
+				operationIndex,
+				patches,
+				rawIndex,
+				rawItem,
+				scope: `display condition for ${location.itemId}.${mutation.componentId}`
+			});
+			break;
+		case "set-component-disabled-condition":
+			validateExpression({
+				expression: mutation.expression,
+				expectedReturnType: ValueType.boolean,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `disabled condition for ${location.itemId}.${mutation.componentId}`
+			});
+			addNestedConditionPatch({
+				branch: "disabledConditions",
+				componentId: mutation.componentId,
+				expression: mutation.expression,
+				patches,
+				rawIndex,
+				rawItem
+			});
+			break;
+		case "clear-component-disabled-condition":
+			removeNestedConditionPatch({
+				branch: "disabledConditions",
+				componentId: mutation.componentId,
+				issues,
+				operationIndex,
+				patches,
+				rawIndex,
+				rawItem,
+				scope: `disabled condition for ${location.itemId}.${mutation.componentId}`
+			});
+			break;
+		case "set-validation-expression":
+			validateExpression({
+				expression: mutation.expression,
+				expectedReturnType: ValueType.boolean,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `validation ${mutation.validationKey} for ${location.itemId}`
+			});
+			if (!isRecord$4(rawItem.validations)) patches.push({
+				op: "add",
+				path: `${itemPath}/validations`,
+				value: toJsonValue({ [mutation.validationKey]: mutation.expression })
+			});
+			else addOrReplacePropertyPatch({
+				patches,
+				parentPath: `${itemPath}/validations`,
+				parentValue: rawItem.validations,
+				property: mutation.validationKey,
+				value: toJsonValue(mutation.expression)
+			});
+			break;
+		case "clear-validation-expression":
+			removePropertyPatch({
+				issues,
+				operationIndex,
+				patches,
+				parentPath: `${itemPath}/validations`,
+				parentValue: rawItem.validations,
+				property: mutation.validationKey,
+				scope: `validation ${mutation.validationKey} for ${location.itemId}`
+			});
+			break;
+		case "set-prefill": {
+			validateExpression({
+				expression: mutation.prefill.when,
+				expectedReturnType: mutation.prefill.when ? ValueType.boolean : void 0,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `prefill ${mutation.prefill.id} condition for ${location.itemId}`
+			});
+			if (mutation.prefill.source.type === "expression") validateExpression({
+				expression: mutation.prefill.source.expression,
+				issues,
+				operationIndex,
+				responseSlotTypes,
+				scope: `prefill ${mutation.prefill.id} source expression for ${location.itemId}`
+			});
+			const prefills = Array.isArray(rawItem.prefills) ? rawItem.prefills : void 0;
+			const existingIndex = prefills?.findIndex((prefill) => isRecord$4(prefill) && prefill.id === mutation.prefill.id);
+			if (!prefills) patches.push({
+				op: "add",
+				path: `${itemPath}/prefills`,
+				value: toJsonValue([mutation.prefill])
+			});
+			else if (existingIndex !== void 0 && existingIndex >= 0) patches.push({
+				op: "replace",
+				path: `${itemPath}/prefills/${existingIndex}`,
+				value: toJsonValue(mutation.prefill)
+			});
+			else patches.push({
+				op: "add",
+				path: `${itemPath}/prefills/-`,
+				value: toJsonValue(mutation.prefill)
+			});
+			break;
+		}
+		case "clear-prefill": {
+			const existingIndex = (Array.isArray(rawItem.prefills) ? rawItem.prefills : []).findIndex((prefill) => isRecord$4(prefill) && prefill.id === mutation.prefillId);
+			if (existingIndex < 0) {
+				issues.push(createIssue$1({
+					severity: "warning",
+					code: "expression-location-already-empty",
+					message: `Prefill "${mutation.prefillId}" is not present on ${location.itemId}.`,
+					operationIndex
+				}));
+				return;
+			}
+			patches.push({
+				op: "remove",
+				path: `${itemPath}/prefills/${existingIndex}`
+			});
+			break;
+		}
+	}
+};
+//#endregion
+//#region src/engine/normalization.ts
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getString = (value) => typeof value === "string" ? value.trim() : void 0;
+const normalizeChoiceMaxSelection = (config) => {
+	if (config.maxSelection === null) return null;
+	if (typeof config.maxSelection === "number" && Number.isFinite(config.maxSelection)) return Math.max(1, Math.floor(config.maxSelection));
+	if (typeof config.maxSelection === "string") {
+		const normalized = config.maxSelection.trim().toLowerCase();
+		if (normalized === "multiple" || normalized === "multi" || normalized === "unlimited" || normalized === "none") return null;
+		const parsed = Number.parseInt(normalized, 10);
+		if (Number.isFinite(parsed) && parsed >= 1) return parsed;
+	}
+	const mode = getString(config.mode)?.toLowerCase() ?? getString(config.selectionType)?.toLowerCase() ?? getString(config.selectionMode)?.toLowerCase();
+	if (mode === "multiple" || mode === "multi" || mode === "multi-select" || mode === "multiselect" || mode === "checkbox" || mode === "checkboxes") return null;
+	return 1;
+};
+const humanizeKey = (value) => value.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+const normalizeLayout = (value) => {
+	const baseLayout = {
+		base: 1,
+		xs: 1,
+		sm: 1,
+		md: 1,
+		xl: 1
+	};
+	if (!isRecord$3(value)) return baseLayout;
+	const normalized = { ...baseLayout };
+	for (const key of Object.keys(normalized)) {
+		const count = value[key];
+		if (typeof count === "number" && Number.isFinite(count)) normalized[key] = Math.min(4, Math.max(1, Math.round(count)));
+	}
+	return normalized;
+};
+const normalizeKey = (value) => value.trim().replace(/[.\s]+/g, "_").replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+const textInline = (text, style) => ({
+	type: "text",
+	text,
+	...style ? { style } : {}
+});
+const paragraphBlock = (text, style) => ({
+	type: "paragraph",
+	children: [textInline(text, style)]
+});
+const getBlockText = (block) => getString(block.text) ?? getString(block.content) ?? getString(block.label);
+const normalizeAssistantHeadingLevel = (level) => Math.min(2, Math.max(1, Math.round(level)));
+const normalizeRichTextStyle = (value) => {
+	const rawStyle = isRecord$3(value.style) ? value.style : {};
+	const style = {};
+	const weight = rawStyle.weight ?? value.weight;
+	const italic = rawStyle.italic ?? value.italic;
+	const underline = rawStyle.underline ?? value.underline;
+	const color = rawStyle.color ?? value.color;
+	if (value.strong === true || value.bold === true || weight === "strong" || weight === "bold") style.weight = "strong";
+	else if (weight === "normal") style.weight = "normal";
+	if (value.italic === true || italic === "italic") style.italic = "italic";
+	else if (italic === "normal") style.italic = "normal";
+	if (value.underline === true || underline === "underline") style.underline = "underline";
+	else if (underline === "none") style.underline = "none";
+	if (color === "primary" || color === "accent" || color === "default") style.color = color;
+	return Object.keys(style).length > 0 ? style : void 0;
+};
+const normalizeRichTextInline = (value, allowLink = true) => {
+	if (typeof value === "string") return textInline(value);
+	if (!isRecord$3(value)) return;
+	const type = getString(value.type)?.toLowerCase();
+	if (type === "linebreak" || type === "line-break" || type === "break") return { type: "lineBreak" };
+	if (type === "link" && allowLink) {
+		const href = getString(value.href) ?? getString(value.url);
+		if (!href) return;
+		return {
+			type: "link",
+			href,
+			children: (Array.isArray(value.children) ? value.children : [getString(value.text) ?? getString(value.label) ?? href]).map((child) => normalizeRichTextInline(child, false)).filter((child) => child !== void 0 && child.type !== "link")
+		};
+	}
+	const text = getBlockText(value);
+	return text === void 0 ? void 0 : textInline(text, normalizeRichTextStyle(value));
+};
+const normalizeRichTextChildren = (value) => {
+	if (!Array.isArray(value.children)) return;
+	const children = value.children.map((child) => normalizeRichTextInline(child)).filter((child) => Boolean(child));
+	return children.length > 0 ? children : void 0;
+};
+const normalizeRichTextBlock = (value) => {
+	if (typeof value === "string") return paragraphBlock(value);
+	if (!isRecord$3(value)) return;
+	const type = getString(value.type)?.toLowerCase();
+	const text = getBlockText(value);
+	const style = normalizeRichTextStyle(value);
+	const children = normalizeRichTextChildren(value);
+	if (type === "heading" || /^h[1-6]$/.test(type ?? "")) return {
+		type: "heading",
+		level: normalizeAssistantHeadingLevel(typeof value.level === "number" ? value.level : type === "h1" ? 1 : 2),
+		children: children ?? [textInline(text ?? "", style)]
+	};
+	if (type === "bulletlist" || type === "bullet-list" || type === "list" || type === "bullets") return {
+		type: "bulletList",
+		items: (Array.isArray(value.items) ? value.items : []).map((item) => {
+			const itemText = typeof item === "string" ? item : isRecord$3(item) ? getBlockText(item) : void 0;
+			return itemText ? {
+				type: "listItem",
+				children: [paragraphBlock(itemText)]
+			} : void 0;
+		}).filter((item) => Boolean(item))
+	};
+	if (type === "infobox" || type === "info-box" || type === "note" || type === "footnote") return {
+		type: "infoBox",
+		tone: value.tone === "warning" ? "warning" : "info",
+		title: getString(value.title) ? [textInline(getString(value.title) ?? "")] : void 0,
+		collapsible: value.collapsible === true,
+		defaultOpen: value.defaultOpen !== false,
+		children: [paragraphBlock(text ?? "")]
+	};
+	if (type === "separator" || type === "divider" || type === "rule") return { type: "separator" };
+	if (type === "paragraph" || text) return children ? {
+		type: "paragraph",
+		children
+	} : paragraphBlock(text ?? "", style);
+};
+const normalizeRichTextContent = (value) => {
+	if (!isRecord$3(value)) return value;
+	if (value.type === ContentType.richText && isRecord$3(value.doc) && value.version === 1) return value;
+	const candidateBlocks = Array.isArray(value.richTextBlocks) ? value.richTextBlocks : Array.isArray(value.blocks) ? value.blocks : void 0;
+	if (!candidateBlocks) return value;
+	const blocks = candidateBlocks.map(normalizeRichTextBlock).filter((block) => Boolean(block));
+	return {
+		type: ContentType.richText,
+		version: 1,
+		doc: {
+			type: "doc",
+			blocks
+		}
+	};
+};
+const normalizeLooseTranslationRecord = (value) => {
+	const locale = getString(value.locale);
+	const contentKey = getString(value.contentKey);
+	if (!locale || !contentKey) return;
+	const content = normalizeRichTextContent(value.content ?? (Array.isArray(value.blocks) || Array.isArray(value.richTextBlocks) ? value : void 0));
+	const plainText = typeof value.plainText === "string" ? value.plainText : void 0;
+	if (isRecord$3(content) && content.type) return {
+		locale,
+		contentKey,
+		content
+	};
+	if (plainText !== void 0) return {
+		locale,
+		contentKey,
+		plainText
+	};
+	const shorthandText = getString(value.text) ?? getString(value.label);
+	return shorthandText ? {
+		locale,
+		contentKey,
+		plainText: shorthandText
+	} : void 0;
+};
+const toTranslation = (locale, contentKey, value) => {
+	if (typeof value === "string") return {
+		locale,
+		contentKey,
+		plainText: value
+	};
+	if (!isRecord$3(value)) return;
+	const normalizedContent = normalizeRichTextContent(value);
+	if (isRecord$3(normalizedContent) && normalizedContent.type === ContentType.richText && isRecord$3(normalizedContent.doc) && normalizedContent.version === 1) return {
+		locale,
+		contentKey,
+		content: normalizedContent
+	};
+	if ((value.type === ContentType.md || value.type === ContentType.plain) && typeof value.content === "string") return {
+		locale,
+		contentKey,
+		content: value
+	};
+	if (value.type === ContentType.richText && isRecord$3(value.doc) && value.version === 1) return {
+		locale,
+		contentKey,
+		content: value
+	};
+	const shorthandText = getString(value.text) ?? getString(value.content) ?? getString(value.label);
+	return shorthandText ? {
+		locale,
+		contentKey,
+		plainText: shorthandText
+	} : void 0;
+};
+const upsertLooseTranslation = (translations, next) => {
+	if (!next) return;
+	const existingIndex = translations.findIndex((translation) => translation.locale === next.locale && translation.contentKey === next.contentKey);
+	if (existingIndex >= 0) {
+		translations[existingIndex] = next;
+		return;
+	}
+	translations.push(next);
+};
+const flattenLooseItemTranslations = (value) => {
+	if (Array.isArray(value)) return value.filter(isRecord$3).map(normalizeLooseTranslationRecord).filter((translation) => Boolean(translation));
+	if (!isRecord$3(value)) return [];
+	const translations = [];
+	for (const [locale, localeValue] of Object.entries(value)) {
+		if (!isRecord$3(localeValue)) continue;
+		const appendContentMap = (contentMap) => {
+			for (const [contentKey, contentValue] of Object.entries(contentMap)) {
+				if (contentKey === "options" && isRecord$3(contentValue)) {
+					for (const [optionId, optionLabel] of Object.entries(contentValue)) upsertLooseTranslation(translations, toTranslation(locale, `options.${optionId}.label`, optionLabel));
+					continue;
+				}
+				if (contentKey === "fieldGroups" && Array.isArray(contentValue)) {
+					for (const group of contentValue) {
+						if (!isRecord$3(group)) continue;
+						const groupId = getString(group.id) ?? getString(group.groupId);
+						if (!groupId) continue;
+						upsertLooseTranslation(translations, toTranslation(locale, `fieldGroups.${groupId}.title`, group.title));
+						upsertLooseTranslation(translations, toTranslation(locale, `fieldGroups.${groupId}.description`, group.description));
+					}
+					continue;
+				}
+				upsertLooseTranslation(translations, toTranslation(locale, contentKey, contentValue));
+			}
+		};
+		if (isRecord$3(localeValue.itemTranslations)) {
+			for (const itemTranslation of Object.values(localeValue.itemTranslations)) if (isRecord$3(itemTranslation)) appendContentMap(itemTranslation);
+			continue;
+		}
+		appendContentMap(localeValue);
+	}
+	return translations;
+};
+const appendParenthetical = (text, note) => {
+	if (!note) return text;
+	if (text.toLowerCase().includes(note.toLowerCase())) return text;
+	return `${text} (${note})`;
+};
+const appendMarker = (text, marker) => {
+	if (!marker || text.endsWith(marker)) return text;
+	return `${text}${marker}`;
+};
+const getOptionNote = (option) => getString(option.note) ?? getString(option.description) ?? getString(option.helpText) ?? getString(option.instruction);
+const getFootnoteMarker = (option) => getString(option.footnoteMarker) ?? getString(option.marker);
+const hasEmbeddedForm = (option) => isRecord$3(option.embeddedForm);
+const stripTrailingEmbeddedFormCue = (text, option) => {
+	if (!hasEmbeddedForm(option)) return text;
+	return text.replace(/\s*[,;:]?\s*(namelijk|namely|please specify|specify|explain|explanation|toelichting)\s*[:.]?\s*$/iu, "").trim();
+};
+const getOptionTranslationLabel = (option) => {
+	const directLabel = getString(option.label) ?? getString(option.text) ?? getString(option.title);
+	if (directLabel) return appendMarker(stripTrailingEmbeddedFormCue(appendParenthetical(directLabel, getOptionNote(option)), option), getFootnoteMarker(option));
+	if (!isRecord$3(option.translations)) return;
+	for (const localeValue of Object.values(option.translations)) {
+		if (!isRecord$3(localeValue)) continue;
+		const translatedLabel = getString(localeValue.label) ?? getString(localeValue.text);
+		if (translatedLabel) {
+			const translatedNote = getString(localeValue.note) ?? getString(localeValue.description) ?? getString(localeValue.helpText) ?? getString(localeValue.instruction);
+			const translatedMarker = getString(localeValue.footnoteMarker) ?? getString(localeValue.marker);
+			return appendMarker(stripTrailingEmbeddedFormCue(appendParenthetical(translatedLabel, translatedNote), option), translatedMarker);
+		}
+	}
+};
+const getSelectOptionTranslationLabel = (option) => getString(option.label) ?? getString(option.text) ?? getString(option.title) ?? getString(option.name);
+const normalizeSelectControllerOptions = ({ controller, fieldId, translations }) => {
+	if (controller.type !== "select" || !Array.isArray(controller.options)) return controller;
+	return {
+		...controller,
+		options: controller.options.map((option, index) => {
+			if (!isRecord$3(option)) return option;
+			const optionLabel = getSelectOptionTranslationLabel(option);
+			const optionId = normalizeKey(getString(option.id) ?? getString(option.optionId) ?? getString(option.value) ?? (optionLabel ? normalizeKey(optionLabel) : void 0) ?? `option_${index + 1}`) || `option_${index + 1}`;
+			const value = getString(option.value) ?? optionId;
+			if (optionLabel) translations.push({
+				contentKey: `fields.${fieldId}.options.${optionId}.label`,
+				plainText: optionLabel
+			});
+			return {
+				...option,
+				id: optionId,
+				value
+			};
+		})
+	};
+};
+const appendOptionTranslationLabels = (translations, option, optionId) => {
+	if (!optionId || !isRecord$3(option.translations)) return;
+	for (const [locale, localeValue] of Object.entries(option.translations)) {
+		if (!isRecord$3(localeValue)) continue;
+		upsertLooseTranslation(translations, toTranslation(locale, `options.${optionId}.label`, localeValue.label ?? localeValue.text));
+	}
+};
+const normalizeLooseField = (field) => {
+	if (!isRecord$3(field)) return { translations: [] };
+	const rawId = getString(field.id) ?? getString(field.fieldId) ?? getString(field.key);
+	const id = rawId ? normalizeKey(rawId) : void 0;
+	if (!id) return { translations: [] };
+	const rawType = getString(field.type) ?? getString(field.controlType) ?? "input";
+	const type = rawType === "text" || rawType === "email" ? "input" : rawType === "checkbox" ? "switch" : rawType;
+	const controller = rawType === "textarea" ? {
+		type: "textarea",
+		rows: 3
+	} : rawType === "number" ? {
+		type: "number",
+		step: 1
+	} : rawType === "checkbox" ? {
+		type: "switch",
+		defaultChecked: false
+	} : rawType === "select" ? {
+		type: "select",
+		options: []
+	} : {
+		type: "input",
+		inputMode: rawType === "email" ? "email" : "text"
+	};
+	const translations = [{
+		contentKey: `fields.${id}.label`,
+		plainText: getString(field.label) ?? humanizeKey(id)
+	}];
+	const placeholder = getString(field.placeholder);
+	if (placeholder) translations.push({
+		contentKey: `fields.${id}.placeholder`,
+		plainText: placeholder
+	});
+	const description = getString(field.description);
+	if (description) translations.push({
+		contentKey: `fields.${id}.description`,
+		plainText: description
+	});
+	const unit = getString(field.unit);
+	if (unit) translations.push({
+		contentKey: `fields.${id}.unit`,
+		plainText: unit
+	});
+	return {
+		field: {
+			id,
+			key: getString(field.key) ?? id.toUpperCase(),
+			type,
+			required: field.required === true,
+			controller: normalizeSelectControllerOptions({
+				controller: isRecord$3(field.controller) ? field.controller : controller,
+				fieldId: id,
+				translations
+			}),
+			validations: Array.isArray(field.validations) && field.validations.length > 0 ? field.validations : rawType === "email" ? [{
+				id: "email",
+				type: "email"
+			}] : []
+		},
+		translations
+	};
+};
+const normalizeFormFieldGroupSelectOptions = (fieldGroups) => {
+	if (!Array.isArray(fieldGroups)) return {
+		fieldGroups,
+		translations: []
+	};
+	const translations = [];
+	return {
+		fieldGroups: fieldGroups.map((group) => {
+			if (!isRecord$3(group) || !Array.isArray(group.fields)) return group;
+			return {
+				...group,
+				fields: group.fields.map((field) => {
+					if (!isRecord$3(field)) return field;
+					const fieldId = getString(field.id) ?? getString(field.fieldId) ?? getString(field.key);
+					const controller = isRecord$3(field.controller) ? field.controller : void 0;
+					if (!fieldId || !controller || controller.type !== "select") return field;
+					return {
+						...field,
+						controller: normalizeSelectControllerOptions({
+							controller,
+							fieldId,
+							translations
+						})
+					};
+				})
+			};
+		}),
+		translations
+	};
+};
+const normalizeLooseCreateOperation = (operation, defaultLocale) => {
+	if (!isRecord$3(operation) || !isRecord$3(operation.item)) return operation;
+	if ((getString(operation.kind) ?? getString(operation.op)) !== "create-item") return operation;
+	const item = { ...operation.item };
+	const translations = [...flattenLooseItemTranslations(operation.translations), ...flattenLooseItemTranslations(item.translations)];
+	if (!getString(item.id)) {
+		const itemId = getString(item.key) ?? getString(item.label);
+		if (itemId) item.id = normalizeKey(itemId);
+	}
+	if (!isRecord$3(item.config) && isRecord$3(operation.config)) item.config = operation.config;
+	if (item.itemType === "choiceItem") {
+		const rawConfig = isRecord$3(item.config) ? item.config : {};
+		const choiceConfig = isRecord$3(item.choiceConfig) ? item.choiceConfig : {};
+		const looseOptions = Array.isArray(item.options) ? item.options : void 0;
+		const config = {
+			...choiceConfig,
+			...rawConfig,
+			...!Array.isArray(rawConfig.options) && looseOptions ? { options: looseOptions } : {}
+		};
+		config.id = getString(config.id) ?? getString(item.id) ?? getString(item.key);
+		config.maxSelection = normalizeChoiceMaxSelection(config);
+		config.shuffleOptions = config.shuffleOptions === true;
+		if (Array.isArray(config.options)) config.options = config.options.map((option) => {
+			if (!isRecord$3(option)) return option;
+			const optionLabel = getOptionTranslationLabel(option);
+			const optionId = getString(option.id) ?? getString(option.optionId) ?? getString(option.value) ?? (optionLabel ? normalizeKey(optionLabel) : void 0);
+			appendOptionTranslationLabels(translations, option, optionId);
+			return {
+				...option,
+				id: optionId,
+				key: getString(option.key) ?? getString(option.value) ?? getString(option.optionId),
+				label: optionLabel
+			};
+		});
+		item.config = config;
+		delete item.choiceConfig;
+		delete item.options;
+	}
+	if (item.itemType === "formItem" && isRecord$3(item.config)) {
+		const config = { ...item.config };
+		config.id = getString(config.id) ?? getString(item.id) ?? getString(item.key);
+		const looseFields = Array.isArray(config.fields) ? config.fields : [];
+		const fieldTranslations = [];
+		const normalizedLooseFields = looseFields.map((field) => {
+			const normalized = normalizeLooseField(field);
+			fieldTranslations.push(...normalized.translations);
+			return normalized.field;
+		}).filter((field) => Boolean(field));
+		if (Array.isArray(config.fieldGroups)) config.fieldGroups = config.fieldGroups.map((group, index) => {
+			if (!isRecord$3(group)) return group;
+			return {
+				...group,
+				id: getString(group.id) ?? getString(group.groupId) ?? `group_${index + 1}`,
+				layout: normalizeLayout(group.layout),
+				fields: Array.isArray(group.fields) && group.fields.length > 0 ? group.fields : index === 0 ? normalizedLooseFields : []
+			};
+		});
+		else if (normalizedLooseFields.length > 0) config.fieldGroups = [{
+			id: "main",
+			layout: {
+				base: 1,
+				xs: 1,
+				sm: 1,
+				md: 1,
+				xl: 1
+			},
+			fields: normalizedLooseFields
+		}];
+		delete config.fields;
+		const normalizedSelectOptions = normalizeFormFieldGroupSelectOptions(config.fieldGroups);
+		config.fieldGroups = normalizedSelectOptions.fieldGroups;
+		fieldTranslations.push(...normalizedSelectOptions.translations);
+		for (const translation of fieldTranslations) upsertLooseTranslation(translations, {
+			locale: defaultLocale,
+			contentKey: translation.contentKey,
+			plainText: translation.plainText
+		});
+		item.config = config;
+	}
+	delete item.translations;
+	return {
+		...operation,
+		kind: "create-item",
+		item,
+		...translations.length > 0 ? { translations } : {}
+	};
+};
+/**
+* Accepts common model-authored shorthand and converts it to the strict
+* assistant operation shape before validation. This keeps the public tool
+* compact while making it tolerant of predictable schema-near authoring
+* mistakes: nested raw translation maps, sibling config objects, choice
+* optionId aliases, and flat form fields.
+*/
+const normalizeSurveyChangeOperations = (operations, defaultLocale) => operations.map((operation) => normalizeLooseCreateOperation(operation, defaultLocale));
+//#endregion
+//#region src/engine/operations.ts
+const ITEM_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL = 200;
+const CHOICE_ITEM_TYPE = "choiceItem";
+const FORM_ITEM_TYPE = "formItem";
+const CHOICE_OPTION_LABEL_CONTENT_KEY_PATTERN = /^options\.([^.]+)\.label$/;
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getTrimmedString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const getFirstStringProperty = (record, keys) => {
+	for (const key of keys) {
+		const value = getTrimmedString(record[key]);
+		if (value) return value;
+	}
+};
+const isContent = (value) => {
+	if (!isRecord$2(value)) return false;
+	if ((value.type === ContentType.md || value.type === ContentType.plain) && typeof value.content === "string") return true;
+	return value.type === ContentType.richText && value.version === 1 && isRecord$2(value.doc) && value.doc.type === "doc" && Array.isArray(value.doc.blocks);
+};
+const cloneContent = (content) => structuredCloneMethod(content);
+const getTranslationPlainText = ({ content, plainText }) => {
+	if (content) return getContentPlainText(content).trim();
+	return (plainText ?? "").trim();
+};
+const isTranslationContentEmpty = ({ content, plainText }) => content ? isContentEmpty(content) : (plainText ?? "").trim().length === 0;
+const getCreateItemNestedTranslations = (item) => {
+	const rawTranslations = item.translations;
+	if (!Array.isArray(rawTranslations)) return [];
+	return rawTranslations.filter(isRecord$2).map((translation) => {
+		const locale = getTrimmedString(translation.locale);
+		const contentKey = getTrimmedString(translation.contentKey);
+		const content = isContent(translation.content) ? cloneContent(translation.content) : void 0;
+		const plainText = typeof translation.plainText === "string" ? translation.plainText : void 0;
+		if (!locale || !contentKey || !content && plainText === void 0) return;
+		return {
+			locale,
+			contentKey,
+			...plainText !== void 0 ? { plainText } : {},
+			...content ? { content } : {}
+		};
+	}).filter((translation) => Boolean(translation));
+};
+const getGroupChildren = (item) => {
+	const items = (isRecord$2(item?.config) ? item.config : void 0)?.items;
+	if (!Array.isArray(items)) return [];
+	return items.filter((entry) => typeof entry === "string");
+};
+const isRootItem = (item) => {
+	return (isRecord$2(item?.config) ? item.config : void 0)?.isRoot === true;
+};
+const isSurveyJsonPatchOperation = (operation) => operation.kind === "survey-json-patch";
+const getPatchTouchedPaths = (operation) => operation.patches.flatMap((patch) => "from" in patch ? [patch.path, patch.from] : [patch.path]);
+const touchesSurveySchemaPath = (path) => {
+	return parseJsonPointer(path)[0] === "$schema";
+};
+const isTranslationContainerMutation = (patch) => patch.op !== "test";
+const validateTranslationPatchSafety = ({ operation, survey }) => {
+	const issues = [];
+	const operationId = getOperationId(operation);
+	const translations = survey.translations ?? {};
+	for (const [patchIndex, patch] of operation.patches.entries()) {
+		const paths = patch.op === "move" ? [patch.path, patch.from] : [patch.path];
+		for (const path of paths) {
+			let segments;
+			try {
+				segments = parseJsonPointer(path);
+			} catch {
+				continue;
+			}
+			if (segments[0] !== "translations" || !isTranslationContainerMutation(patch)) continue;
+			if (segments.length === 1) {
+				issues.push(createIssue({
+					code: "unsafe-translation-root-patch",
+					message: "Raw patches cannot replace or remove the complete translations map. Patch a specific locale/content leaf or use typed translation operations.",
+					operationIndex: patchIndex,
+					operationId
+				}));
+				continue;
+			}
+			const locale = segments[1];
+			const localeTranslations = translations[locale];
+			if (segments.length === 2 && localeTranslations !== void 0) {
+				issues.push(createIssue({
+					code: "unsafe-locale-translation-patch",
+					message: `Raw patch ${patchIndex} would replace or remove the existing ${locale} locale branch and discard sibling translations. Patch a leaf under /translations/${locale}/itemTranslations/<itemId>/... instead.`,
+					operationIndex: patchIndex,
+					operationId
+				}));
+				continue;
+			}
+			if (segments[2] === "itemTranslations" && segments.length === 4 && localeTranslations?.itemTranslations?.[segments[3]] !== void 0) issues.push(createIssue({
+				code: "unsafe-item-translation-patch",
+				message: `Raw patch ${patchIndex} would replace or remove all existing translations for item "${segments[3]}" in locale ${locale}. Patch the individual content key instead, or use update-item-translation.`,
+				operationIndex: patchIndex,
+				operationId,
+				itemId: segments[3]
+			}));
+		}
+	}
+	return issues;
+};
+const validateTranslationBranchShapes = ({ operation, survey }) => {
+	const issues = [];
+	const operationId = getOperationId(operation);
+	for (const [locale, localeTranslations] of Object.entries(survey.translations ?? {})) {
+		if (!isRecord$2(localeTranslations)) {
+			issues.push(createIssue({
+				code: "invalid-locale-translation-shape",
+				message: `Locale "${locale}" must be a translation object, not an array or primitive value.`,
+				operationIndex: 0,
+				operationId
+			}));
+			continue;
+		}
+		if (localeTranslations.itemTranslations !== void 0 && !isRecord$2(localeTranslations.itemTranslations)) issues.push(createIssue({
+			code: "invalid-item-translations-shape",
+			message: `Locale "${locale}" itemTranslations must be an object keyed by item id.`,
+			operationIndex: 0,
+			operationId
+		}));
+	}
+	return issues;
+};
+const getRawItemsFromSurvey = (survey) => Array.isArray(survey.surveyItems) ? survey.surveyItems : [];
+const createStructureIssue = ({ code, message, operationId, itemId }) => createIssue({
+	code,
+	message,
+	operationIndex: 0,
+	operationId,
+	itemId
+});
+const buildResponseSlotTypesForDraft = ({ currentItem, rawItemsById, snapshot }) => {
+	const draftItems = Array.from(rawItemsById.values());
+	if (currentItem) {
+		const existingIndex = draftItems.findIndex((item) => item.id === currentItem.id);
+		if (existingIndex >= 0) draftItems[existingIndex] = currentItem;
+		else draftItems.push(currentItem);
+	}
+	return deriveResponseSlotTypes({
+		...snapshot.survey,
+		surveyItems: draftItems
+	});
+};
+const isJsonExpression = (value) => isRecord$2(value) && typeof value.type === "string";
+const validateCreateItemExpressions = ({ issues, item, operationId, operationIndex, responseSlotTypes }) => {
+	const addExpressionValidation = (expression, scope, expectedReturnType) => {
+		if (!isJsonExpression(expression)) {
+			issues.push(createIssue({
+				code: "invalid-expression",
+				message: `${scope} must be a CASE expression JSON object.`,
+				operationIndex,
+				operationId,
+				itemId: item.id
+			}));
+			return;
+		}
+		const beforeCount = issues.length;
+		validateExpression({
+			expression,
+			expectedReturnType,
+			issues,
+			operationIndex,
+			responseSlotTypes,
+			scope
+		});
+		for (const issue of issues.slice(beforeCount)) {
+			issue.operationId = issue.operationId ?? operationId;
+			issue.itemId = issue.itemId ?? item.id;
+		}
+	};
+	const displayConditions = isRecord$2(item.displayConditions) ? item.displayConditions : void 0;
+	if (displayConditions?.root !== void 0) addExpressionValidation(displayConditions.root, `display condition for new item ${item.id}`, ValueType.boolean);
+	const displayComponents = isRecord$2(displayConditions?.components) ? displayConditions.components : void 0;
+	for (const [componentId, expression] of Object.entries(displayComponents ?? {})) addExpressionValidation(expression, `display condition for new item ${item.id}.${componentId}`, ValueType.boolean);
+	const disabledConditions = isRecord$2(item.disabledConditions) ? item.disabledConditions : void 0;
+	const disabledComponents = isRecord$2(disabledConditions?.components) ? disabledConditions.components : void 0;
+	for (const [componentId, expression] of Object.entries(disabledComponents ?? {})) addExpressionValidation(expression, `disabled condition for new item ${item.id}.${componentId}`, ValueType.boolean);
+	const validations = isRecord$2(item.validations) ? item.validations : void 0;
+	for (const [validationKey, expression] of Object.entries(validations ?? {})) addExpressionValidation(expression, `validation ${validationKey} for new item ${item.id}`, ValueType.boolean);
+	const prefills = Array.isArray(item.prefills) ? item.prefills : [];
+	for (const prefill of prefills) {
+		if (!isRecord$2(prefill)) continue;
+		const prefillId = getTrimmedString(prefill.id) ?? "unnamed";
+		if (prefill.when !== void 0) addExpressionValidation(prefill.when, `prefill ${prefillId} condition for new item ${item.id}`, ValueType.boolean);
+		const source = isRecord$2(prefill.source) ? prefill.source : void 0;
+		if (source?.type === "expression") addExpressionValidation(source.expression, `prefill ${prefillId} source expression for new item ${item.id}`);
+	}
+};
+const validateSurveyTreeStructure = (survey, operationId, availableItemTypes) => {
+	const issues = [];
+	if (!isRecord$2(survey)) return [createStructureIssue({
+		code: "patched-survey-not-object",
+		message: "The patched survey must be a JSON object.",
+		operationId
+	})];
+	if (typeof survey.$schema !== "string" || survey.$schema.trim().length === 0) issues.push(createStructureIssue({
+		code: "missing-survey-schema",
+		message: "The patched survey must keep a non-empty $schema value.",
+		operationId
+	}));
+	if (!Array.isArray(survey.surveyItems) || survey.surveyItems.length === 0) {
+		issues.push(createStructureIssue({
+			code: "missing-survey-items",
+			message: "The patched survey must contain at least one survey item.",
+			operationId
+		}));
+		return issues;
+	}
+	const itemsById = /* @__PURE__ */ new Map();
+	const rootItems = [];
+	for (const [itemIndex, item] of survey.surveyItems.entries()) {
+		if (!isRecord$2(item)) {
+			issues.push(createStructureIssue({
+				code: "invalid-survey-item",
+				message: `Survey item at index ${itemIndex} must be an object.`,
+				operationId
+			}));
+			continue;
+		}
+		const itemId = getTrimmedString(item.id);
+		const itemKey = getTrimmedString(item.key);
+		const itemType = getTrimmedString(item.itemType);
+		if (!itemId || !itemKey || !itemType) {
+			issues.push(createStructureIssue({
+				code: "invalid-survey-item-identity",
+				message: `Survey item at index ${itemIndex} must have non-empty id, key, and itemType fields.`,
+				operationId,
+				itemId
+			}));
+			continue;
+		}
+		if (!availableItemTypes.has(itemType)) issues.push(createStructureIssue({
+			code: "unknown-item-type",
+			message: `Item "${itemId}" uses item type "${itemType}", which is not available in the current editor registry.`,
+			operationId,
+			itemId
+		}));
+		if (!ITEM_KEY_PATTERN.test(itemKey)) issues.push(createStructureIssue({
+			code: "invalid-item-key",
+			message: `Item "${itemId}" has an invalid key. Keys must contain only letters, numbers, underscores, or hyphens.`,
+			operationId,
+			itemId
+		}));
+		if (itemsById.has(itemId)) {
+			issues.push(createStructureIssue({
+				code: "duplicate-item-id",
+				message: `The patched survey contains duplicate item id "${itemId}".`,
+				operationId,
+				itemId
+			}));
+			continue;
+		}
+		const rawItem = item;
+		itemsById.set(itemId, rawItem);
+		if (isRootItem(rawItem)) rootItems.push(rawItem);
+	}
+	if (rootItems.length !== 1) issues.push(createStructureIssue({
+		code: "invalid-root-count",
+		message: rootItems.length === 0 ? "The patched survey must contain one root group item." : "The patched survey cannot contain more than one root group item.",
+		operationId
+	}));
+	else if (rootItems[0].itemType !== ReservedSurveyItemTypes.Group) issues.push(createStructureIssue({
+		code: "root-not-group",
+		message: "The root item must be a group item.",
+		operationId,
+		itemId: rootItems[0].id
+	}));
+	const parentByChildId = /* @__PURE__ */ new Map();
+	for (const item of itemsById.values()) {
+		const childRefs = (isRecord$2(item.config) ? item.config : void 0)?.items;
+		if (childRefs === void 0) continue;
+		if (item.itemType !== ReservedSurveyItemTypes.Group || !Array.isArray(childRefs)) {
+			issues.push(createStructureIssue({
+				code: "invalid-group-items",
+				message: `Item "${item.id}" has an items array but is not a valid group item.`,
+				operationId,
+				itemId: item.id
+			}));
+			continue;
+		}
+		const seenChildRefs = /* @__PURE__ */ new Set();
+		for (const childId of childRefs) {
+			if (typeof childId !== "string" || childId.trim().length === 0) {
+				issues.push(createStructureIssue({
+					code: "invalid-child-reference",
+					message: `Group item "${item.id}" contains an invalid child reference.`,
+					operationId,
+					itemId: item.id
+				}));
+				continue;
+			}
+			if (childId === item.id) issues.push(createStructureIssue({
+				code: "self-child-reference",
+				message: `Group item "${item.id}" cannot include itself as a child.`,
+				operationId,
+				itemId: item.id
+			}));
+			if (seenChildRefs.has(childId)) issues.push(createStructureIssue({
+				code: "duplicate-child-reference",
+				message: `Group item "${item.id}" lists child "${childId}" more than once.`,
+				operationId,
+				itemId: item.id
+			}));
+			seenChildRefs.add(childId);
+			if (!itemsById.has(childId)) {
+				issues.push(createStructureIssue({
+					code: "missing-child-item",
+					message: `Group item "${item.id}" references missing child item "${childId}".`,
+					operationId,
+					itemId: item.id
+				}));
+				continue;
+			}
+			const existingParentId = parentByChildId.get(childId);
+			if (existingParentId && existingParentId !== item.id) issues.push(createStructureIssue({
+				code: "multiple-child-parents",
+				message: `Child item "${childId}" is listed under both "${existingParentId}" and "${item.id}".`,
+				operationId,
+				itemId: childId
+			}));
+			parentByChildId.set(childId, item.id);
+		}
+	}
+	for (const item of itemsById.values()) {
+		if (isRootItem(item)) continue;
+		if (!parentByChildId.has(item.id)) issues.push(createStructureIssue({
+			code: "orphan-survey-item",
+			message: `Item "${item.id}" is not reachable from any group parent.`,
+			operationId,
+			itemId: item.id
+		}));
+	}
+	for (const item of itemsById.values()) {
+		const siblingKeys = /* @__PURE__ */ new Map();
+		for (const childId of getGroupChildren(item)) {
+			const child = itemsById.get(childId);
+			if (!child) continue;
+			const conflictingChildId = siblingKeys.get(child.key);
+			if (conflictingChildId) issues.push(createStructureIssue({
+				code: "duplicate-sibling-key",
+				message: `Siblings "${conflictingChildId}" and "${childId}" both use key "${child.key}".`,
+				operationId,
+				itemId: childId
+			}));
+			siblingKeys.set(child.key, childId);
+		}
+	}
+	const rootItem = rootItems[0];
+	if (rootItem) {
+		const visiting = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (itemId, path) => {
+			if (visiting.has(itemId)) {
+				issues.push(createStructureIssue({
+					code: "survey-item-cycle",
+					message: `The patched survey contains a cycle through item "${itemId}" (${path.join(" -> ")} -> ${itemId}).`,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			if (visited.has(itemId)) return;
+			visiting.add(itemId);
+			const item = itemsById.get(itemId);
+			for (const childId of getGroupChildren(item)) visit(childId, [...path, itemId]);
+			visiting.delete(itemId);
+			visited.add(itemId);
+		};
+		visit(rootItem.id, []);
+	}
+	return issues;
+};
+const validateSurveyJsonPatchOperation = ({ operation, snapshot }) => {
+	const operationId = getOperationId(operation);
+	const issues = [];
+	const warnings = [];
+	issues.push(...validateTranslationPatchSafety({
+		operation,
+		survey: snapshot.survey
+	}));
+	for (const path of getPatchTouchedPaths(operation)) try {
+		if (touchesSurveySchemaPath(path)) issues.push(createIssue({
+			code: "cannot-edit-survey-schema",
+			message: "Assistant raw patches cannot modify the survey $schema field.",
+			operationIndex: 0,
+			operationId
+		}));
+	} catch (error) {
+		issues.push(createIssue({
+			code: "invalid-json-pointer",
+			message: error instanceof Error ? error.message : `Invalid JSON Pointer path "${path}" in raw survey patch.`,
+			operationIndex: 0,
+			operationId
+		}));
+	}
+	if (issues.length > 0) return {
+		valid: false,
+		issues,
+		warnings,
+		normalizedOperations: [operation]
+	};
+	let patchedSurvey;
+	try {
+		patchedSurvey = applyJsonPatch(snapshot.survey, operation.patches);
+	} catch (error) {
+		const patchError = error instanceof JsonPatchError ? error : void 0;
+		return {
+			valid: false,
+			issues: [createIssue({
+				code: patchError?.code ?? "json-patch-failed",
+				message: error instanceof Error ? error.message : "The raw survey JSON Patch could not be applied.",
+				operationIndex: patchError?.operationIndex ?? 0,
+				operationId
+			})],
+			warnings,
+			normalizedOperations: [operation]
+		};
+	}
+	const existingItemIds = new Set(snapshot.survey.surveyItems.map((item) => item.id));
+	const manifestByItemType = new Map(snapshot.capabilities.itemTypes.map((entry) => [entry.itemType, entry]));
+	for (const item of patchedSurvey.surveyItems) {
+		if (existingItemIds.has(item.id)) continue;
+		const capability = manifestByItemType.get(item.itemType);
+		if (capability?.create !== "deterministic") issues.push(createIssue({
+			code: "item-type-not-deterministically-creatable",
+			message: capability ? `Item type "${item.itemType}" requires an interactive editor flow and cannot be created through a raw patch.` : `Item type "${item.itemType}" is not available in the current assistant capability set.`,
+			operationIndex: 0,
+			operationId,
+			itemId: item.id
+		}));
+	}
+	for (const item of patchedSurvey.surveyItems) {
+		const capability = snapshot.trustedCapabilities?.byItemType.get(item.itemType);
+		for (const issue of capability?.validateItem?.(item) ?? []) {
+			const normalizedIssue = {
+				...issue,
+				operationIndex: issue.operationIndex ?? 0,
+				operationId: issue.operationId ?? operationId,
+				itemId: issue.itemId ?? item.id
+			};
+			(normalizedIssue.severity === "warning" ? warnings : issues).push(normalizedIssue);
+		}
+	}
+	issues.push(...validateTranslationBranchShapes({
+		operation,
+		survey: patchedSurvey
+	}), ...validateSurveyTreeStructure(patchedSurvey, operationId, new Set(snapshot.capabilities.itemTypes.map((entry) => entry.itemType))));
+	const documentResult = rawSurveyDocumentSchema.safeParse(patchedSurvey);
+	if (!documentResult.success) {
+		const firstIssue = documentResult.error.issues[0];
+		const path = firstIssue?.path.length ? ` at /${firstIssue.path.join("/")}` : "";
+		issues.push(createIssue({
+			code: "invalid-survey-document",
+			message: `The raw patch would produce an invalid survey document${path}: ${firstIssue?.message ?? "schema validation failed"}.`,
+			operationIndex: 0,
+			operationId
+		}));
+	}
+	if (getRawItemsFromSurvey(patchedSurvey).length !== getRawSurveyItems(snapshot).length) warnings.push(createIssue({
+		severity: "warning",
+		code: "raw-patch-changed-item-count",
+		message: "The raw survey patch changes the number of survey items. Confirm that added or removed ids are reflected in the parent group items array and translations.",
+		operationIndex: 0,
+		operationId
+	}));
+	return {
+		valid: issues.length === 0,
+		issues,
+		warnings,
+		normalizedOperations: [operation]
+	};
+};
+const buildParentByChildId = (rawItems) => {
+	const parentByChildId = /* @__PURE__ */ new Map();
+	for (const item of rawItems) for (const childId of getGroupChildren(item)) parentByChildId.set(childId, item.id);
+	return parentByChildId;
+};
+const collectDescendantIds = (itemId, rawItemsById, descendants = /* @__PURE__ */ new Set()) => {
+	const item = rawItemsById.get(itemId);
+	for (const childId of getGroupChildren(item)) {
+		if (descendants.has(childId)) continue;
+		descendants.add(childId);
+		collectDescendantIds(childId, rawItemsById, descendants);
+	}
+	return descendants;
+};
+const normalizeSummary = (summary) => {
+	const trimmed = summary.trim();
+	return trimmed.length > 0 ? trimmed : "Prepared survey change";
+};
+const createIssue = ({ severity = "error", ...input }) => ({
+	severity,
+	...input
+});
+const getOperationId = (operation) => operation.id;
+const isSurveyLevelOperation = (operation) => [
+	"update-survey-metadata",
+	"update-survey-pagination",
+	"update-survey-translation",
+	"remove-survey-locale",
+	"set-image-asset",
+	"update-image-asset-metadata",
+	"remove-image-asset"
+].includes(operation.kind);
+const getOperationTarget = (operation) => {
+	switch (operation.kind) {
+		case "create-item": return operation.target.parentItemId;
+		case "upsert-form-field-group":
+		case "remove-form-field-group":
+		case "reorder-form-field-groups":
+		case "upsert-form-field":
+		case "remove-form-field":
+		case "move-form-field": return operation.target.itemId;
+		case "reorder-items": return operation.parentItemId;
+		case "update-survey-metadata":
+		case "update-survey-pagination":
+		case "update-survey-translation":
+		case "remove-survey-locale":
+		case "set-image-asset":
+		case "update-image-asset-metadata":
+		case "remove-image-asset": return "";
+		default: return operation.itemId;
+	}
+};
+const createChoiceOptionLabelContentKey = (optionId) => `options.${optionId}.label`;
+const KNOWN_CHOICE_OPTION_INPUT_KEYS = new Set([
+	"id",
+	"optionId",
+	"label",
+	"text",
+	"title",
+	"name",
+	"value",
+	"key",
+	"hasDisplayCondition",
+	"embeddedFormItemId",
+	"embeddedForm"
+]);
+const getUnrecognizedChoiceOptionKeys = (option) => Object.keys(option).filter((key) => !KNOWN_CHOICE_OPTION_INPUT_KEYS.has(key));
+const normalizeChoiceOptionId = (value) => value.trim().replace(/[.\s]+/g, "_").replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+const normalizeChoiceOptionKey = (value) => value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+const getNextChoiceOptionKey = (usedKeys) => {
+	const usedNumbers = new Set(Array.from(usedKeys).map((key) => normalizeChoiceOptionKey(key).match(/^opt_(\d+)$/)?.[1]).filter((value) => value !== void 0).map((value) => Number.parseInt(value, 10)).filter((value) => Number.isFinite(value)));
+	let nextNumber = 1;
+	while (usedNumbers.has(nextNumber)) nextNumber += 1;
+	return `opt_${nextNumber}`;
+};
+const ensureUniqueId = (candidate, usedIds) => {
+	const baseId = (candidate ? normalizeChoiceOptionId(candidate) : "") || generateId();
+	if (!usedIds.has(baseId)) {
+		usedIds.add(baseId);
+		return baseId;
+	}
+	let suffix = 2;
+	while (usedIds.has(`${baseId}_${suffix}`)) suffix += 1;
+	const uniqueId = `${baseId}_${suffix}`;
+	usedIds.add(uniqueId);
+	return uniqueId;
+};
+const ensureUniqueChoiceOptionKey = (candidate, usedKeys) => {
+	const normalizedUsedKeys = new Set(Array.from(usedKeys).map((key) => normalizeChoiceOptionKey(key)).filter((key) => key.length > 0));
+	const baseKey = (candidate ? normalizeChoiceOptionKey(candidate) : "") || getNextChoiceOptionKey(usedKeys);
+	if (!usedKeys.has(baseKey) && !normalizedUsedKeys.has(baseKey)) {
+		usedKeys.add(baseKey);
+		return baseKey;
+	}
+	let suffix = 2;
+	while (usedKeys.has(`${baseKey}_${suffix}`) || normalizedUsedKeys.has(`${baseKey}_${suffix}`)) suffix += 1;
+	const uniqueKey = `${baseKey}_${suffix}`;
+	usedKeys.add(uniqueKey);
+	return uniqueKey;
+};
+const getChoiceOptionsFromRawItem = (rawItem) => {
+	const rawOptions = (isRecord$2(rawItem.config) ? rawItem.config : void 0)?.options;
+	if (!Array.isArray(rawOptions)) return [];
+	return rawOptions.filter(isRecord$2).map((option) => {
+		const optionId = getTrimmedString(option.id);
+		if (!optionId) return;
+		const optionKey = getTrimmedString(option.key);
+		return {
+			...option,
+			id: optionId,
+			...optionKey ? { key: optionKey } : {}
+		};
+	}).filter((option) => Boolean(option));
+};
+const withChoiceOptionsOnRawItem = (rawItem, options) => {
+	const config = isRecord$2(rawItem.config) ? rawItem.config : {};
+	return {
+		...rawItem,
+		config: {
+			id: rawItem.id,
+			maxSelection: 1,
+			shuffleOptions: false,
+			...config,
+			options
+		}
+	};
+};
+const normalizeFormFieldGroupRecord = (value) => {
+	if (!isRecord$2(value)) return void 0;
+	const id = getTrimmedString(value.id);
+	if (!id) return void 0;
+	return {
+		...value,
+		id,
+		layout: isRecord$2(value.layout) ? value.layout : {
+			base: 1,
+			xs: 1,
+			sm: 1,
+			md: 1,
+			xl: 1
+		},
+		fields: Array.isArray(value.fields) ? value.fields.filter(isRecord$2) : []
+	};
+};
+const getFormFieldGroupsFromConfig = (config) => {
+	if (!isRecord$2(config) || !Array.isArray(config.fieldGroups)) return [];
+	return config.fieldGroups.map(normalizeFormFieldGroupRecord).filter((group) => Boolean(group));
+};
+const getFormFieldGroupsForTarget = (rawItem, optionId) => {
+	if (!optionId) return rawItem.itemType === FORM_ITEM_TYPE ? getFormFieldGroupsFromConfig(rawItem.config) : void 0;
+	if (rawItem.itemType !== CHOICE_ITEM_TYPE) return void 0;
+	const option = getChoiceOptionsFromRawItem(rawItem).find((candidate) => candidate.id === optionId);
+	return option ? getFormFieldGroupsFromConfig(option.embeddedForm) : void 0;
+};
+const withFormFieldGroupsForTarget = (rawItem, fieldGroups, optionId) => {
+	if (!optionId) {
+		if (rawItem.itemType !== FORM_ITEM_TYPE) return void 0;
+		const config = isRecord$2(rawItem.config) ? rawItem.config : {};
+		return {
+			...rawItem,
+			config: {
+				id: rawItem.id,
+				...config,
+				fieldGroups
+			}
+		};
+	}
+	if (rawItem.itemType !== CHOICE_ITEM_TYPE) return void 0;
+	const options = getChoiceOptionsFromRawItem(rawItem);
+	const optionIndex = options.findIndex((candidate) => candidate.id === optionId);
+	if (optionIndex < 0) return void 0;
+	const option = options[optionIndex];
+	const embeddedForm = isRecord$2(option.embeddedForm) ? option.embeddedForm : {};
+	options[optionIndex] = {
+		...option,
+		embeddedForm: {
+			id: optionId,
+			...embeddedForm,
+			fieldGroups
+		}
+	};
+	return withChoiceOptionsOnRawItem(rawItem, options);
+};
+const normalizeFormTranslationKey = (contentKey, optionId) => optionId && !contentKey.startsWith(`embeddedForms.${optionId}.`) ? `embeddedForms.${optionId}.${contentKey}` : contentKey;
+const normalizeFormOperationTranslations = (operation, optionId) => ({
+	...operation,
+	translations: operation.translations?.map((translation) => ({
+		...translation,
+		contentKey: normalizeFormTranslationKey(translation.contentKey.trim(), optionId)
+	}))
+});
+const getItemTranslationText = ({ contentKey, itemId, locale, snapshot }) => {
+	const content = new SurveyTranslations(snapshot.survey.translations).getItemTranslations(itemId)?.getContent(locale, contentKey);
+	return content ? getContentPlainText(content).trim() : void 0;
+};
+const resolveChoiceOption = ({ itemId, locale, optionRef, options, snapshot }) => {
+	const normalizedRef = optionRef.trim();
+	const normalizedSearchText = normalizedRef.toLowerCase();
+	for (const option of options) if (option.id === normalizedRef || option.key === normalizedRef) return option;
+	const labelMatches = options.filter((option) => {
+		return getItemTranslationText({
+			contentKey: createChoiceOptionLabelContentKey(option.id),
+			itemId,
+			locale,
+			snapshot
+		})?.toLowerCase() === normalizedSearchText;
+	});
+	return labelMatches.length === 1 ? labelMatches[0] : void 0;
+};
+const createChoiceOptionsConflictIssue = ({ code, itemId, message, operationId, operationIndex }) => createIssue({
+	code,
+	itemId,
+	message,
+	operationId,
+	operationIndex
+});
+const upsertCreateItemTranslation = (translations, nextTranslation) => {
+	const existingIndex = translations.findIndex((translation) => translation.locale === nextTranslation.locale && translation.contentKey === nextTranslation.contentKey);
+	if (existingIndex >= 0) {
+		translations[existingIndex] = nextTranslation;
+		return;
+	}
+	translations.push(nextTranslation);
+};
+const normalizeChoiceOptionInput = ({ defaultLocale, option, usedIds }) => {
+	if (typeof option === "string") {
+		const label = option.trim();
+		if (!label) return;
+		const optionId = ensureUniqueId(label, usedIds);
+		const optionKey = normalizeChoiceOptionKey(label);
+		return {
+			labelTranslation: {
+				locale: defaultLocale,
+				contentKey: createChoiceOptionLabelContentKey(optionId),
+				plainText: label
+			},
+			option: {
+				id: optionId,
+				...optionKey ? { key: optionKey } : {}
+			}
+		};
+	}
+	if (!isRecord$2(option)) return;
+	const label = getFirstStringProperty(option, [
+		"label",
+		"text",
+		"title",
+		"name"
+	]);
+	const optionId = ensureUniqueId(getFirstStringProperty(option, ["id", "optionId"]) ?? getFirstStringProperty(option, ["value", "key"]) ?? label, usedIds);
+	const keyCandidate = getFirstStringProperty(option, ["key", "value"]) ?? label;
+	const optionKey = keyCandidate ? normalizeChoiceOptionKey(keyCandidate) : void 0;
+	const embeddedFormItemId = getTrimmedString(option.embeddedFormItemId);
+	const unrecognizedKeys = getUnrecognizedChoiceOptionKeys(option);
+	return {
+		labelTranslation: label ? {
+			locale: defaultLocale,
+			contentKey: createChoiceOptionLabelContentKey(optionId),
+			plainText: label
+		} : void 0,
+		option: {
+			id: optionId,
+			...optionKey ? { key: optionKey } : {},
+			...option.hasDisplayCondition === true ? { hasDisplayCondition: true } : {},
+			...embeddedFormItemId ? { embeddedFormItemId } : {},
+			...isRecord$2(option.embeddedForm) ? { embeddedForm: option.embeddedForm } : {}
+		},
+		...unrecognizedKeys.length > 0 ? { unrecognizedKeys } : {}
+	};
+};
+const normalizeContentKeyForItemType = (contentKey, registryEntry) => {
+	const normalizedContentKey = contentKey.trim();
+	const contentSurfaces = registryEntry?.contentSurfaces;
+	if (!contentSurfaces) return normalizedContentKey;
+	const normalizedLowerCase = normalizedContentKey.toLowerCase();
+	for (const surface of contentSurfaces) if (surface.aliases?.some((alias) => alias.toLowerCase() === normalizedLowerCase)) return surface.key;
+	return contentSurfaces.find((surface) => surface.key.toLowerCase() === normalizedLowerCase)?.key ?? normalizedContentKey;
+};
+const normalizeCreateItemTranslationContentKeys = (operation, registryEntry) => ({
+	...operation,
+	translations: operation.translations?.map((translation) => ({
+		...translation,
+		contentKey: normalizeContentKeyForItemType(translation.contentKey, registryEntry)
+	}))
+});
+const normalizeChoiceItemCreateOperation = (operation, defaultLocale) => {
+	if (operation.item.itemType !== CHOICE_ITEM_TYPE) return {
+		operation,
+		optionWarnings: []
+	};
+	const config = isRecord$2(operation.item.config) ? operation.item.config : {};
+	const rawOptions = Array.isArray(config.options) ? config.options : [];
+	const usedIds = /* @__PURE__ */ new Set();
+	const normalizedOptions = [];
+	const translations = [...operation.translations ?? []];
+	const optionWarnings = [];
+	for (const option of rawOptions) {
+		const normalized = normalizeChoiceOptionInput({
+			defaultLocale,
+			option,
+			usedIds
+		});
+		if (!normalized) continue;
+		normalizedOptions.push(normalized.option);
+		if (normalized.labelTranslation) upsertCreateItemTranslation(translations, normalized.labelTranslation);
+		if (normalized.unrecognizedKeys?.length) optionWarnings.push({
+			optionId: normalized.option.id,
+			unrecognizedKeys: normalized.unrecognizedKeys
+		});
+	}
+	for (const translation of translations) {
+		const optionId = translation.contentKey.match(CHOICE_OPTION_LABEL_CONTENT_KEY_PATTERN)?.[1];
+		const labelText = getTranslationPlainText(translation);
+		if (!optionId || usedIds.has(optionId) || !labelText) continue;
+		usedIds.add(optionId);
+		normalizedOptions.push({
+			id: optionId,
+			key: normalizeChoiceOptionKey(labelText)
+		});
+	}
+	return {
+		operation: {
+			...operation,
+			item: {
+				...operation.item,
+				config: {
+					...config,
+					options: normalizedOptions
+				}
+			},
+			translations
+		},
+		optionWarnings
+	};
+};
+const hasRequiredCreateContent = (operation, registryEntry) => {
+	const requiredContentSurfaces = registryEntry?.contentSurfaces.filter((surface) => surface.requiredOnCreate) ?? [];
+	if (requiredContentSurfaces.length === 0) return true;
+	return requiredContentSurfaces.every((surface) => (operation.translations ?? []).some((translation) => translation.contentKey === surface.key && !isTranslationContentEmpty(translation)));
+};
+const getChoiceCreateOptionIds = (operation) => {
+	if (operation.item.itemType !== CHOICE_ITEM_TYPE || !isRecord$2(operation.item.config)) return [];
+	const options = operation.item.config.options;
+	if (!Array.isArray(options)) return [];
+	return options.map((option) => isRecord$2(option) ? getTrimmedString(option.id) : void 0).filter((optionId) => Boolean(optionId));
+};
+const getChoiceCreateContentIssue = ({ operation, operationId, operationIndex, itemId }) => {
+	if (operation.item.itemType !== CHOICE_ITEM_TYPE) return;
+	const optionIds = getChoiceCreateOptionIds(operation);
+	if (optionIds.length === 0) return createIssue({
+		code: "missing-choice-options",
+		message: "New choice items need response options. Add item.config.options entries with labels, for example { \"label\": \"Fuji\" }.",
+		operationIndex,
+		operationId,
+		itemId
+	});
+	const missingLabelOptionIds = optionIds.filter((optionId) => !(operation.translations ?? []).some((translation) => translation.contentKey === createChoiceOptionLabelContentKey(optionId) && getTranslationPlainText(translation).length > 0));
+	if (missingLabelOptionIds.length === 0) return;
+	return createIssue({
+		code: "missing-choice-option-labels",
+		message: `New choice item options need visible labels. Missing labels for option id(s): ${missingLabelOptionIds.join(", ")}.`,
+		operationIndex,
+		operationId,
+		itemId
+	});
+};
+const getRawFieldIds = (fieldGroups) => {
+	if (!Array.isArray(fieldGroups)) return [];
+	const fieldIds = [];
+	for (const group of fieldGroups) {
+		if (!isRecord$2(group) || !Array.isArray(group.fields)) continue;
+		for (const field of group.fields) {
+			const fieldId = isRecord$2(field) ? getTrimmedString(field.id) : void 0;
+			if (fieldId) fieldIds.push(fieldId);
+		}
+	}
+	return fieldIds;
+};
+const getRawFields = (fieldGroups) => {
+	if (!Array.isArray(fieldGroups)) return [];
+	const fields = [];
+	for (const group of fieldGroups) {
+		if (!isRecord$2(group) || !Array.isArray(group.fields)) continue;
+		for (const field of group.fields) if (isRecord$2(field)) fields.push(field);
+	}
+	return fields;
+};
+const getMissingSelectOptionLabelContentKeys = ({ fieldGroups, prefix, translations }) => {
+	const missingContentKeys = [];
+	for (const field of getRawFields(fieldGroups)) {
+		const fieldId = getTrimmedString(field.id);
+		const controller = isRecord$2(field.controller) ? field.controller : void 0;
+		if (!fieldId || field.type !== "select" || controller?.type !== "select") continue;
+		const options = Array.isArray(controller.options) ? controller.options : [];
+		for (const option of options) {
+			const optionId = isRecord$2(option) ? getTrimmedString(option.id) : void 0;
+			if (!optionId) continue;
+			const contentKey = `${prefix}.${fieldId}.options.${optionId}.label`;
+			if (!hasNonEmptyCreateTranslation(translations, contentKey)) missingContentKeys.push(contentKey);
+		}
+	}
+	return missingContentKeys;
+};
+/**
+* A `fieldGroups` array only counts as "usable" if at least one group actually
+* carries a non-empty `fields` array. An empty/missing `fieldGroups` (or one
+* full of empty groups) renders nothing, even though it looks superficially
+* valid.
+*/
+const hasUsableFieldGroups = (fieldGroups) => {
+	if (!Array.isArray(fieldGroups) || fieldGroups.length === 0) return false;
+	return fieldGroups.some((group) => isRecord$2(group) && Array.isArray(group.fields) && group.fields.length > 0);
+};
+/**
+* Shallow recursive search (bounded depth) for a stray `fields` array anywhere
+* inside a malformed form/embeddedForm record, so the validation message can
+* point at exactly where the model misplaced it (e.g. wrapped it in a spurious
+* `itemType`/`config` envelope instead of putting `fieldGroups` at the top
+* level of the record).
+*/
+const findNestedFieldsArrayPath = (value, path, depth) => {
+	if (depth > 3 || !isRecord$2(value)) return;
+	if (Array.isArray(value.fields) && value.fields.length > 0) return path ? `${path}.fields` : "fields";
+	for (const [key, nested] of Object.entries(value)) {
+		if (key === "fields" || !isRecord$2(nested)) continue;
+		const found = findNestedFieldsArrayPath(nested, path ? `${path}.${key}` : key, depth + 1);
+		if (found) return found;
+	}
+};
+/**
+* Detects any shape where a form's fields are not usable because they are not
+* nested inside a `fieldGroups` array directly on this record — including the
+* near-miss of a top-level `fields` array, AND shapes that wrap everything in
+* a spurious envelope like `{ "itemType": "formItem", "config": { "fields": [...] } }`
+* (a real model failure mode: it invents an `itemType`/`config` wrapper around
+* the embedded form instead of using the flat `{ "id", "fieldGroups" }` shape).
+* Since `fieldGroups` is not schema-validated (config is `z.unknown()`), any of
+* these mistakes is otherwise silently dropped and results in no visible fields.
+*/
+const getMissingFieldGroupsWrapperHint = (record) => {
+	if (hasUsableFieldGroups(record.fieldGroups)) return;
+	const nestedFieldsPath = findNestedFieldsArrayPath(record, "", 0);
+	if (nestedFieldsPath) return `found a "${nestedFieldsPath}" array, but fields must be nested inside a top-level "fieldGroups" array on this exact object, for example { "id": "...", "fieldGroups": [{ "id": "main", "fields": [...] }] } — do NOT wrap this in an "itemType"/"config" envelope; the shape is flat`;
+	return "no \"fieldGroups\" array with any fields was found; the shape must be { \"id\": \"...\", \"fieldGroups\": [{ \"id\": \"main\", \"fields\": [...] }] }";
+};
+const hasNonEmptyCreateTranslation = (translations, contentKey) => (translations ?? []).some((translation) => translation.contentKey === contentKey && getTranslationPlainText(translation).length > 0);
+const getFormCreateFieldLabelIssue = ({ operation, operationId, operationIndex, itemId }) => {
+	if (operation.item.itemType !== FORM_ITEM_TYPE || !isRecord$2(operation.item.config)) return;
+	const wrapperHint = getMissingFieldGroupsWrapperHint(operation.item.config);
+	if (wrapperHint) return createIssue({
+		code: "missing-field-groups-wrapper",
+		message: `New form item has no usable fields: ${wrapperHint}.`,
+		operationIndex,
+		operationId,
+		itemId
+	});
+	const missingLabelFieldIds = getRawFieldIds(operation.item.config.fieldGroups).filter((fieldId) => !hasNonEmptyCreateTranslation(operation.translations, `fields.${fieldId}.label`));
+	const missingSelectOptionLabelContentKeys = getMissingSelectOptionLabelContentKeys({
+		fieldGroups: operation.item.config.fieldGroups,
+		prefix: "fields",
+		translations: operation.translations
+	});
+	if (missingSelectOptionLabelContentKeys.length > 0) return createIssue({
+		code: "missing-form-select-option-labels",
+		message: `New form item select options need visible labels. Add translations for: ` + missingSelectOptionLabelContentKeys.join(", ") + ".",
+		operationIndex,
+		operationId,
+		itemId
+	});
+	if (missingLabelFieldIds.length === 0) return;
+	return createIssue({
+		code: "missing-form-field-labels",
+		message: `New form item fields need visible labels. Add a translation with contentKey "fields.<fieldId>.label" for field id(s): ${missingLabelFieldIds.join(", ")}.`,
+		operationIndex,
+		operationId,
+		itemId
+	});
+};
+const getChoiceEmbeddedFormFieldLabelIssue = ({ operation, operationId, operationIndex, itemId }) => {
+	if (operation.item.itemType !== CHOICE_ITEM_TYPE || !isRecord$2(operation.item.config)) return;
+	const options = operation.item.config.options;
+	if (!Array.isArray(options)) return;
+	const missingLabelContentKeys = [];
+	for (const option of options) {
+		if (!isRecord$2(option) || !isRecord$2(option.embeddedForm)) continue;
+		const optionId = getTrimmedString(option.id);
+		if (!optionId) continue;
+		const wrapperHint = getMissingFieldGroupsWrapperHint(option.embeddedForm);
+		if (wrapperHint) return createIssue({
+			code: "missing-field-groups-wrapper",
+			message: `Embedded form on option "${optionId}" has no usable fields: ${wrapperHint}.`,
+			operationIndex,
+			operationId,
+			itemId
+		});
+		for (const fieldId of getRawFieldIds(option.embeddedForm.fieldGroups)) {
+			const contentKey = `embeddedForms.${optionId}.fields.${fieldId}.label`;
+			if (!hasNonEmptyCreateTranslation(operation.translations, contentKey)) missingLabelContentKeys.push(contentKey);
+		}
+		missingLabelContentKeys.push(...getMissingSelectOptionLabelContentKeys({
+			fieldGroups: option.embeddedForm.fieldGroups,
+			prefix: `embeddedForms.${optionId}.fields`,
+			translations: operation.translations
+		}));
+	}
+	if (missingLabelContentKeys.length === 0) return;
+	return createIssue({
+		code: "missing-embedded-form-field-labels",
+		message: `New embedded form fields and select options need visible labels, otherwise respondents only see raw keys. Add translations for: ${missingLabelContentKeys.join(", ")}.`,
+		operationIndex,
+		operationId,
+		itemId
+	});
+};
+const resolveRawItemByIdentifier = ({ identifier, indexById, outlineById, rawItemsById }) => {
+	const direct = rawItemsById.get(identifier);
+	if (direct) return {
+		itemId: identifier,
+		rawItem: direct
+	};
+	const resolved = resolveItemSummary(identifier, indexById, outlineById);
+	if (!resolved) return;
+	const rawItem = rawItemsById.get(resolved.itemId);
+	return rawItem ? {
+		itemId: resolved.itemId,
+		rawItem
+	} : void 0;
+};
+const resolveCreateParentByIdentifier = ({ identifier, indexById, outlineById, rawItemsById }) => {
+	if (identifier.trim().length > 0) return resolveRawItemByIdentifier({
+		identifier,
+		indexById,
+		outlineById,
+		rawItemsById
+	});
+	const rootItems = Array.from(rawItemsById.entries()).filter(([, rawItem]) => rawItem.itemType === ReservedSurveyItemTypes.Group && isRootItem(rawItem));
+	if (rootItems.length !== 1) return;
+	const [itemId, rawItem] = rootItems[0];
+	return {
+		itemId,
+		rawItem
+	};
+};
+const normalizeOperation = (operation, resolvedItemId) => {
+	switch (operation.kind) {
+		case "create-item": {
+			const nestedTranslations = getCreateItemNestedTranslations(operation.item);
+			const topLevelTranslations = operation.translations ?? [];
+			const translations = topLevelTranslations.length > 0 ? topLevelTranslations : nestedTranslations;
+			const item = { ...operation.item };
+			delete item.translations;
+			return {
+				...operation,
+				target: {
+					...operation.target,
+					parentItemId: operation.target.parentItemId.trim()
+				},
+				item: {
+					...item,
+					id: operation.item.id?.trim(),
+					key: operation.item.key.trim(),
+					itemType: operation.item.itemType.trim()
+				},
+				translations: translations.map((translation) => ({
+					...translation,
+					locale: translation.locale.trim(),
+					contentKey: translation.contentKey.trim()
+				}))
+			};
+		}
+		case "update-item-key": return {
+			...operation,
+			itemId: resolvedItemId,
+			key: operation.key.trim()
+		};
+		case "update-item-label": return {
+			...operation,
+			itemId: resolvedItemId,
+			itemLabel: operation.itemLabel.trim()
+		};
+		case "update-item-color": return {
+			...operation,
+			itemId: resolvedItemId
+		};
+		case "update-item-translation": return {
+			...operation,
+			itemId: resolvedItemId,
+			locale: operation.locale.trim(),
+			contentKey: operation.contentKey.trim()
+		};
+		case "update-placed-image": return {
+			...operation,
+			itemId: resolvedItemId,
+			locale: operation.locale.trim(),
+			contentKey: operation.contentKey.trim(),
+			expectedAssetId: operation.expectedAssetId?.trim(),
+			changes: {
+				...operation.changes,
+				source: operation.changes.source?.type === "asset" ? {
+					type: "asset",
+					assetId: operation.changes.source.assetId.trim()
+				} : operation.changes.source?.type === "external" ? {
+					type: "external",
+					url: operation.changes.source.url.trim()
+				} : void 0
+			}
+		};
+		case "patch-item-config": return {
+			...operation,
+			itemId: resolvedItemId
+		};
+		case "upsert-form-field-group":
+		case "remove-form-field-group":
+		case "reorder-form-field-groups":
+		case "upsert-form-field":
+		case "remove-form-field":
+		case "move-form-field": return {
+			...operation,
+			target: {
+				...operation.target,
+				itemId: resolvedItemId,
+				optionId: operation.target.optionId?.trim()
+			}
+		};
+		case "set-embedded-form":
+		case "remove-embedded-form": return {
+			...operation,
+			itemId: resolvedItemId,
+			optionId: operation.optionId.trim()
+		};
+		case "add-choice-option": return {
+			...operation,
+			itemId: resolvedItemId,
+			locale: operation.locale?.trim(),
+			option: {
+				...operation.option,
+				id: operation.option.id?.trim(),
+				key: operation.option.key?.trim(),
+				label: operation.option.label.trim()
+			}
+		};
+		case "update-choice-option-label": return {
+			...operation,
+			itemId: resolvedItemId,
+			optionId: operation.optionId.trim(),
+			locale: operation.locale?.trim(),
+			label: operation.label.trim()
+		};
+		case "remove-choice-option": return {
+			...operation,
+			itemId: resolvedItemId,
+			optionId: operation.optionId.trim()
+		};
+		case "reorder-choice-options": return {
+			...operation,
+			itemId: resolvedItemId,
+			optionIds: operation.optionIds.map((optionId) => optionId.trim())
+		};
+		case "remove-item": return {
+			...operation,
+			itemId: resolvedItemId,
+			includeChildren: operation.includeChildren ?? false
+		};
+		case "move-item": return {
+			...operation,
+			itemId: resolvedItemId,
+			target: {
+				...operation.target,
+				parentItemId: operation.target.parentItemId.trim()
+			}
+		};
+		case "reorder-items": return {
+			...operation,
+			parentItemId: resolvedItemId,
+			itemIds: operation.itemIds.map((itemId) => itemId.trim())
+		};
+		case "update-survey-metadata":
+		case "update-survey-pagination":
+		case "set-image-asset":
+		case "update-image-asset-metadata":
+		case "remove-image-asset": return operation;
+		case "update-survey-translation": return {
+			...operation,
+			locale: operation.locale.trim(),
+			contentKey: operation.contentKey.trim()
+		};
+		case "remove-survey-locale": return {
+			...operation,
+			locale: operation.locale.trim()
+		};
+		case "survey-json-patch": return operation;
+	}
+};
+const createEmptyValidationResult = (issue, operations) => ({
+	valid: false,
+	issues: [issue],
+	warnings: [],
+	normalizedOperations: operations
+});
+const getSiblingKeyConflict = ({ createdKeysByParentId, deletedItemIds, itemId, key, parentByChildId, plannedKeys, rawItemsById }) => {
+	const parentId = parentByChildId.get(itemId);
+	if (!parentId) return;
+	const createdKeys = createdKeysByParentId.get(parentId);
+	for (const [createdItemId, createdKey] of createdKeys ?? []) if (createdItemId !== itemId && createdKey === key) return createdItemId;
+	for (const siblingId of getGroupChildren(rawItemsById.get(parentId))) {
+		if (siblingId === itemId || deletedItemIds.has(siblingId)) continue;
+		if ((plannedKeys.get(siblingId) ?? rawItemsById.get(siblingId)?.key) === key) return siblingId;
+	}
+};
+const getKeyConflictInParent = ({ createdKeysByParentId, deletedItemIds, key, parentId, rawItemsById }) => {
+	const createdKeys = createdKeysByParentId.get(parentId);
+	for (const [createdItemId, createdKey] of createdKeys ?? []) if (createdKey === key) return createdItemId;
+	for (const siblingId of getGroupChildren(rawItemsById.get(parentId))) {
+		if (deletedItemIds.has(siblingId)) continue;
+		if (rawItemsById.get(siblingId)?.key === key) return siblingId;
+	}
+};
+const getPlannedCreateCountForParent = (parentId, createdKeysByParentId) => createdKeysByParentId.get(parentId)?.size ?? 0;
+const getDeletedAncestor = (itemId, parentByChildId, deletedItemIds) => {
+	let currentParentId = parentByChildId.get(itemId);
+	while (currentParentId) {
+		if (deletedItemIds.has(currentParentId)) return currentParentId;
+		currentParentId = parentByChildId.get(currentParentId);
+	}
+};
+const buildSurveyDocumentVersion = (snapshot) => ({ ...snapshot.version });
+const resolveEngineContext = (snapshot) => "document" in snapshot ? snapshot : createSurveyAssistantEngineContext(snapshot);
+const validateSurveyOperations = ({ operations, snapshot: snapshotInput }) => {
+	if (!snapshotInput) return createEmptyValidationResult(createIssue({
+		code: "missing-snapshot",
+		message: "No live editor snapshot was provided for this assistant turn."
+	}), operations);
+	const snapshot = resolveEngineContext(snapshotInput);
+	if (operations.length === 0) return createEmptyValidationResult(createIssue({
+		code: "empty-operations",
+		message: "No survey change operations were provided."
+	}), operations);
+	if (operations.length > 200) return createEmptyValidationResult(createIssue({
+		code: "too-many-operations",
+		message: `At most 200 operations can be proposed at once.`
+	}), operations);
+	const surveyJsonPatchOperations = operations.filter(isSurveyJsonPatchOperation);
+	if (surveyJsonPatchOperations.length > 0) {
+		if (operations.length > 1 || surveyJsonPatchOperations.length > 1) return createEmptyValidationResult(createIssue({
+			code: "raw-patch-must-be-single-operation",
+			message: "A survey-json-patch operation must be the only operation in a proposal. Put all raw edits in that operation's patches array.",
+			operationIndex: operations.findIndex(isSurveyJsonPatchOperation),
+			operationId: surveyJsonPatchOperations[0]?.id
+		}), operations);
+		return validateSurveyJsonPatchOperation({
+			operation: surveyJsonPatchOperations[0],
+			snapshot
+		});
+	}
+	const rawItems = getRawSurveyItems(snapshot);
+	const rawItemsById = mapRawItemsById(snapshot);
+	const parentByChildId = buildParentByChildId(rawItems);
+	const outlineById = mapOutlineById(snapshot);
+	const indexById = mapKeyIndexById(snapshot);
+	const itemTypeManifestByType = new Map(snapshot.capabilities.itemTypes.map((entry) => [entry.itemType, entry]));
+	const deterministicCreateItemTypes = new Set(snapshot.capabilities.itemTypes.filter((entry) => entry.create === "deterministic").map((entry) => entry.itemType));
+	const issues = [];
+	const warnings = [];
+	const normalizedOperations = [];
+	const createdKeysByParentId = /* @__PURE__ */ new Map();
+	const plannedKeys = /* @__PURE__ */ new Map();
+	const deletedItemIds = /* @__PURE__ */ new Set();
+	const introducedLocaleWarnings = /* @__PURE__ */ new Set();
+	const addIntroducedLocaleWarning = ({ itemId, locale, operationId, operationIndex }) => {
+		if (snapshot.inspection.locales.includes(locale)) return;
+		const warningKey = `${operationIndex}:${itemId ?? ""}:${locale}`;
+		if (introducedLocaleWarnings.has(warningKey)) return;
+		introducedLocaleWarnings.add(warningKey);
+		warnings.push(createIssue({
+			severity: "warning",
+			code: "introduced-locale",
+			message: `Locale "${locale}" is not currently present and will be introduced by this translation change.`,
+			operationIndex,
+			operationId,
+			itemId
+		}));
+	};
+	operations.forEach((operation, operationIndex) => {
+		const operationId = getOperationId(operation);
+		if (operation.kind === "create-item") {
+			const baseNormalized = normalizeOperation(operation, "");
+			const registryEntry = itemTypeManifestByType.get(baseNormalized.item.itemType);
+			const { operation: normalized, optionWarnings } = normalizeChoiceItemCreateOperation(normalizeCreateItemTranslationContentKeys(baseNormalized, registryEntry), snapshot.ui.selectedLocale);
+			for (const optionWarning of optionWarnings) issues.push(createIssue({
+				code: "unrecognized-choice-option-keys",
+				message: `Option "${optionWarning.optionId}" has unrecognized field(s): ${optionWarning.unrecognizedKeys.join(", ")}. Recognized option fields are id, key, label, hasDisplayCondition, embeddedFormItemId, and embeddedForm (singular). Put respondent labels in translations at options.<optionId>.label; do not use provider-specific option metadata.`,
+				operationIndex,
+				operationId
+			}));
+			const parent = resolveCreateParentByIdentifier({
+				identifier: normalized.target.parentItemId,
+				indexById,
+				outlineById,
+				rawItemsById
+			});
+			if (!parent) {
+				issues.push(createIssue({
+					code: "target-parent-not-found",
+					message: normalized.target.parentItemId.length > 0 ? `No parent group matching "${normalized.target.parentItemId}" was found.` : "No root group parent could be inferred for this create-item operation.",
+					operationIndex,
+					operationId
+				}));
+				return;
+			}
+			if (parent.rawItem.itemType !== ReservedSurveyItemTypes.Group) {
+				issues.push(createIssue({
+					code: "target-parent-not-group",
+					message: `The target parent "${parent.itemId}" is not a group item.`,
+					operationIndex,
+					operationId,
+					itemId: parent.itemId
+				}));
+				return;
+			}
+			const deletedParentAncestorId = getDeletedAncestor(parent.itemId, parentByChildId, deletedItemIds);
+			if (deletedItemIds.has(parent.itemId) || deletedParentAncestorId) {
+				issues.push(createIssue({
+					code: "target-parent-already-removed",
+					message: "The target parent is removed earlier in this proposal.",
+					operationIndex,
+					operationId,
+					itemId: parent.itemId
+				}));
+				return;
+			}
+			const itemId = normalized.item.id && normalized.item.id.length > 0 ? normalized.item.id : generateId();
+			if (rawItemsById.has(itemId)) {
+				issues.push(createIssue({
+					code: "duplicate-item-id",
+					message: `The new item id "${itemId}" already exists in the survey or this proposal.`,
+					operationIndex,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			if (!ITEM_KEY_PATTERN.test(normalized.item.key)) {
+				issues.push(createIssue({
+					code: "invalid-item-key",
+					message: "Item keys must contain only letters, numbers, underscores, or hyphens.",
+					operationIndex,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			if (normalized.item.itemType === "root" || isRecord$2(normalized.item.config) && normalized.item.config.isRoot === true) {
+				issues.push(createIssue({
+					code: "cannot-create-root",
+					message: "The assistant cannot create a second survey root item.",
+					operationIndex,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			if (normalized.item.itemType === ReservedSurveyItemTypes.Group && getGroupChildren(normalized.item).length > 0) {
+				issues.push(createIssue({
+					code: "create-group-with-children",
+					message: "Create group items without embedded child ids; create children as separate operations.",
+					operationIndex,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			const conflictId = getKeyConflictInParent({
+				createdKeysByParentId,
+				deletedItemIds,
+				key: normalized.item.key,
+				parentId: parent.itemId,
+				rawItemsById
+			});
+			if (conflictId) {
+				issues.push(createIssue({
+					code: "duplicate-sibling-key",
+					message: `The key "${normalized.item.key}" is already used by sibling item "${conflictId}".`,
+					operationIndex,
+					operationId,
+					itemId
+				}));
+				return;
+			}
+			if (normalized.target.index !== void 0) {
+				const maximumUsefulIndex = getGroupChildren(parent.rawItem).length + getPlannedCreateCountForParent(parent.itemId, createdKeysByParentId);
+				if (normalized.target.index > maximumUsefulIndex) warnings.push(createIssue({
+					severity: "warning",
+					code: "target-index-after-end",
+					message: `The target index is after the end of the parent group and will be clamped by the editor apply path.`,
+					operationIndex,
+					operationId,
+					itemId
+				}));
+			}
+			if (!deterministicCreateItemTypes.has(normalized.item.itemType)) issues.push(createIssue({
+				code: "item-type-not-deterministically-creatable",
+				message: registryEntry ? registryEntry.create === "interactive-only" ? `Item type "${normalized.item.itemType}" requires an interactive editor flow and cannot be created silently.` : `Item type "${normalized.item.itemType}" is available in the editor registry but does not support deterministic creation.` : `Item type "${normalized.item.itemType}" is not available in the current editor registry.`,
+				operationIndex,
+				operationId,
+				itemId
+			}));
+			if (!hasRequiredCreateContent(normalized, registryEntry)) issues.push(createIssue({
+				code: "missing-create-content",
+				message: registryEntry?.contentSurfaces.find((surface) => surface.requiredOnCreate)?.key ? `New "${normalized.item.itemType}" items need visible content. Add a translation for "${registryEntry.contentSurfaces.find((surface) => surface.requiredOnCreate)?.key}".` : `New "${normalized.item.itemType}" items need visible content.`,
+				operationIndex,
+				operationId,
+				itemId
+			}));
+			const choiceContentIssue = getChoiceCreateContentIssue({
+				operation: normalized,
+				operationId,
+				operationIndex,
+				itemId
+			});
+			if (choiceContentIssue) issues.push(choiceContentIssue);
+			const embeddedFormFieldLabelIssue = getChoiceEmbeddedFormFieldLabelIssue({
+				operation: normalized,
+				operationId,
+				operationIndex,
+				itemId
+			});
+			if (embeddedFormFieldLabelIssue) issues.push(embeddedFormFieldLabelIssue);
+			const formFieldLabelIssue = getFormCreateFieldLabelIssue({
+				operation: normalized,
+				operationId,
+				operationIndex,
+				itemId
+			});
+			if (formFieldLabelIssue) issues.push(formFieldLabelIssue);
+			for (const translation of normalized.translations ?? []) {
+				addIntroducedLocaleWarning({
+					locale: translation.locale,
+					operationIndex,
+					operationId,
+					itemId
+				});
+				if (translation.contentKey.includes("..")) issues.push(createIssue({
+					code: "invalid-content-key",
+					message: "Translation content keys cannot contain empty path segments.",
+					operationIndex,
+					operationId,
+					itemId
+				}));
+			}
+			let normalizedItem = {
+				...normalized.item,
+				id: itemId
+			};
+			const trustedCapability = snapshot.trustedCapabilities?.byItemType.get(normalizedItem.itemType);
+			if (trustedCapability?.normalizeCreate) normalizedItem = trustedCapability.normalizeCreate(normalizedItem);
+			if (normalizedItem.id !== itemId || normalizedItem.itemType !== normalized.item.itemType || normalizedItem.key !== normalized.item.key) issues.push(createIssue({
+				code: "invalid-capability-normalization",
+				message: "The trusted item capability changed the new item's identity during normalization.",
+				operationIndex,
+				operationId,
+				itemId
+			}));
+			for (const issue of trustedCapability?.validateItem?.(normalizedItem) ?? []) {
+				const normalizedIssue = {
+					...issue,
+					operationIndex: issue.operationIndex ?? operationIndex,
+					operationId: issue.operationId ?? operationId,
+					itemId: issue.itemId ?? itemId
+				};
+				(normalizedIssue.severity === "warning" ? warnings : issues).push(normalizedIssue);
+			}
+			validateCreateItemExpressions({
+				issues,
+				item: normalizedItem,
+				operationId,
+				operationIndex,
+				responseSlotTypes: buildResponseSlotTypesForDraft({
+					currentItem: normalizedItem,
+					rawItemsById,
+					snapshot
+				})
+			});
+			if (issues.some((issue) => issue.operationIndex === operationIndex)) return;
+			const createdKeys = createdKeysByParentId.get(parent.itemId) ?? /* @__PURE__ */ new Map();
+			createdKeys.set(itemId, normalizedItem.key);
+			createdKeysByParentId.set(parent.itemId, createdKeys);
+			rawItemsById.set(itemId, normalizedItem);
+			parentByChildId.set(itemId, parent.itemId);
+			normalizedOperations.push({
+				...normalized,
+				target: {
+					...normalized.target,
+					parentItemId: parent.itemId
+				},
+				item: normalizedItem
+			});
+			return;
+		}
+		if (operation.kind === "survey-json-patch") return;
+		if (isSurveyLevelOperation(operation)) {
+			const normalized = normalizeOperation(operation, "");
+			switch (normalized.kind) {
+				case "update-survey-metadata":
+					if (Object.keys(normalized.values).length === 0) {
+						issues.push(createIssue({
+							code: "empty-survey-metadata-update",
+							message: "Provide at least one survey metadata key to set or remove.",
+							operationIndex,
+							operationId
+						}));
+						return;
+					}
+					break;
+				case "update-survey-translation":
+					addIntroducedLocaleWarning({
+						locale: normalized.locale,
+						operationIndex,
+						operationId
+					});
+					if (normalized.contentKey.includes("..")) {
+						issues.push(createIssue({
+							code: "invalid-content-key",
+							message: "Translation content keys cannot contain empty path segments.",
+							operationIndex,
+							operationId
+						}));
+						return;
+					}
+					break;
+				case "remove-survey-locale":
+					if (!snapshot.inspection.locales.includes(normalized.locale)) {
+						issues.push(createIssue({
+							code: "survey-locale-not-found",
+							message: `Locale "${normalized.locale}" is not present in the survey.`,
+							operationIndex,
+							operationId
+						}));
+						return;
+					}
+					if (snapshot.inspection.locales.length <= 1) {
+						issues.push(createIssue({
+							code: "cannot-remove-last-survey-locale",
+							message: "The survey's final locale cannot be removed.",
+							operationIndex,
+							operationId
+						}));
+						return;
+					}
+					break;
+				case "update-image-asset-metadata":
+				case "remove-image-asset":
+					if (!snapshot.survey.assets?.[normalized.assetId]) {
+						issues.push(createIssue({
+							code: "image-asset-not-found",
+							message: `Image asset "${normalized.assetId}" was not found.`,
+							operationIndex,
+							operationId
+						}));
+						return;
+					}
+					break;
+				case "set-image-asset":
+				case "update-survey-pagination": break;
+			}
+			normalizedOperations.push(normalized);
+			return;
+		}
+		const item = resolveRawItemByIdentifier({
+			identifier: getOperationTarget(operation),
+			indexById,
+			outlineById,
+			rawItemsById
+		});
+		if (!item) {
+			issues.push(createIssue({
+				code: "item-not-found",
+				message: `No survey item matching "${getOperationTarget(operation)}" was found.`,
+				operationIndex,
+				operationId
+			}));
+			return;
+		}
+		const deletedAncestorId = getDeletedAncestor(item.itemId, parentByChildId, deletedItemIds);
+		if (deletedItemIds.has(item.itemId) || deletedAncestorId) {
+			issues.push(createIssue({
+				code: "target-already-removed",
+				message: `The operation targets an item that is already removed earlier in this proposal.`,
+				operationIndex,
+				operationId,
+				itemId: item.itemId
+			}));
+			return;
+		}
+		const { rawItem } = item;
+		const rawNormalized = normalizeOperation(operation, item.itemId);
+		const normalized = rawNormalized.kind === "update-item-translation" || rawNormalized.kind === "update-placed-image" ? {
+			...rawNormalized,
+			contentKey: normalizeContentKeyForItemType(rawNormalized.contentKey, itemTypeManifestByType.get(rawItem.itemType))
+		} : rawNormalized.kind === "upsert-form-field-group" || rawNormalized.kind === "upsert-form-field" ? normalizeFormOperationTranslations(rawNormalized, rawNormalized.target.optionId) : rawNormalized.kind === "set-embedded-form" ? normalizeFormOperationTranslations(rawNormalized, rawNormalized.optionId) : rawNormalized;
+		if (!itemTypeManifestByType.get(rawItem.itemType)?.supportedOperations.includes(normalized.kind)) {
+			issues.push(createIssue({
+				code: "operation-not-supported-for-item-type",
+				message: `Item type "${rawItem.itemType}" does not support operation "${normalized.kind}".`,
+				operationIndex,
+				operationId,
+				itemId: item.itemId
+			}));
+			return;
+		}
+		const trustedCapability = snapshot.trustedCapabilities?.byItemType.get(rawItem.itemType);
+		if (trustedCapability?.supportsOperation && !trustedCapability.supportsOperation(normalized)) {
+			issues.push(createIssue({
+				code: "operation-rejected-by-item-capability",
+				message: `The trusted capability for "${rawItem.itemType}" rejected operation "${normalized.kind}".`,
+				operationIndex,
+				operationId,
+				itemId: item.itemId
+			}));
+			return;
+		}
+		switch (normalized.kind) {
+			case "update-item-key": {
+				if (!ITEM_KEY_PATTERN.test(normalized.key)) {
+					issues.push(createIssue({
+						code: "invalid-item-key",
+						message: "Item keys must contain only letters, numbers, underscores, or hyphens.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const conflictId = getSiblingKeyConflict({
+					createdKeysByParentId,
+					deletedItemIds,
+					itemId: item.itemId,
+					key: normalized.key,
+					parentByChildId,
+					plannedKeys,
+					rawItemsById
+				});
+				if (conflictId) {
+					issues.push(createIssue({
+						code: "duplicate-sibling-key",
+						message: `The key "${normalized.key}" is already used by sibling item "${conflictId}".`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (rawItem.key === normalized.key) warnings.push(createIssue({
+					severity: "warning",
+					code: "no-key-change",
+					message: `The item already has the key "${normalized.key}".`,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				}));
+				plannedKeys.set(item.itemId, normalized.key);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "update-item-label":
+				if ((rawItem.metadata?.itemLabel ?? "") === normalized.itemLabel) warnings.push(createIssue({
+					severity: "warning",
+					code: "no-label-change",
+					message: "The item already has that editor label.",
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				}));
+				normalizedOperations.push(normalized);
+				break;
+			case "update-item-color":
+				if (rawItem.metadata?.editorItemColor === normalized.color) warnings.push(createIssue({
+					severity: "warning",
+					code: "no-color-change",
+					message: "The item already has that editor color.",
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				}));
+				normalizedOperations.push(normalized);
+				break;
+			case "update-item-translation":
+				addIntroducedLocaleWarning({
+					locale: normalized.locale,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				});
+				if (normalized.contentKey.includes("..")) {
+					issues.push(createIssue({
+						code: "invalid-content-key",
+						message: "Translation content keys cannot contain empty path segments.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				normalizedOperations.push(normalized);
+				break;
+			case "update-placed-image": {
+				const content = new SurveyTranslations(snapshot.survey.translations).getItemTranslations(item.itemId)?.getContent(normalized.locale, normalized.contentKey);
+				if (content?.type !== ContentType.richText) {
+					issues.push(createIssue({
+						code: "placed-image-content-not-rich-text",
+						message: `Content "${normalized.locale}:${normalized.contentKey}" is not rich text and has no placed image to update.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const imageBlocks = content.doc.blocks.filter((block) => block.type === "image");
+				const image = imageBlocks[normalized.imageIndex];
+				if (!image) {
+					issues.push(createIssue({
+						code: "placed-image-not-found",
+						message: `No image exists at imageIndex ${normalized.imageIndex} in "${normalized.locale}:${normalized.contentKey}". The content contains ${imageBlocks.length} image block${imageBlocks.length === 1 ? "" : "s"}.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (normalized.expectedAssetId && (image.source.type !== "asset" || image.source.assetId !== normalized.expectedAssetId)) {
+					issues.push(createIssue({
+						code: "placed-image-asset-mismatch",
+						message: `The selected image no longer references expected asset "${normalized.expectedAssetId}". Inspect the item again before changing it.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "patch-item-config": {
+				let nextConfig;
+				try {
+					nextConfig = applyJsonPatch(rawItem.config ?? {}, normalized.patches);
+				} catch (error) {
+					const patchError = error instanceof JsonPatchError ? error : void 0;
+					issues.push(createIssue({
+						code: patchError?.code ?? "item-config-patch-failed",
+						message: error instanceof Error ? error.message : "The item config JSON Patch could not be applied.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const nextItem = {
+					...rawItem,
+					config: nextConfig
+				};
+				const capabilityIssues = trustedCapability?.validateItem?.(nextItem) ?? [];
+				for (const issue of capabilityIssues) {
+					const normalizedIssue = {
+						...issue,
+						operationIndex: issue.operationIndex ?? operationIndex,
+						operationId: issue.operationId ?? operationId,
+						itemId: issue.itemId ?? item.itemId
+					};
+					(normalizedIssue.severity === "warning" ? warnings : issues).push(normalizedIssue);
+				}
+				if (issues.some((issue) => issue.operationIndex === operationIndex)) break;
+				rawItemsById.set(item.itemId, nextItem);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "upsert-form-field-group": {
+				const groups = getFormFieldGroupsForTarget(rawItem, normalized.target.optionId);
+				if (!groups) {
+					issues.push(createIssue({
+						code: "form-target-not-found",
+						message: normalized.target.optionId ? `No inline embedded form was found on choice option "${normalized.target.optionId}".` : "Form operations require a formItem target.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const existingIndex = groups.findIndex((group) => group.id === normalized.group.id);
+				const existing = existingIndex >= 0 ? groups[existingIndex] : void 0;
+				const nextGroup = normalizeFormFieldGroupRecord({
+					...existing,
+					...normalized.group,
+					fields: Array.isArray(normalized.group.fields) ? normalized.group.fields : existing?.fields ?? []
+				});
+				if (!nextGroup) break;
+				const nextGroups = [...groups];
+				if (existingIndex >= 0) nextGroups[existingIndex] = nextGroup;
+				else {
+					const insertIndex = Math.min(normalized.index ?? nextGroups.length, nextGroups.length);
+					nextGroups.splice(insertIndex, 0, nextGroup);
+				}
+				const nextItem = withFormFieldGroupsForTarget(rawItem, nextGroups, normalized.target.optionId);
+				if (!nextItem) break;
+				for (const translation of normalized.translations ?? []) addIntroducedLocaleWarning({
+					locale: translation.locale,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				});
+				rawItemsById.set(item.itemId, nextItem);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "remove-form-field-group": {
+				const groups = getFormFieldGroupsForTarget(rawItem, normalized.target.optionId);
+				const groupIndex = groups?.findIndex((group) => group.id === normalized.groupId) ?? -1;
+				if (!groups || groupIndex < 0) {
+					issues.push(createIssue({
+						code: "form-field-group-not-found",
+						message: `Form field group "${normalized.groupId}" was not found.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const nextItem = withFormFieldGroupsForTarget(rawItem, groups.filter((_, index) => index !== groupIndex), normalized.target.optionId);
+				if (nextItem) rawItemsById.set(item.itemId, nextItem);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "reorder-form-field-groups": {
+				const groups = getFormFieldGroupsForTarget(rawItem, normalized.target.optionId);
+				const groupIds = groups?.map((group) => group.id) ?? [];
+				if (!groups || normalized.groupIds.length !== groupIds.length || new Set(normalized.groupIds).size !== groupIds.length || normalized.groupIds.some((groupId) => !groupIds.includes(groupId))) {
+					issues.push(createIssue({
+						code: "incomplete-form-field-group-order",
+						message: "Reordering form groups requires every existing group id exactly once.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const byId = new Map(groups.map((group) => [group.id, group]));
+				const nextItem = withFormFieldGroupsForTarget(rawItem, normalized.groupIds.map((groupId) => byId.get(groupId)), normalized.target.optionId);
+				if (nextItem) rawItemsById.set(item.itemId, nextItem);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "upsert-form-field": {
+				const groups = getFormFieldGroupsForTarget(rawItem, normalized.target.optionId);
+				const groupIndex = groups?.findIndex((group) => group.id === normalized.groupId) ?? -1;
+				if (!groups || groupIndex < 0) {
+					issues.push(createIssue({
+						code: "form-field-group-not-found",
+						message: `Form field group "${normalized.groupId}" was not found.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (groups.flatMap((group) => group.fields).find((field) => field.id !== normalized.field.id && field.key === normalized.field.key)) {
+					issues.push(createIssue({
+						code: "duplicate-form-field-key",
+						message: `Form field key "${normalized.field.key}" is already in use.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const nextGroups = groups.map((group) => ({
+					...group,
+					fields: [...group.fields]
+				}));
+				let existingField;
+				for (const group of nextGroups) {
+					const existingIndex = group.fields.findIndex((field) => field.id === normalized.field.id);
+					if (existingIndex >= 0) {
+						existingField = group.fields[existingIndex];
+						group.fields.splice(existingIndex, 1);
+					}
+				}
+				const targetFields = nextGroups[groupIndex].fields;
+				const insertIndex = Math.min(normalized.index ?? targetFields.length, targetFields.length);
+				targetFields.splice(insertIndex, 0, {
+					...existingField,
+					...normalized.field
+				});
+				const nextItem = withFormFieldGroupsForTarget(rawItem, nextGroups, normalized.target.optionId);
+				if (nextItem) rawItemsById.set(item.itemId, nextItem);
+				for (const translation of normalized.translations ?? []) addIntroducedLocaleWarning({
+					locale: translation.locale,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				});
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "remove-form-field":
+			case "move-form-field": {
+				const groups = getFormFieldGroupsForTarget(rawItem, normalized.target.optionId);
+				if (!groups) {
+					issues.push(createIssue({
+						code: "form-target-not-found",
+						message: "The requested form or embedded form was not found.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const nextGroups = groups.map((group) => ({
+					...group,
+					fields: [...group.fields]
+				}));
+				let foundField;
+				for (const group of nextGroups) {
+					const fieldIndex = group.fields.findIndex((field) => field.id === normalized.fieldId);
+					if (fieldIndex >= 0) {
+						[foundField] = group.fields.splice(fieldIndex, 1);
+						break;
+					}
+				}
+				if (!foundField) {
+					issues.push(createIssue({
+						code: "form-field-not-found",
+						message: `Form field "${normalized.fieldId}" was not found.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (normalized.kind === "move-form-field") {
+					const targetGroup = nextGroups.find((group) => group.id === normalized.targetGroupId);
+					if (!targetGroup) {
+						issues.push(createIssue({
+							code: "form-field-group-not-found",
+							message: `Target form field group "${normalized.targetGroupId}" was not found.`,
+							operationIndex,
+							operationId,
+							itemId: item.itemId
+						}));
+						break;
+					}
+					targetGroup.fields.splice(Math.min(normalized.index ?? targetGroup.fields.length, targetGroup.fields.length), 0, foundField);
+				}
+				const nextItem = withFormFieldGroupsForTarget(rawItem, nextGroups, normalized.target.optionId);
+				if (nextItem) rawItemsById.set(item.itemId, nextItem);
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "set-embedded-form":
+			case "remove-embedded-form": {
+				if (rawItem.itemType !== CHOICE_ITEM_TYPE) {
+					issues.push(createIssue({
+						code: "not-choice-item",
+						message: "Embedded forms can only target choiceItem options.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const options = getChoiceOptionsFromRawItem(rawItem);
+				const optionIndex = options.findIndex((option) => option.id === normalized.optionId);
+				if (optionIndex < 0) {
+					issues.push(createIssue({
+						code: "choice-option-not-found",
+						message: `Choice option "${normalized.optionId}" was not found.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				options[optionIndex] = { ...options[optionIndex] };
+				if (normalized.kind === "set-embedded-form") {
+					options[optionIndex].embeddedForm = normalized.form;
+					for (const translation of normalized.translations ?? []) addIntroducedLocaleWarning({
+						locale: translation.locale,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					});
+				} else {
+					delete options[optionIndex].embeddedForm;
+					delete options[optionIndex].embeddedFormItemId;
+				}
+				rawItemsById.set(item.itemId, withChoiceOptionsOnRawItem(rawItem, options));
+				normalizedOperations.push(normalized);
+				break;
+			}
+			case "add-choice-option": {
+				const locale = normalized.locale ?? snapshot.ui.selectedLocale;
+				if (rawItem.itemType !== CHOICE_ITEM_TYPE) {
+					issues.push(createIssue({
+						code: "not-choice-item",
+						message: "Choice option operations can only target choiceItem items.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				addIntroducedLocaleWarning({
+					locale,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				});
+				if (!normalized.option.label.trim()) {
+					issues.push(createIssue({
+						code: "missing-choice-option-label",
+						message: "A new choice option needs a non-empty respondent-visible label.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const options = getChoiceOptionsFromRawItem(rawItem);
+				const usedIds = new Set(options.map((option) => option.id));
+				const usedKeys = new Set(options.map((option) => option.key).filter((key) => Boolean(key)));
+				const optionId = ensureUniqueId(normalized.option.id ?? normalized.option.label, usedIds);
+				const optionKey = ensureUniqueChoiceOptionKey(normalized.option.key ?? normalized.option.label, usedKeys);
+				const nextOption = {
+					id: optionId,
+					key: optionKey
+				};
+				const insertIndex = normalized.index === void 0 ? options.length : Math.min(options.length, Math.max(0, normalized.index));
+				const nextOptions = [...options];
+				nextOptions.splice(insertIndex, 0, nextOption);
+				if (normalized.index !== void 0 && normalized.index > options.length) warnings.push(createIssue({
+					severity: "warning",
+					code: "option-index-after-end",
+					message: "The option index is after the end of the option list and will be clamped.",
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				}));
+				rawItemsById.set(item.itemId, withChoiceOptionsOnRawItem(rawItem, nextOptions));
+				normalizedOperations.push({
+					...normalized,
+					locale,
+					index: insertIndex,
+					option: {
+						id: optionId,
+						key: optionKey,
+						label: normalized.option.label
+					}
+				});
+				break;
+			}
+			case "update-choice-option-label": {
+				const locale = normalized.locale ?? snapshot.ui.selectedLocale;
+				if (rawItem.itemType !== CHOICE_ITEM_TYPE) {
+					issues.push(createIssue({
+						code: "not-choice-item",
+						message: "Choice option operations can only target choiceItem items.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				addIntroducedLocaleWarning({
+					locale,
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				});
+				const option = resolveChoiceOption({
+					itemId: item.itemId,
+					locale,
+					optionRef: normalized.optionId,
+					options: getChoiceOptionsFromRawItem(rawItem),
+					snapshot
+				});
+				if (!option) {
+					issues.push(createChoiceOptionsConflictIssue({
+						code: "choice-option-not-found",
+						message: `No option matching "${normalized.optionId}" was found on this choice item.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (getItemTranslationText({
+					contentKey: createChoiceOptionLabelContentKey(option.id),
+					itemId: item.itemId,
+					locale,
+					snapshot
+				}) === normalized.label) warnings.push(createIssue({
+					severity: "warning",
+					code: "no-choice-option-label-change",
+					message: "The option already has that label.",
+					operationIndex,
+					operationId,
+					itemId: item.itemId
+				}));
+				normalizedOperations.push({
+					...normalized,
+					locale,
+					optionId: option.id
+				});
+				break;
+			}
+			case "remove-choice-option": {
+				if (rawItem.itemType !== CHOICE_ITEM_TYPE) {
+					issues.push(createIssue({
+						code: "not-choice-item",
+						message: "Choice option operations can only target choiceItem items.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const options = getChoiceOptionsFromRawItem(rawItem);
+				const option = resolveChoiceOption({
+					itemId: item.itemId,
+					locale: snapshot.ui.selectedLocale,
+					optionRef: normalized.optionId,
+					options,
+					snapshot
+				});
+				if (!option) {
+					issues.push(createChoiceOptionsConflictIssue({
+						code: "choice-option-not-found",
+						message: `No option matching "${normalized.optionId}" was found on this choice item.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				rawItemsById.set(item.itemId, withChoiceOptionsOnRawItem(rawItem, options.filter((candidate) => candidate.id !== option.id)));
+				normalizedOperations.push({
+					...normalized,
+					optionId: option.id
+				});
+				break;
+			}
+			case "reorder-choice-options": {
+				if (rawItem.itemType !== CHOICE_ITEM_TYPE) {
+					issues.push(createIssue({
+						code: "not-choice-item",
+						message: "Choice option operations can only target choiceItem items.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const options = getChoiceOptionsFromRawItem(rawItem);
+				const resolvedOptions = normalized.optionIds.map((optionRef) => resolveChoiceOption({
+					itemId: item.itemId,
+					locale: snapshot.ui.selectedLocale,
+					optionRef,
+					options,
+					snapshot
+				}));
+				const missingIndex = resolvedOptions.findIndex((option) => !option);
+				if (missingIndex >= 0) {
+					issues.push(createChoiceOptionsConflictIssue({
+						code: "choice-option-not-found",
+						message: `No option matching "${normalized.optionIds[missingIndex]}" was found on this choice item.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const resolvedOptionIds = resolvedOptions.map((option) => option.id);
+				if (new Set(resolvedOptionIds).size !== resolvedOptionIds.length) {
+					issues.push(createChoiceOptionsConflictIssue({
+						code: "duplicate-choice-option-order-entry",
+						message: "The option order contains the same option more than once.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const existingOptionIds = new Set(options.map((option) => option.id));
+				if (resolvedOptionIds.length !== options.length || resolvedOptionIds.some((optionId) => !existingOptionIds.has(optionId))) {
+					issues.push(createChoiceOptionsConflictIssue({
+						code: "incomplete-choice-option-order",
+						message: "Reordering options requires a complete order containing every existing option exactly once.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const optionsById = new Map(options.map((option) => [option.id, option]));
+				rawItemsById.set(item.itemId, withChoiceOptionsOnRawItem(rawItem, resolvedOptionIds.map((optionId) => optionsById.get(optionId))));
+				normalizedOperations.push({
+					...normalized,
+					optionIds: resolvedOptionIds
+				});
+				break;
+			}
+			case "move-item": {
+				if (isRootItem(rawItem)) {
+					issues.push(createIssue({
+						code: "cannot-move-root",
+						message: "The survey root item cannot be moved.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const parent = resolveCreateParentByIdentifier({
+					identifier: normalized.target.parentItemId,
+					indexById,
+					outlineById,
+					rawItemsById
+				});
+				if (!parent || parent.rawItem.itemType !== ReservedSurveyItemTypes.Group) {
+					issues.push(createIssue({
+						code: "target-parent-not-group",
+						message: `Move target "${normalized.target.parentItemId}" is not an existing group.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				if (item.itemId === parent.itemId || collectDescendantIds(item.itemId, rawItemsById).has(parent.itemId)) {
+					issues.push(createIssue({
+						code: "move-would-create-cycle",
+						message: "An item cannot be moved into itself or one of its descendants.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const previousParentId = parentByChildId.get(item.itemId);
+				if (previousParentId) {
+					const previousParent = rawItemsById.get(previousParentId);
+					if (previousParent) rawItemsById.set(previousParentId, {
+						...previousParent,
+						config: {
+							...isRecord$2(previousParent.config) ? previousParent.config : {},
+							items: getGroupChildren(previousParent).filter((childId) => childId !== item.itemId)
+						}
+					});
+				}
+				const nextChildren = getGroupChildren(parent.rawItem).filter((childId) => childId !== item.itemId);
+				nextChildren.splice(Math.min(normalized.target.index ?? nextChildren.length, nextChildren.length), 0, item.itemId);
+				rawItemsById.set(parent.itemId, {
+					...parent.rawItem,
+					config: {
+						...isRecord$2(parent.rawItem.config) ? parent.rawItem.config : {},
+						items: nextChildren
+					}
+				});
+				parentByChildId.set(item.itemId, parent.itemId);
+				normalizedOperations.push({
+					...normalized,
+					target: {
+						...normalized.target,
+						parentItemId: parent.itemId
+					}
+				});
+				break;
+			}
+			case "reorder-items": {
+				if (rawItem.itemType !== ReservedSurveyItemTypes.Group) {
+					issues.push(createIssue({
+						code: "target-parent-not-group",
+						message: "Only group children can be reordered.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const currentChildren = getGroupChildren(rawItem);
+				const resolvedIds = normalized.itemIds.map((itemRef) => resolveRawItemByIdentifier({
+					identifier: itemRef,
+					indexById,
+					outlineById,
+					rawItemsById
+				})).map((child) => child?.itemId);
+				if (resolvedIds.some((childId) => !childId) || resolvedIds.length !== currentChildren.length || new Set(resolvedIds).size !== currentChildren.length || resolvedIds.some((childId) => !currentChildren.includes(childId))) {
+					issues.push(createIssue({
+						code: "incomplete-item-order",
+						message: "Reordering group children requires every existing direct child exactly once.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				rawItemsById.set(item.itemId, {
+					...rawItem,
+					config: {
+						...isRecord$2(rawItem.config) ? rawItem.config : {},
+						items: resolvedIds
+					}
+				});
+				normalizedOperations.push({
+					...normalized,
+					itemIds: resolvedIds
+				});
+				break;
+			}
+			case "remove-item": {
+				if (isRootItem(rawItem)) {
+					issues.push(createIssue({
+						code: "cannot-remove-root",
+						message: "The survey root item cannot be removed.",
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				const descendantIds = collectDescendantIds(item.itemId, rawItemsById);
+				if (descendantIds.size > 0 && !normalized.includeChildren) {
+					issues.push(createIssue({
+						code: "remove-would-delete-children",
+						message: `Removing this item would also remove ${descendantIds.size} child item(s). Set includeChildren to true if that is intended.`,
+						operationIndex,
+						operationId,
+						itemId: item.itemId
+					}));
+					break;
+				}
+				deletedItemIds.add(item.itemId);
+				for (const descendantId of descendantIds) deletedItemIds.add(descendantId);
+				normalizedOperations.push(normalized);
+				break;
+			}
+		}
+	});
+	return {
+		valid: issues.length === 0,
+		issues,
+		warnings,
+		normalizedOperations
+	};
+};
+const createSurveyChangeSet = ({ operations, snapshot, summary, turnId }) => {
+	const validation = validateSurveyOperations({
+		operations,
+		snapshot
+	});
+	return {
+		protocolVersion: 1,
+		id: globalThis.crypto.randomUUID(),
+		turnId,
+		status: validation.valid ? "validated" : "rejected",
+		summary: normalizeSummary(summary),
+		operations: validation.normalizedOperations,
+		precondition: snapshot ? buildSurveyDocumentVersion(snapshot) : void 0,
+		validation,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+};
+//#endregion
+//#region src/engine/turn-change-collector.ts
+const createId = () => globalThis.crypto.randomUUID();
+const SURVEY_CHANGE_CONTINUATION_MODES = ["append", "replace"];
+const SURVEY_CHANGE_CONTINUATION_DESCRIPTION = "Omit only for the first mutation call in this turn. On every later mutation call, use \"append\" for independent additional work or \"replace\" for a correction that should discard all currently active candidates.";
+var TurnChangeCollector = class {
+	turnId;
+	#candidates = /* @__PURE__ */ new Map();
+	#activeChangeSetIds = [];
+	#blockedChangeSetIds = /* @__PURE__ */ new Set();
+	#ambiguousChangeSetIds = /* @__PURE__ */ new Set();
+	#requiresReplacement = false;
+	#final = null;
+	constructor(turnId = createId()) {
+		this.turnId = turnId;
+	}
+	register(candidate, { continuationMode } = {}) {
+		if (this.#final) throw new Error("Cannot register a survey change after the turn was finalized.");
+		if (this.#candidates.has(candidate.id)) throw new Error(`Survey change "${candidate.id}" was registered more than once.`);
+		const modeRequired = this.#candidates.size > 0 && continuationMode === void 0;
+		const replacementRequired = this.#requiresReplacement && continuationMode !== "replace";
+		const continuationIssue = modeRequired ? {
+			severity: "error",
+			code: "change-mode-required",
+			message: "A prior mutation candidate exists in this turn. Retry this complete proposal with continuationMode \"append\" for independent additional work or \"replace\" for a correction that discards the active candidates."
+		} : replacementRequired ? {
+			severity: "error",
+			code: "change-mode-repair-required",
+			message: "An earlier mutation proposal was rejected and blocked turn authorization. Retry the complete intended proposal with continuationMode \"replace\" before appending any later independent chunks."
+		} : void 0;
+		const candidateWasRejected = candidate.status !== "validated" || !candidate.validation.valid;
+		const ambiguousModeOnly = modeRequired && !candidateWasRejected && continuationIssue?.code === "change-mode-required";
+		const shouldClearActive = continuationMode === "replace" || continuationIssue !== void 0 && !ambiguousModeOnly || candidateWasRejected;
+		const supersedesChangeIds = shouldClearActive ? [...this.#activeChangeSetIds] : [];
+		const registered = surveyChangeSetSchema.parse({
+			...candidate,
+			turnId: this.turnId,
+			...continuationIssue ? {
+				status: "rejected",
+				validation: {
+					...candidate.validation,
+					valid: false,
+					issues: [...candidate.validation.issues, continuationIssue]
+				}
+			} : {},
+			...supersedesChangeIds.length > 0 ? { supersedesChangeIds } : {}
+		});
+		this.#candidates.set(registered.id, registered);
+		const isValidated = registered.status === "validated" && registered.validation.valid;
+		if (shouldClearActive) this.#activeChangeSetIds = [];
+		if (ambiguousModeOnly) {
+			this.#blockedChangeSetIds.add(registered.id);
+			this.#ambiguousChangeSetIds.add(registered.id);
+		} else if (!isValidated) {
+			this.#blockedChangeSetIds.add(registered.id);
+			this.#requiresReplacement = true;
+		} else if (continuationMode === "replace") {
+			this.#blockedChangeSetIds.clear();
+			this.#ambiguousChangeSetIds.clear();
+			this.#requiresReplacement = false;
+		} else if (continuationMode === "append" && this.#ambiguousChangeSetIds.size > 0) {
+			for (const changeSetId of this.#ambiguousChangeSetIds) this.#blockedChangeSetIds.delete(changeSetId);
+			this.#ambiguousChangeSetIds.clear();
+		}
+		if (!this.#requiresReplacement && isValidated) this.#activeChangeSetIds.push(registered.id);
+		return registered;
+	}
+	finalize(status, createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
+		if (this.#final) return this.#final;
+		const blockedChangeSetIds = [...this.#blockedChangeSetIds];
+		const canAuthorize = status === "completed" && !this.#requiresReplacement && blockedChangeSetIds.length === 0;
+		this.#final = surveyAssistantTurnFinalSchema.parse({
+			protocolVersion: 1,
+			turnId: this.turnId,
+			status,
+			executableChangeSetIds: canAuthorize ? this.#activeChangeSetIds : [],
+			...blockedChangeSetIds.length > 0 ? { blockedChangeSetIds } : {},
+			createdAt
+		});
+		return this.#final;
+	}
+	getCandidate(changeSetId) {
+		return this.#candidates.get(changeSetId);
+	}
+	get final() {
+		return this.#final;
+	}
+};
+//#endregion
+//#region src/engine/task-context.ts
+const MAX_RELATED_ITEMS = 48;
+const MAX_SIBLING_ITEMS = 80;
+const MAX_VISIBLE_TEXT_ENTRIES_PER_ITEM = 24;
+const MAX_VISIBLE_TEXT_CHARS = 600;
+const MAX_NAMING_EXAMPLES = 40;
+const MAX_TRANSLATION_EXAMPLES = 60;
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getItemLabel = (item) => {
+	if (!isRecord$1(item.metadata)) return void 0;
+	const label = item.metadata.itemLabel;
+	return typeof label === "string" && label.trim().length > 0 ? label.trim() : void 0;
+};
+const getCenteredNeighbors = (values, focusIndex, limit) => {
+	if (focusIndex < 0 || limit < 1) return [];
+	const windowSize = Math.min(values.length, limit + 1);
+	const idealStart = focusIndex - Math.floor(limit / 2);
+	const start = Math.min(Math.max(0, idealStart), values.length - windowSize);
+	return values.slice(start, start + windowSize).filter((_, index) => start + index !== focusIndex);
+};
+const buildSurveyAssistantTaskContext = (snapshot, options) => {
+	const { inspection } = createSurveyAssistantEngineContext(snapshot, void 0, { focusItemId: options.focusItemId });
+	const itemsById = new Map(snapshot.survey.surveyItems.map((item) => [item.id, item]));
+	const parentById = new Map(inspection.outline.flatMap((item) => item.parentId ? [[item.itemId, item.parentId]] : []));
+	const childIdsByParent = /* @__PURE__ */ new Map();
+	for (const item of inspection.outline) {
+		if (!item.parentId) continue;
+		const childIds = childIdsByParent.get(item.parentId) ?? [];
+		childIds.push(item.itemId);
+		childIdsByParent.set(item.parentId, childIds);
+	}
+	const fullKeyById = new Map(inspection.keyIndex.map((item) => [item.itemId, item.fullKey]));
+	const summarizeItem = (item) => {
+		const allVisibleText = [];
+		let visibleTextValueTruncated = false;
+		for (const [locale, translations] of Object.entries(snapshot.survey.translations ?? {})) {
+			const itemTranslations = translations.itemTranslations?.[item.id];
+			if (!itemTranslations) continue;
+			for (const [contentKey, content] of Object.entries(itemTranslations)) {
+				const text = getContentPlainText(content).trim();
+				if (text) {
+					if (text.length > MAX_VISIBLE_TEXT_CHARS) visibleTextValueTruncated = true;
+					allVisibleText.push({
+						locale,
+						contentKey,
+						text: text.length > MAX_VISIBLE_TEXT_CHARS ? `${text.slice(0, MAX_VISIBLE_TEXT_CHARS)}...` : text
+					});
+				}
+			}
+		}
+		return {
+			id: item.id,
+			key: item.key,
+			fullKey: fullKeyById.get(item.id) ?? item.key,
+			itemType: item.itemType,
+			itemLabel: getItemLabel(item),
+			visibleText: allVisibleText.slice(0, MAX_VISIBLE_TEXT_ENTRIES_PER_ITEM),
+			visibleTextTruncated: allVisibleText.length > MAX_VISIBLE_TEXT_ENTRIES_PER_ITEM || visibleTextValueTruncated
+		};
+	};
+	const rootItemId = inspection.outline.find((item) => item.depth === 0)?.itemId;
+	const rootItem = rootItemId ? itemsById.get(rootItemId) : void 0;
+	const result = {
+		document: {
+			revision: snapshot.version.revision,
+			contentHash: snapshot.version.contentHash,
+			capabilityDigest: snapshot.version.capabilityDigest
+		},
+		survey: {
+			key: rootItem?.key,
+			locales: inspection.locales,
+			itemCount: inspection.itemCount,
+			selectedLocale: snapshot.ui.selectedLocale
+		}
+	};
+	const focusItem = options.focusItemId ? itemsById.get(options.focusItemId) : void 0;
+	if (focusItem) {
+		const parentId = parentById.get(focusItem.id);
+		const parentItem = parentId ? itemsById.get(parentId) : void 0;
+		const ancestorItems = [];
+		const seenAncestorIds = /* @__PURE__ */ new Set();
+		let ancestorId = parentId;
+		while (ancestorId && !seenAncestorIds.has(ancestorId)) {
+			seenAncestorIds.add(ancestorId);
+			const ancestor = itemsById.get(ancestorId);
+			if (!ancestor) break;
+			ancestorItems.unshift(ancestor);
+			ancestorId = parentById.get(ancestorId);
+		}
+		const siblingIds = parentItem ? childIdsByParent.get(parentItem.id) ?? [] : [];
+		const siblingItemCount = Math.max(0, siblingIds.length - 1);
+		const siblingItems = getCenteredNeighbors(siblingIds, siblingIds.indexOf(focusItem.id), MAX_SIBLING_ITEMS).map((itemId) => itemsById.get(itemId)).filter((item) => Boolean(item));
+		const allRelatedItems = [];
+		const seenRelatedIds = /* @__PURE__ */ new Set();
+		const pending = [...childIdsByParent.get(focusItem.id) ?? []];
+		while (pending.length > 0) {
+			const itemId = pending.shift();
+			const item = itemId ? itemsById.get(itemId) : void 0;
+			if (!item || seenRelatedIds.has(item.id)) continue;
+			seenRelatedIds.add(item.id);
+			allRelatedItems.push(item);
+			pending.push(...childIdsByParent.get(item.id) ?? []);
+		}
+		const relatedItems = allRelatedItems.slice(0, MAX_RELATED_ITEMS);
+		result.focus = {
+			item: summarizeItem(focusItem),
+			parent: parentItem ? summarizeItem(parentItem) : void 0,
+			ancestorPath: ancestorItems.map(summarizeItem),
+			siblingKeys: siblingItems.map((item) => item.key),
+			siblingItems: siblingItems.map(summarizeItem),
+			siblingItemCount,
+			siblingItemsTruncated: siblingItemCount > siblingItems.length,
+			relatedItems: relatedItems.map(summarizeItem),
+			relatedItemCount: allRelatedItems.length,
+			relatedItemsTruncated: allRelatedItems.length > relatedItems.length
+		};
+	}
+	if ((options.purpose === "suggest-item-key" || options.purpose === "suggest-item-label") && focusItem) {
+		const parentId = parentById.get(focusItem.id);
+		const siblingIds = parentId ? childIdsByParent.get(parentId) ?? [] : [];
+		const siblingPositionById = new Map(siblingIds.map((itemId, index) => [itemId, index]));
+		const focusSiblingPosition = siblingPositionById.get(focusItem.id);
+		const rankedItems = snapshot.survey.surveyItems.filter((item) => item.id !== focusItem.id).map((item, index) => ({
+			item,
+			index,
+			siblingDistance: focusSiblingPosition !== void 0 && siblingPositionById.has(item.id) ? Math.abs(siblingPositionById.get(item.id) - focusSiblingPosition) : Number.POSITIVE_INFINITY,
+			relationship: parentById.get(item.id) === parentId ? "sibling" : item.itemType === focusItem.itemType ? "same-type" : "survey"
+		})).sort((left, right) => {
+			const rank = {
+				sibling: 0,
+				"same-type": 1,
+				survey: 2
+			};
+			return rank[left.relationship] - rank[right.relationship] || left.siblingDistance - right.siblingDistance || left.index - right.index;
+		});
+		const allKeyExamples = rankedItems.map(({ item, relationship }) => ({
+			itemId: item.id,
+			itemType: item.itemType,
+			key: item.key,
+			relationship
+		}));
+		const allLabelExamples = rankedItems.flatMap(({ item, relationship }) => {
+			const label = getItemLabel(item);
+			return label ? [{
+				itemId: item.id,
+				itemType: item.itemType,
+				key: item.key,
+				label,
+				relationship
+			}] : [];
+		});
+		result.naming = {
+			keyExamples: allKeyExamples.slice(0, MAX_NAMING_EXAMPLES),
+			keyExampleCount: allKeyExamples.length,
+			keyExamplesTruncated: allKeyExamples.length > MAX_NAMING_EXAMPLES,
+			labelExamples: allLabelExamples.slice(0, MAX_NAMING_EXAMPLES),
+			labelExampleCount: allLabelExamples.length,
+			labelExamplesTruncated: allLabelExamples.length > MAX_NAMING_EXAMPLES
+		};
+	}
+	const sourceLocale = options.sourceLocale;
+	if (options.purpose === "translate-content" && sourceLocale) {
+		const relevantLocales = [sourceLocale, ...options.targetLocales ?? []];
+		const sourceTokens = new Set((options.sourceTexts ?? []).flatMap((text) => text.toLocaleLowerCase().split(/[^\p{L}\p{N}]+/u)).filter((token) => token.length >= 3));
+		const allExamples = [];
+		snapshot.survey.surveyItems.forEach((item, itemIndex) => {
+			const contentKeys = /* @__PURE__ */ new Set();
+			for (const locale of relevantLocales) {
+				const itemTranslations = snapshot.survey.translations?.[locale]?.itemTranslations?.[item.id];
+				for (const contentKey of Object.keys(itemTranslations ?? {})) contentKeys.add(contentKey);
+			}
+			for (const contentKey of contentKeys) {
+				const values = {};
+				for (const locale of relevantLocales) {
+					const content = snapshot.survey.translations?.[locale]?.itemTranslations?.[item.id]?.[contentKey];
+					if (!content) continue;
+					const text = getContentPlainText(content).trim();
+					if (text) values[locale] = text.slice(0, MAX_VISIBLE_TEXT_CHARS);
+				}
+				const sourceText = values[sourceLocale];
+				if (!sourceText || Object.keys(values).length < 2) continue;
+				const normalizedSource = sourceText.toLocaleLowerCase();
+				const score = [...sourceTokens].reduce((total, token) => total + (normalizedSource.includes(token) ? 1 : 0), 0);
+				allExamples.push({
+					itemId: item.id,
+					contentKey,
+					values,
+					score,
+					order: itemIndex
+				});
+			}
+		});
+		allExamples.sort((left, right) => right.score - left.score || left.order - right.order);
+		result.translation = {
+			examples: allExamples.slice(0, MAX_TRANSLATION_EXAMPLES).map(({ itemId, contentKey, values }) => ({
+				itemId,
+				contentKey,
+				values
+			})),
+			exampleCount: allExamples.length,
+			examplesTruncated: allExamples.length > MAX_TRANSLATION_EXAMPLES
+		};
+	}
+	return result;
+};
+//#endregion
+//#region src/engine/task-result-cache.ts
+const DEFAULT_TTL_MS = 900 * 1e3;
+const DEFAULT_MAX_ENTRIES = 64;
+/** Small in-memory LRU cache for deterministic, snapshot-scoped one-shot results. */
+var SurveyAssistantTaskResultCache = class {
+	entries = /* @__PURE__ */ new Map();
+	ttlMs;
+	maxEntries;
+	now;
+	constructor(options = {}) {
+		this.ttlMs = Math.max(0, options.ttlMs ?? DEFAULT_TTL_MS);
+		this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_ENTRIES);
+		this.now = options.now ?? Date.now;
+	}
+	get(key) {
+		const entry = this.entries.get(key);
+		if (!entry) return void 0;
+		if (entry.expiresAt <= this.now()) {
+			this.entries.delete(key);
+			return;
+		}
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		return entry.value;
+	}
+	set(key, value) {
+		this.entries.delete(key);
+		this.entries.set(key, {
+			expiresAt: this.now() + this.ttlMs,
+			value
+		});
+		while (this.entries.size > this.maxEntries) {
+			const oldestKey = this.entries.keys().next().value;
+			if (oldestKey === void 0) break;
+			this.entries.delete(oldestKey);
+		}
+	}
+	clear() {
+		this.entries.clear();
+	}
+};
+//#endregion
+//#region src/engine/audit.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const records = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+const strings = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+const QUALITY_PRINCIPLES = [
+	{
+		id: "purpose-alignment",
+		title: "Purpose and construct alignment",
+		prompt: "Does every question serve a stated objective, and does it measure the intended construct?"
+	},
+	{
+		id: "cognitive-burden",
+		title: "Respondent burden",
+		prompt: "Is the survey as short and cognitively simple as its purpose allows?"
+	},
+	{
+		id: "question-wording",
+		title: "Clear, neutral wording",
+		prompt: "Are questions specific, neutral, answerable, and limited to one idea without assumptions or double negatives?"
+	},
+	{
+		id: "recall",
+		title: "Recall and reference periods",
+		prompt: "Are recall periods explicit, realistic, and consistent with what respondents can remember?"
+	},
+	{
+		id: "response-options",
+		title: "Response option quality",
+		prompt: "Are options mutually exclusive, collectively sufficient, balanced, ordered, and consistently scaled?"
+	},
+	{
+		id: "flow",
+		title: "Flow and completeness",
+		prompt: "Does the order move logically from easy/general to specific, with needed instructions and no important objective omitted?"
+	},
+	{
+		id: "routing",
+		title: "Requiredness and routing",
+		prompt: "Do required fields, branching, validation, and not-applicable paths avoid forcing inaccurate answers?"
+	},
+	{
+		id: "sensitivity",
+		title: "Sensitivity and ethics",
+		prompt: "Are sensitive questions justified, respectfully phrased, appropriately optional, and paired with privacy context where needed?"
+	},
+	{
+		id: "accessibility",
+		title: "Accessibility and inclusion",
+		prompt: "Is language plain and inclusive, and are content, controls, and images understandable without avoidable barriers?"
+	},
+	{
+		id: "localization",
+		title: "Cross-language equivalence",
+		prompt: "Do translations preserve meaning and cultural relevance rather than merely matching words?"
+	},
+	{
+		id: "testing",
+		title: "Testing and validation",
+		prompt: "Has the instrument been cognitively tested, piloted, and checked for reliability or validity where the intended use requires it?"
+	}
+];
+const translationText = (context, locale, itemId, contentKey) => {
+	const localeTranslations = isRecord(context.survey.translations?.[locale]) ? context.survey.translations?.[locale] : void 0;
+	const itemTranslations = isRecord(localeTranslations?.itemTranslations) ? localeTranslations.itemTranslations : void 0;
+	const content = (isRecord(itemTranslations?.[itemId]) ? itemTranslations[itemId] : void 0)?.[contentKey];
+	return content ? getContentPlainText(content).trim() : "";
+};
+const getGroups = (item, optionId) => {
+	const config = isRecord(item.config) ? item.config : {};
+	if (!optionId) return records(config.fieldGroups);
+	const option = records(config.options).find((entry) => entry.id === optionId);
+	return records(isRecord(option?.embeddedForm) ? option.embeddedForm.fieldGroups : void 0);
+};
+const auditSurvey = (context, options = {}) => {
+	const findings = [];
+	const add = (finding) => findings.push(finding);
+	const items = context.survey.surveyItems;
+	const itemsById = /* @__PURE__ */ new Map();
+	const parentById = /* @__PURE__ */ new Map();
+	const itemTypes = {};
+	for (const item of items) {
+		itemTypes[item.itemType] = (itemTypes[item.itemType] ?? 0) + 1;
+		if (itemsById.has(item.id)) add({
+			code: "duplicate-item-id",
+			severity: "error",
+			category: "structure",
+			itemId: item.id,
+			message: `Item id "${item.id}" is duplicated.`
+		});
+		itemsById.set(item.id, item);
+	}
+	for (const parent of items) {
+		const seenChildren = /* @__PURE__ */ new Set();
+		for (const childId of strings(isRecord(parent.config) ? parent.config.items : void 0)) {
+			if (seenChildren.has(childId)) add({
+				code: "duplicate-child-reference",
+				severity: "error",
+				category: "structure",
+				itemId: parent.id,
+				message: `Child "${childId}" is listed more than once.`
+			});
+			seenChildren.add(childId);
+			if (!itemsById.has(childId)) add({
+				code: "missing-child",
+				severity: "error",
+				category: "structure",
+				itemId: parent.id,
+				message: `Referenced child "${childId}" does not exist.`
+			});
+			else if (parentById.has(childId)) add({
+				code: "multiple-parents",
+				severity: "error",
+				category: "structure",
+				itemId: childId,
+				message: `Item is referenced by multiple parents.`
+			});
+			else parentById.set(childId, parent.id);
+		}
+	}
+	const roots = items.filter((item) => !parentById.has(item.id));
+	if (roots.length !== 1) add({
+		code: "root-count",
+		severity: "error",
+		category: "structure",
+		message: `Expected one survey root but found ${roots.length}.`
+	});
+	for (const parent of items) {
+		const siblingKeys = /* @__PURE__ */ new Map();
+		for (const childId of strings(isRecord(parent.config) ? parent.config.items : void 0)) {
+			const child = itemsById.get(childId);
+			if (!child) continue;
+			const existing = siblingKeys.get(child.key);
+			if (existing) add({
+				code: "duplicate-sibling-key",
+				severity: "error",
+				category: "structure",
+				itemId: child.id,
+				message: `Key "${child.key}" duplicates sibling "${existing}".`
+			});
+			siblingKeys.set(child.key, child.id);
+		}
+	}
+	const locales = context.inspection.locales;
+	const sourceLocale = options.sourceLocale ?? context.ui.selectedLocale ?? locales[0];
+	const targetLocales = options.targetLocales ?? locales.filter((locale) => locale !== sourceLocale);
+	const manifests = new Map(context.capabilities.itemTypes.map((entry) => [entry.itemType, entry]));
+	for (const item of items) {
+		const manifest = manifests.get(item.itemType);
+		if (!manifest) {
+			add({
+				code: "unsupported-item-type",
+				severity: "warning",
+				category: "structure",
+				itemId: item.id,
+				message: `Item type "${item.itemType}" is not advertised by the active editor.`
+			});
+			continue;
+		}
+		for (const surface of manifest.contentSurfaces.filter((entry) => entry.requiredOnCreate && !entry.pattern)) if (!translationText(context, sourceLocale, item.id, surface.key)) add({
+			code: "missing-primary-content",
+			severity: "warning",
+			category: "content",
+			itemId: item.id,
+			locale: sourceLocale,
+			contentKey: surface.key,
+			message: `Required respondent content "${surface.key}" is empty in ${sourceLocale}.`
+		});
+		const sourceContent = isRecord(context.survey.translations?.[sourceLocale]?.itemTranslations?.[item.id]) ? context.survey.translations?.[sourceLocale]?.itemTranslations?.[item.id] : {};
+		for (const [contentKey, content] of Object.entries(sourceContent ?? {})) {
+			if (!getContentPlainText(content).trim()) continue;
+			for (const locale of targetLocales) if (!translationText(context, locale, item.id, contentKey)) add({
+				code: "missing-translation",
+				severity: "warning",
+				category: "localization",
+				itemId: item.id,
+				locale,
+				contentKey,
+				message: `Content "${contentKey}" has source text but no ${locale} translation.`
+			});
+		}
+		const config = isRecord(item.config) ? item.config : {};
+		if (item.itemType === "choiceItem") {
+			const optionsList = records(config.options);
+			if (optionsList.length === 0) add({
+				code: "choice-without-options",
+				severity: "error",
+				category: "content",
+				itemId: item.id,
+				message: "Choice item has no options."
+			});
+			for (const option of optionsList) {
+				if (typeof option.id === "string" && !translationText(context, sourceLocale, item.id, `options.${option.id}.label`)) add({
+					code: "missing-option-label",
+					severity: "warning",
+					category: "content",
+					itemId: item.id,
+					locale: sourceLocale,
+					contentKey: `options.${option.id}.label`,
+					message: `Choice option "${option.id}" has no visible label.`
+				});
+				if (typeof option.id === "string" && option.embeddedForm) {
+					for (const group of getGroups(item, option.id)) for (const field of records(group.fields)) if (typeof field.id === "string" && !translationText(context, sourceLocale, item.id, `embeddedForms.${option.id}.fields.${field.id}.label`)) add({
+						code: "missing-field-label",
+						severity: "warning",
+						category: "content",
+						itemId: item.id,
+						locale: sourceLocale,
+						contentKey: `embeddedForms.${option.id}.fields.${field.id}.label`,
+						message: `Embedded field "${field.id}" has no visible label.`
+					});
+				}
+			}
+		}
+		if (item.itemType === "formItem") {
+			const groups = getGroups(item);
+			if (groups.length === 0) add({
+				code: "form-without-groups",
+				severity: "error",
+				category: "content",
+				itemId: item.id,
+				message: "Form item has no field groups."
+			});
+			for (const group of groups) for (const field of records(group.fields)) if (typeof field.id === "string" && !translationText(context, sourceLocale, item.id, `fields.${field.id}.label`)) add({
+				code: "missing-field-label",
+				severity: "warning",
+				category: "content",
+				itemId: item.id,
+				locale: sourceLocale,
+				contentKey: `fields.${field.id}.label`,
+				message: `Form field "${field.id}" has no visible label.`
+			});
+		}
+	}
+	const assets = context.survey.assets ?? {};
+	for (const [assetId, asset] of Object.entries(assets)) {
+		const metadata = isRecord(asset.metadata) ? asset.metadata : {};
+		if (asset.kind === "image" && typeof metadata.alt !== "string") add({
+			code: "missing-image-alt",
+			severity: "warning",
+			category: "assets",
+			message: `Image asset "${assetId}" has no alternative text.`,
+			suggestion: "Add concise alt text, or an empty alt value when the image is purely decorative."
+		});
+	}
+	const limited = findings.slice(0, options.maxFindings ?? 200);
+	return {
+		summary: limited.reduce((acc, entry) => {
+			acc[entry.severity] += 1;
+			acc.total += 1;
+			return acc;
+		}, {
+			error: 0,
+			warning: 0,
+			info: 0,
+			total: 0
+		}),
+		metrics: {
+			itemCount: items.length,
+			localeCount: locales.length,
+			responseSlotCount: context.inspection.responseSlots.length,
+			assetCount: Object.keys(assets).length,
+			itemTypes
+		},
+		findings: limited,
+		qualityReviewPrinciples: QUALITY_PRINCIPLES,
+		note: "Technical findings are deterministic. Quality principles are a structured review rubric; apply them with human/model judgment and domain context, and do not present them as psychometric validation."
+	};
+};
+//#endregion
+export { deriveResponseSlotTypes as $, getRawSurvey$1 as A, resolveItemSummary as B, clampLimit as C, formFieldGroupLayoutSchema as D, formFieldGroupDetailsSchema as E, mapKeyIndexById as F, summarizeKeyIndexEntry as G, summarizeFocusItemNode as H, mapOutlineById as I, translationEntrySchema as J, summarizeOutlineNode as K, mapRawItemsById as L, itemConfigDetailsSchema as M, itemMatchesQuery as N, formSelectOptionDetailsSchema as O, itemSummarySchema as P, createSurveyAssistantEngineContext as Q, normalizeText as R, choiceOptionDetailsSchema as S, formFieldDetailsSchema as T, summarizeItemById as U, sliceWithCursor as V, summarizeKeyIndexEntries as W, inferExpressionReturnType as X, unique as Y, validateExpression as Z, buildConfigSearchText as _, SURVEY_CHANGE_CONTINUATION_MODES as a, buildItemTranslationEntries as b, buildSurveyDocumentVersion as c, normalizeSurveyChangeOperations as d, buildExpressionMutationPatches as f, MAX_LIMIT as g, DEFAULT_LIMIT as h, SURVEY_CHANGE_CONTINUATION_DESCRIPTION as i, getRawSurveyItems as j, getKeyIndexEntries as k, createSurveyChangeSet as l, expressionSchema as m, SurveyAssistantTaskResultCache as n, TurnChangeCollector as o, expressionMutationSchema as p, summarizeRawItem as q, buildSurveyAssistantTaskContext as r, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL as s, auditSurvey as t, validateSurveyOperations as u, buildEmbeddedFormDetails as v, findDirectChildrenByFullKey as w, buildSurveyTranslations as x, buildItemConfigDetails as y, parseCursor as z };
+
+//# sourceMappingURL=engine-sPvuixWg.mjs.map