@case-framework/survey-assistant 0.8.0 → 0.9.0

package/dist/engine-D950TfvC.mjs

@@ -0,0 +1,3098 @@
+import { f as surveyChangeSetSchema, l as surveyAssistantTurnFinalSchema } from "./protocol-BQ7uIDYT.mjs";
+import { B as elementTransportSchema, H as surveyContentSchema, T as surveyOperationSchema, V as jsonValueSchema } from "./capabilities-D55dq-fO.mjs";
+import { stableStringify } from "./digest.mjs";
+import { a as assertSurveyAssistantCapabilities, n as defaultSurveyAssistantCapabilitySet } from "./default-D22AKTqE.mjs";
+import { z } from "zod";
+import { ContentType, DefinitionError, JsonPatchError, Survey, SurveyStateGraph, annotatedReferences, applyJsonPatch, collectExpressionDependencies, contentOwnerIds, encodeJsonPointerSegment, expressionIssues, expressionSchema, expressionSchema as expressionSchema$1, functionTypeIssues, generateId, getContentPlainText, getDefaultProjectionIssues, getDefinitionDiagnostics, getLocalizationEntryKey, hasLocalizationText, inferExpressionReturnType, inferExpressionReturnType as inferExpressionReturnType$1, inspectAnnotated, isContentEmpty, listLocalizationEntries, ownValue, ownerAtPath, parseJsonPointer, readLocalizationContent, resolveElementName, setOwnValue, slotPrefillSchema, stringRecord, templateValueSchema, transformExpression, unreachable, validationRuleSchema } from "@case-framework/survey-core";
+import { defaultElementRegistry } from "@case-framework/survey-items";
+import { SurveyEditor, getAnswerTypeChangeDiagnostics } from "@case-framework/survey-core/editor";
+//#region src/engine/survey-model.ts
+/** One trusted headless definition registry, shared with the editor/player/exporter.
+* Unknown types reject; serialized capabilities never install slot or runtime behavior.
+*/
+function createAssistantSurvey(raw, capabilities) {
+	const registry = capabilities?.registry ?? defaultElementRegistry;
+	return Survey.parse(raw, registry, { admission: "draft" });
+}
+function getAssistantVisibilityIssues(survey) {
+	try {
+		new SurveyStateGraph(survey, { admission: "draft" });
+		return [];
+	} catch (error) {
+		return error instanceof DefinitionError ? [...error.diagnostics] : [{
+			severity: "error",
+			code: "invalid-expression-graph",
+			path: [],
+			message: error instanceof Error ? error.message : String(error)
+		}];
+	}
+}
+function getAssistantResponseSchemaIssues(raw, capabilities) {
+	try {
+		const survey = createAssistantSurvey(raw, capabilities);
+		return [...getAssistantVisibilityIssues(survey), ...getDefaultProjectionIssues(survey).map((message) => ({
+			severity: "error",
+			code: "invalid-response-export",
+			message
+		}))];
+	} catch (error) {
+		return error instanceof DefinitionError ? [...error.diagnostics] : [{
+			severity: "error",
+			code: "invalid-response-schema",
+			message: error instanceof Error ? error.message : String(error)
+		}];
+	}
+}
+//#endregion
+//#region src/engine/context.ts
+const getChildIds = (item) => item.itemType === "group" ? item.config.items : [];
+const deriveResponseSlotTypes = (survey, trustedCapabilities) => Object.fromEntries(createAssistantSurvey(survey, trustedCapabilities).slots.definitions.map((slot) => [slot.slotId, slot.valueType]));
+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 model = createAssistantSurvey(snapshot.survey, trustedCapabilities);
+	const name = (id) => model.resolveItemEditorName(id, snapshot.ui.selectedLocale);
+	const getNamePath = (id) => {
+		const names = [name(id)];
+		const seen = /* @__PURE__ */ new Set([id]);
+		let parent = parentById.get(id);
+		while (parent && !seen.has(parent)) {
+			seen.add(parent);
+			names.unshift(name(parent));
+			parent = parentById.get(parent);
+		}
+		return names;
+	};
+	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,
+			editorName: name(item.id),
+			breadcrumb: getNamePath(itemId).join(" / "),
+			itemLabel: item.metadata?.itemLabel,
+			childCount: getChildIds(item).length
+		});
+		for (const childId of getChildIds(item)) visit(childId, depth + 1);
+	};
+	const explicitRoot = rawItems.find((item) => item.itemType === "group" && 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 itemIndex = outline.map((node) => ({
+		itemId: node.itemId,
+		itemType: node.itemType,
+		editorName: node.editorName,
+		breadcrumb: node.breadcrumb,
+		itemLabel: node.itemLabel,
+		path: getNamePath(node.itemId)
+	}));
+	const buildFocusNode = (itemId, budget) => {
+		const item = itemsById.get(itemId);
+		budget.remaining -= 1;
+		const owners = [...model.owners.values()].filter((owner) => owner.itemId === itemId);
+		const translationSnippets = Object.entries(model.data.translations ?? {}).flatMap(([locale, translations]) => owners.flatMap((owner) => Object.entries(ownValue(translations.content, owner.id) ?? {}).map(([role, content]) => ({
+			locale,
+			ownerId: owner.id,
+			role,
+			text: getContentPlainText(content).slice(0, 120)
+		})))).slice(0, 40);
+		return {
+			itemId,
+			itemType: item.itemType,
+			editorName: name(item.id),
+			breadcrumb: getNamePath(itemId).join(" / "),
+			itemLabel: item.metadata?.itemLabel,
+			siblingNames: rawItems.filter((candidate) => candidate.id !== itemId && parentById.get(candidate.id) === parentById.get(itemId)).map((candidate) => name(candidate.id)),
+			translations: translationSnippets,
+			elements: [...model.elements.values()].filter((element) => element.itemId === itemId).map((element) => ({
+				elementId: element.node.id,
+				elementType: element.node.elementType,
+				owners: owners.filter((owner) => owner.elementId === element.node.id)
+			})),
+			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 = Object.fromEntries(model.slots.definitions.map((slot) => [slot.slotId, slot.valueType]));
+	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: snapshot.survey.metadata?.surveyKey,
+			locales,
+			itemCount: rawItems.filter((item) => item.id !== explicitRoot?.id).length,
+			outline,
+			focus,
+			focusItem,
+			itemIndex,
+			responseSlots: model.slots.definitions.map((slot) => slot.slotId),
+			focusItemTreeTruncated
+		},
+		model,
+		responseSlotTypes,
+		responseVariables: model.slots.definitions
+	};
+};
+const createSurveyAssistantEngineContext = (document, trustedCapabilities, options) => {
+	assertSurveyAssistantCapabilities({
+		manifest: document.capabilities,
+		trustedCapabilities,
+		versionDigest: document.version.capabilityDigest
+	});
+	const { inspection, model, responseSlotTypes, responseVariables } = buildDerivedContext(document, trustedCapabilities, options?.focusItemId);
+	return {
+		document,
+		version: document.version,
+		survey: model.serialize(),
+		model,
+		ui: document.ui,
+		capabilities: document.capabilities,
+		responseSlotTypes,
+		responseVariables,
+		inspection,
+		trustedCapabilities
+	};
+};
+//#endregion
+//#region src/engine/expression-validation.ts
+const validateExpression = ({ expression, expectedReturnType, issues, operationIndex, responseSlotTypes, stateTargets, scope }) => {
+	const report = (code, message) => issues.push({
+		severity: "error",
+		code,
+		message: `${scope}: ${message}`,
+		operationIndex
+	});
+	if (!expression) {
+		report("missing-expression", "An expression is required.");
+		return;
+	}
+	const parsed = expressionSchema.safeParse(expression);
+	if (!parsed.success) {
+		report("invalid-expression", `Invalid expression JSON: ${parsed.error.message}`);
+		return;
+	}
+	for (const dependency of collectExpressionDependencies(parsed.data)) switch (dependency.kind) {
+		case "answer":
+			if (!Object.hasOwn(responseSlotTypes, dependency.slotId)) report("unknown-response-ref", `Unknown response slot "${dependency.slotId}". Inspect response slots before using it.`);
+			break;
+		case "state":
+			if (!stateTargets.has(dependency.targetRef.ownerId)) report("unknown-state-ref", `Unknown disabled-state owner "${dependency.targetRef.ownerId}". Inspect structural owners before using it.`);
+			break;
+		default: unreachable(dependency);
+	}
+	for (const issue of expressionIssues(parsed.data)) report("expression-function-signature-mismatch", `${issue.message} at ${JSON.stringify(issue.path)}.`);
+	transformExpression(parsed.data, {
+		const: (node) => node,
+		responseVariable: (node) => node,
+		ownerState: (node) => node,
+		contextVariable: (node) => node,
+		function: (node, path) => {
+			functionTypeIssues(node, responseSlotTypes).forEach((message) => report("expression-function-signature-mismatch", `${message} at ${JSON.stringify(path)}.`));
+			return node;
+		}
+	});
+	const inferred = inferExpressionReturnType(parsed.data, responseSlotTypes);
+	if (expectedReturnType && inferred && inferred !== expectedReturnType) report("expression-return-type-mismatch", `Must return ${expectedReturnType}, but this expression returns ${inferred}.`);
+};
+//#endregion
+//#region src/engine/definition-diagnostics.ts
+const getDiagnosticLocation = (survey, path, ownerId) => {
+	const owner = ownerId ? survey.owners.get(ownerId) : path ? ownerAtPath(survey, path) : void 0;
+	return owner && path && owner.path.every((part, index) => part === path[index]) ? {
+		ownerId: owner.id,
+		path: path.slice(owner.path.length)
+	} : { path };
+};
+const getIntroducedDefinitionIssues = (before, after, locale) => {
+	const key = (survey, issue) => stableStringify([
+		issue.code,
+		getDiagnosticLocation(survey, issue.path, issue.ownerId),
+		issue.message
+	]);
+	const prior = new Set(getDefinitionDiagnostics(before, locale).map((issue) => key(before, issue)));
+	return getDefinitionDiagnostics(after, locale).filter((issue) => !prior.has(key(after, issue))).map((issue) => ({
+		severity: issue.severity,
+		code: issue.code,
+		message: issue.kind === "reference" ? `${JSON.stringify(issue.path)}: ${issue.message}. Repair or remove this reference in the same change.` : issue.message,
+		itemId: issue.ownerItemId
+	}));
+};
+//#endregion
+//#region src/engine/expression-reference-integrity.ts
+/** Includes the same answer/state/dependency/quality checks the editor presents. */
+const analyzeSurveyAssistantExpressionReferences = (survey, trustedCapabilities, locale) => {
+	try {
+		return getDefinitionDiagnostics(createAssistantSurvey(survey, trustedCapabilities), locale);
+	} catch (error) {
+		if (error instanceof DefinitionError) return [...error.diagnostics];
+		return [{
+			severity: "error",
+			code: "invalid-survey-schema",
+			path: [],
+			message: error instanceof Error ? error.message : String(error)
+		}];
+	}
+};
+const getSurveyAssistantExpressionDiagnosticGuidance = (diagnostic) => {
+	if (diagnostic.kind === "reference") return "This reference points at content that no longer exists, usually after the author deleted or changed it. Inspect the owning item, current response slots and options, then retarget it to the intended replacement or remove the dependent condition, rule, prefill or setting if it no longer applies. Do not guess a replacement from spelling.";
+	if (diagnostic.code.includes("cycle")) return "Break the answer/state dependency cycle using an independent controlling answer or recorded context. A child inherits its ancestors' disabled state; prefills do not break cycles.";
+	if (diagnostic.code === "external-checkbox-lock") return "Use visibility for answers that stop applying. Disabled checkboxes keep selected values and cannot be unticked. Use selected-and-enabled only when inherited locking should also exclude the option from this expression.";
+	return diagnostic.severity === "error" ? "Repair this located definition error using current owner and slot IDs before claiming success." : "Review this author warning in the selected language; preserve intentional survey logic.";
+};
+//#endregion
+//#region src/engine/expression-mutations.ts
+const id = z.string().min(1);
+const expressionMutationSchema = z.discriminatedUnion("kind", [
+	z.strictObject({
+		kind: z.literal("set-condition"),
+		ownerId: id,
+		property: z.enum(["visibility", "disabled"]),
+		expression: expressionSchema
+	}),
+	z.strictObject({
+		kind: z.literal("clear-condition"),
+		ownerId: id,
+		property: z.enum(["visibility", "disabled"])
+	}),
+	z.strictObject({
+		kind: z.literal("set-config-expression"),
+		elementId: id,
+		path: z.string().startsWith("/"),
+		expression: expressionSchema
+	}),
+	z.strictObject({
+		kind: z.literal("clear-config-expression"),
+		elementId: id,
+		path: z.string().startsWith("/")
+	}),
+	z.strictObject({
+		kind: z.literal("set-validation-rule"),
+		itemId: id,
+		rule: validationRuleSchema
+	}),
+	z.strictObject({
+		kind: z.literal("remove-validation-rule"),
+		itemId: id,
+		ruleId: id
+	}),
+	z.strictObject({
+		kind: z.literal("set-prefill"),
+		elementId: id,
+		slotId: id,
+		prefill: slotPrefillSchema
+	}),
+	z.strictObject({
+		kind: z.literal("clear-prefill"),
+		elementId: id,
+		slotId: id,
+		prefillId: id
+	}),
+	z.strictObject({
+		kind: z.literal("set-template-value"),
+		templateKey: id,
+		templateValue: templateValueSchema
+	}),
+	z.strictObject({
+		kind: z.literal("clear-template-value"),
+		templateKey: id
+	})
+]);
+const pointer$1 = (path) => path.length ? `/${path.map((part) => encodeJsonPointerSegment(String(part))).join("/")}` : "";
+const readAt = (root, path) => path.reduce((value, part) => value && typeof value === "object" ? value[part] : void 0, root);
+const isLiteral = (value) => typeof value === "number" || typeof value === "string";
+/** Compile against the exact trusted registry and one detached accepted revision.
+* Conditions are located through annotated owners, including custom components.
+* Only the final batch graph is compiled, so a multi-step cycle repair is atomic.
+* The turn draft and normal editor apply path remain responsible for publishing.
+*/
+function buildExpressionMutationBatch(mutations, definition) {
+	const issues = [];
+	const patches = [];
+	let working = definition;
+	for (const [operationIndex, input] of mutations.entries()) {
+		const pending = [];
+		const report = (code, message, severity = "error") => issues.push({
+			severity,
+			code,
+			message,
+			operationIndex
+		});
+		const put = (path, value) => pending.push({
+			op: "add",
+			path: pointer$1(path),
+			value: jsonValueSchema.parse(value)
+		});
+		const remove = (path, exists) => exists ? pending.push({
+			op: "remove",
+			path: pointer$1(path)
+		}) : report("expression-location-already-empty", `${pointer$1(path)} is already empty.`, "warning");
+		const check = (expression, scope, expectedReturnType) => validateExpression({
+			expression,
+			scope,
+			expectedReturnType,
+			issues,
+			operationIndex,
+			responseSlotTypes: Object.fromEntries(working.slots.definitions.map((slot) => [slot.slotId, slot.valueType])),
+			stateTargets: new Set(working.owners.keys())
+		});
+		try {
+			const mutation = expressionMutationSchema.parse(input);
+			switch (mutation.kind) {
+				case "set-config-expression":
+				case "clear-config-expression": {
+					const element = working.elements.get(mutation.elementId);
+					if (!element) throw new Error(`Unknown element "${mutation.elementId}".`);
+					const path = [
+						...element.path,
+						"config",
+						...parseJsonPointer(mutation.path)
+					];
+					const location = pointer$1(path);
+					const boundPath = path.at(-1) === "expression" ? path.slice(0, -1) : void 0;
+					const bound = boundPath && readAt(working.serialize(), boundPath);
+					const declaredBound = !!boundPath && inspectAnnotated(working.registry.elementSchema, element.node).some((visit) => visit.annotation.kind === "bound" && pointer$1([...element.path, ...visit.path]) === pointer$1(boundPath));
+					if (mutation.kind === "set-config-expression") {
+						check(mutation.expression, `element ${mutation.elementId} config ${mutation.path}`);
+						if (boundPath && (bound === void 0 || declaredBound && isLiteral(bound))) put(boundPath, {
+							expression: mutation.expression,
+							...bound === void 0 ? {} : { fallback: bound }
+						});
+						else put(path, mutation.expression);
+						if (!Survey.parse(applyJsonPatch(working.serialize(), pending), working.registry, { admission: "draft" }).expressions.some((entry) => pointer$1(entry.path) === location)) throw new Error(`Config path "${mutation.path}" is not a registered expression field.`);
+					} else {
+						if (!working.expressions.some((entry) => pointer$1(entry.path) === location)) throw new Error(`Config path "${mutation.path}" does not contain a registered expression field.`);
+						const fallback = declaredBound ? bound.fallback : void 0;
+						if (boundPath && declaredBound) if (isLiteral(fallback)) put(boundPath, fallback);
+						else remove(boundPath, true);
+						else remove(path, true);
+					}
+					break;
+				}
+				case "set-condition":
+				case "clear-condition": {
+					const owner = working.owners.get(mutation.ownerId);
+					if (!owner) throw new Error(`Unknown structural owner "${mutation.ownerId}". Inspect owners before editing a condition.`);
+					const path = [...owner.path, mutation.property];
+					if (mutation.kind === "set-condition") {
+						check(mutation.expression, `${mutation.property} of ${mutation.ownerId}`, "boolean");
+						put(path, mutation.expression);
+					} else remove(path, owner[mutation.property] !== void 0);
+					break;
+				}
+				case "set-validation-rule":
+				case "remove-validation-rule": {
+					const item = working.flowItems.get(mutation.itemId);
+					const owner = working.owners.get(mutation.itemId);
+					if (!item || item.itemType !== "content" || !owner) throw new Error(`Validation rules require a content item: "${mutation.itemId}".`);
+					const path = [
+						...owner.path,
+						"config",
+						"validationRules"
+					];
+					const rules = [...item.config.validationRules ?? []];
+					const ruleId = mutation.kind === "set-validation-rule" ? mutation.rule.id : mutation.ruleId;
+					const index = rules.findIndex((rule) => rule.id === ruleId);
+					if (mutation.kind === "set-validation-rule") {
+						check(mutation.rule.expression, `validation ${ruleId}`, "boolean");
+						if (mutation.rule.when) check(mutation.rule.when, `validation ${ruleId} condition`, "boolean");
+						if (index < 0) rules.push(mutation.rule);
+						else rules[index] = mutation.rule;
+						put(path, rules);
+					} else if (index >= 0) {
+						remove([...path, index], true);
+						for (const [locale, translations] of Object.entries(working.data.translations ?? {})) if (Object.hasOwn(translations.content, ruleId)) remove([
+							"translations",
+							locale,
+							"content",
+							ruleId
+						], true);
+					} else report("expression-location-already-empty", `Validation "${ruleId}" is already absent.`, "warning");
+					break;
+				}
+				case "set-prefill":
+				case "clear-prefill": {
+					const element = working.elements.get(mutation.elementId);
+					const slot = working.slots.get(mutation.slotId);
+					if (!element || !slot || slot.elementId !== mutation.elementId || slot.computed) throw new Error(`Prefill target "${mutation.slotId}" must be a stored slot owned by element "${mutation.elementId}".`);
+					const prefills = structuredClone(element.node.prefills ?? {});
+					const entries = ownValue(prefills, mutation.slotId) ?? [];
+					const prefillId = mutation.kind === "set-prefill" ? mutation.prefill.id : mutation.prefillId;
+					const index = entries.findIndex((prefill) => prefill.id === prefillId);
+					if (mutation.kind === "set-prefill") {
+						if (mutation.prefill.when) check(mutation.prefill.when, `prefill ${prefillId} condition`, "boolean");
+						if (mutation.prefill.source.type === "expression") check(mutation.prefill.source.expression, `prefill ${prefillId} value`, slot.valueType);
+						if (index < 0) entries.push(mutation.prefill);
+						else entries[index] = mutation.prefill;
+					} else if (index >= 0) entries.splice(index, 1);
+					else report("expression-location-already-empty", `Prefill "${prefillId}" is already absent.`, "warning");
+					if (entries.length) setOwnValue(prefills, mutation.slotId, entries);
+					else delete prefills[mutation.slotId];
+					put([...element.path, "prefills"], prefills);
+					break;
+				}
+				case "set-template-value":
+				case "clear-template-value":
+					if (mutation.kind === "set-template-value") {
+						if (mutation.templateValue.expression) check(mutation.templateValue.expression, `template ${mutation.templateKey}`, mutation.templateValue.type === "formatDate" ? "date" : mutation.templateValue.returnType);
+						put(["templateValues"], {
+							...working.data.templateValues,
+							[mutation.templateKey]: mutation.templateValue
+						});
+					} else remove(["templateValues", mutation.templateKey], Object.hasOwn(working.data.templateValues ?? {}, mutation.templateKey));
+					break;
+				default: unreachable(mutation);
+			}
+			if (issues.some((issue) => issue.severity === "error")) return {
+				issues,
+				patches: []
+			};
+			working = Survey.parse(applyJsonPatch(working.serialize(), pending), definition.registry, { admission: "draft" });
+			patches.push(...pending);
+		} catch (error) {
+			report("expression-mutation-transition-failed", error instanceof Error ? error.message : String(error));
+			return {
+				issues,
+				patches: []
+			};
+		}
+	}
+	try {
+		new SurveyStateGraph(working, { admission: "draft" });
+	} catch (error) {
+		issues.push({
+			severity: "error",
+			code: "invalid-expression-graph",
+			message: error instanceof Error ? error.message : String(error)
+		});
+		return {
+			issues,
+			patches: []
+		};
+	}
+	return {
+		issues,
+		patches
+	};
+}
+//#endregion
+//#region src/engine/inspection.ts
+const DEFAULT_LIMIT = 12;
+const MAX_LIMIT = 50;
+const itemSummarySchema = z.object({
+	itemId: z.string(),
+	itemType: z.string(),
+	editorName: z.string(),
+	breadcrumb: 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(),
+	siblingNames: z.array(z.string()).optional()
+});
+const translationEntrySchema = z.object({
+	locale: z.string(),
+	ownerId: z.string(),
+	role: z.string(),
+	text: z.string()
+});
+const schemaPath = z.array(z.union([z.string(), z.number()]));
+const contentOwnerDetailsSchema = z.object({
+	ownerId: z.string(),
+	kind: z.string(),
+	position: z.number().int().positive().optional(),
+	parentId: z.string().optional(),
+	elementId: z.string().optional(),
+	path: schemaPath,
+	roles: z.array(z.object({
+		role: z.string(),
+		policy: z.enum(["inline", "block"]),
+		recommended: z.boolean().optional()
+	})),
+	visibility: z.boolean(),
+	disabled: z.boolean(),
+	followUpTriggerId: z.string().optional()
+});
+const elementDetailsSchema = z.object({
+	elementId: z.string(),
+	elementType: z.string(),
+	position: z.number().int().positive().optional(),
+	path: schemaPath,
+	configPath: z.string(),
+	config: jsonValueSchema,
+	responseSlotIds: z.array(z.string()),
+	owners: z.array(contentOwnerDetailsSchema)
+});
+const itemConfigDetailsSchema = z.object({
+	kind: z.enum([
+		"content",
+		"group",
+		"page-break"
+	]),
+	summary: z.array(z.string()),
+	listOrdering: stringRecord(z.string(), z.string()),
+	elements: z.array(elementDetailsSchema),
+	owners: z.array(contentOwnerDetailsSchema),
+	bodyLocations: z.array(z.object({
+		ownerId: z.string(),
+		path: schemaPath,
+		followUp: z.boolean()
+	}))
+});
+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 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 mapItemIndexById = (snapshot) => new Map(snapshot.inspection.itemIndex.map((item) => [item.itemId, item]));
+/** The full-survey item index, regardless of the (possibly focus-scoped) outline. */
+const getItemIndexEntries = (snapshot) => snapshot.inspection.itemIndex;
+const getRawSurvey = (snapshot) => snapshot.survey;
+const getRawSurveyItems = (snapshot) => snapshot.survey.surveyItems;
+const mapRawItemsById = (snapshot) => new Map(getRawSurveyItems(snapshot).map((item) => [item.id, item]));
+const summarizeRawItem = (item) => ({
+	itemId: item.id,
+	itemType: item.itemType,
+	editorName: item.metadata?.itemLabel?.trim() || item.id,
+	breadcrumb: item.id,
+	itemLabel: item.metadata?.itemLabel
+});
+const buildItemTranslationEntries = (snapshot, itemId, input) => {
+	const localeFilter = input.locales?.length ? new Set(input.locales) : void 0;
+	const textLimit = input.textLimit ?? 400;
+	const entries = [];
+	const owners = [...snapshot.model.owners.values()].filter((owner) => owner.itemId === itemId);
+	for (const [locale, translations] of Object.entries(snapshot.model.data.translations ?? {})) {
+		if (localeFilter && !localeFilter.has(locale)) continue;
+		for (const owner of owners) for (const [role, content] of Object.entries(ownValue(translations.content, owner.id) ?? {})) {
+			const text = getContentPlainText(content).trim();
+			if (text) entries.push({
+				locale,
+				ownerId: owner.id,
+				role,
+				text: text.length > textLimit ? `${text.slice(0, textLimit)}...` : text
+			});
+		}
+	}
+	return entries;
+};
+const summarizeOutlineNode = (node) => ({
+	itemId: node.itemId,
+	itemType: node.itemType,
+	editorName: node.editorName,
+	breadcrumb: node.breadcrumb,
+	itemLabel: node.itemLabel,
+	parentId: node.parentId,
+	depth: node.depth,
+	childCount: node.childCount
+});
+const summarizeItemIndexEntry = (entry, outlineById) => {
+	const outlineNode = outlineById.get(entry.itemId);
+	return {
+		itemId: entry.itemId,
+		itemType: entry.itemType,
+		editorName: entry.editorName,
+		breadcrumb: entry.breadcrumb,
+		itemLabel: entry.itemLabel,
+		parentId: outlineNode?.parentId,
+		depth: outlineNode?.depth,
+		childCount: outlineNode?.childCount,
+		path: entry.path
+	};
+};
+const summarizeItemIndexEntries = (entries, outlineById) => entries.map((entry) => summarizeItemIndexEntry(entry, outlineById));
+/** Components and follow-ups come from the registry's declared ownership, not type-name scanners. */
+const buildItemConfigDetails = (item, model) => {
+	const owners = [...model.owners.values()].filter((owner) => owner.itemId === item.id).map((owner) => ({
+		ownerId: owner.id,
+		kind: owner.kind,
+		position: owner.kind !== "item" && typeof owner.path.at(-1) === "number" ? Number(owner.path.at(-1)) + 1 : void 0,
+		parentId: owner.parentId,
+		elementId: owner.elementId,
+		path: [...owner.path],
+		roles: [...owner.roles],
+		visibility: owner.visibility !== void 0,
+		disabled: owner.disabled !== void 0,
+		followUpTriggerId: owner.followUpTriggerId
+	}));
+	const elements = [...model.elements.values()].filter((element) => element.itemId === item.id).map((element) => ({
+		elementId: element.node.id,
+		elementType: element.node.elementType,
+		position: typeof element.path.at(-1) === "number" ? Number(element.path.at(-1)) + 1 : void 0,
+		path: [...element.path],
+		configPath: `/${[...element.path, "config"].map((part) => encodeJsonPointerSegment(String(part))).join("/")}`,
+		config: jsonValueSchema.parse(element.node.config),
+		responseSlotIds: element.facts.slots.map((slot) => slot.slotId),
+		owners: owners.filter((owner) => owner.elementId === element.node.id)
+	}));
+	return {
+		kind: item.itemType,
+		listOrdering: {
+			elements: "Authored depth-first traversal, including follow-ups; position is one-based within each element's own layout, not this flattened list.",
+			owners: "Declared content-owner traversal. A position is one-based within the array identified by path; consult the element's shuffle configuration before interpreting it as respondent-visible order.",
+			bodyLocations: "Authored body traversal; follow-ups stay directly under their triggering owner, not after the entire element."
+		},
+		summary: item.itemType === "content" ? [`${elements.length} elements in vertically ordered layouts and sections`] : item.itemType === "group" ? [`${item.config.items.length} flow children`] : ["Page break"],
+		elements,
+		owners,
+		bodyLocations: [...model.bodies.values()].filter((body) => model.owners.get(body.ownerId)?.itemId === item.id).map((body) => ({
+			...body,
+			path: [...body.path]
+		}))
+	};
+};
+const buildConfigSearchText = (item, model) => {
+	const details = buildItemConfigDetails(item, model);
+	const values = [...details.summary, ...details.elements.flatMap((element) => [
+		element.elementId,
+		element.elementType,
+		JSON.stringify(element.config)
+	])];
+	for (const slot of model.slots.definitions.filter((slot) => slot.itemId === item.id)) values.push(slot.slotId, slot.variableName, ...Object.values(slot.referenceValueKeys ?? {}));
+	const itemPath = model.owners.get(item.id)?.path;
+	if (itemPath) {
+		for (const entry of model.expressions) if (itemPath.every((part, index) => entry.path[index] === part)) for (const reference of collectExpressionDependencies(entry.expression)) values.push(reference.kind === "answer" ? reference.slotId : reference.targetRef.ownerId);
+	}
+	return values;
+};
+const summarizeFocusItemNode = (node, outlineById) => {
+	const outlineNode = outlineById.get(node.itemId);
+	return {
+		itemId: node.itemId,
+		itemType: node.itemType,
+		editorName: node.editorName,
+		breadcrumb: node.breadcrumb,
+		itemLabel: node.itemLabel,
+		parentId: outlineNode?.parentId,
+		depth: outlineNode?.depth,
+		childCount: outlineNode?.childCount ?? node.descendants.length,
+		siblingNames: node.siblingNames
+	};
+};
+const summarizeItemById = (itemId, indexById, outlineById) => {
+	const outlineNode = outlineById.get(itemId);
+	if (outlineNode) return summarizeOutlineNode(outlineNode);
+	const indexEntry = indexById.get(itemId);
+	if (indexEntry) return summarizeItemIndexEntry(indexEntry, outlineById);
+};
+/** Resolve only persistent item IDs. Search can discover names and breadcrumbs. */
+const resolveItemSummary = (identifier, indexById, outlineById) => {
+	return summarizeItemById(identifier, indexById, outlineById);
+};
+const itemMatchesQuery = (item, query) => {
+	return [
+		item.itemId,
+		item.itemType,
+		item.editorName,
+		item.breadcrumb,
+		item.itemLabel,
+		...item.path ?? [],
+		...item.siblingNames ?? []
+	].filter(Boolean).join(" ").toLowerCase().includes(query);
+};
+/**
+* Direct children of `parentId` derived from the full-survey item index.
+* This works for any item, selected or not.
+*/
+const findDirectChildrenByParentId = (entries, outlineById, parentId) => {
+	return entries.filter((entry) => outlineById.get(entry.itemId)?.parentId === parentId).map((entry) => summarizeItemIndexEntry(entry, outlineById));
+};
+//#endregion
+//#region src/engine/normalization.ts
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getString = (value) => typeof value === "string" ? value.trim() : void 0;
+const textInline = (text, style) => ({
+	type: "text",
+	text,
+	...style ? { style } : {}
+});
+const paragraphBlock = (text, style) => ({
+	type: "paragraph",
+	children: [textInline(text, style)]
+});
+const parseCanonicalRichTextBlocks = (blocks) => {
+	const parsed = surveyContentSchema.safeParse({
+		type: ContentType.richText,
+		version: 1,
+		doc: {
+			type: "doc",
+			blocks
+		}
+	});
+	return parsed.success && parsed.data.type === ContentType.richText && stableStringify(parsed.data.doc.blocks) === stableStringify(blocks) ? parsed.data.doc.blocks : void 0;
+};
+const getBlockText = (block) => [
+	block.text,
+	block.content,
+	block.label
+].find((value) => typeof value === "string");
+const getShorthandHeadingLevel = (value) => {
+	if (value.level !== void 0) return value.level;
+	const typeLevel = getString(value.type)?.toLowerCase().match(/^h([1-6])$/)?.[1];
+	return typeLevel ? Number(typeLevel) : 2;
+};
+const normalizeRichTextStyle = (value) => {
+	const rawStyle = isRecord$2(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 richTextShorthandNodeTypes = {
+	"bullet-list": "bulletList",
+	bulletlist: "bulletList",
+	list: "bulletList",
+	bullets: "bulletList",
+	infobox: "infoBox",
+	"info-box": "infoBox",
+	note: "infoBox",
+	footnote: "infoBox",
+	divider: "separator",
+	rule: "separator",
+	linebreak: "lineBreak",
+	"line-break": "lineBreak",
+	break: "lineBreak",
+	listitem: "listItem",
+	inlineextension: "inlineExtension",
+	blockextension: "blockExtension"
+};
+const resolveRichTextShorthandNodeType = (value) => {
+	const type = getString(value)?.toLowerCase();
+	return type ? ownValue(richTextShorthandNodeTypes, type) ?? (/^h[1-6]$/.test(type) ? "heading" : type) : void 0;
+};
+const normalizeRichTextInline = (value, allowLink = true) => {
+	if (typeof value === "string") return textInline(value);
+	if (!isRecord$2(value)) return value;
+	const type = resolveRichTextShorthandNodeType(value.type);
+	const canonicalParagraph = parseCanonicalRichTextBlocks([{
+		type: "paragraph",
+		children: [value]
+	}])?.[0];
+	const canonicalInline = canonicalParagraph?.type === "paragraph" ? canonicalParagraph.children[0] : void 0;
+	if (canonicalInline && (allowLink || canonicalInline.type !== "link")) return canonicalInline;
+	if (type === "lineBreak") return { type: "lineBreak" };
+	if (type === "link" && allowLink) {
+		const href = getString(value.href) ?? getString(value.url);
+		if (!href) return;
+		const childValues = value.children === void 0 ? [getBlockText(value) ?? href] : value.children;
+		const children = Array.isArray(childValues) ? childValues.map((child) => normalizeRichTextInline(child, false)) : childValues;
+		return {
+			...value,
+			type: "link",
+			href,
+			children
+		};
+	}
+	if (type && type !== "text") return value;
+	const text = getBlockText(value);
+	return text === void 0 ? value : textInline(text, normalizeRichTextStyle(value));
+};
+const normalizeRichTextChildren = (value) => {
+	if (!Array.isArray(value.children)) return;
+	return value.children.map((child) => normalizeRichTextInline(child));
+};
+const normalizeRichTextParagraph = (value) => typeof value === "string" || isRecord$2(value) && (!value.type || getString(value.type)?.toLowerCase() === "paragraph") ? normalizeRichTextBlock(value) : value;
+const normalizeRichTextBlock = (value) => {
+	if (typeof value === "string") return paragraphBlock(value);
+	if (!isRecord$2(value)) return value;
+	const canonicalBlock = parseCanonicalRichTextBlocks([value])?.[0];
+	if (canonicalBlock) return canonicalBlock;
+	const type = resolveRichTextShorthandNodeType(value.type);
+	const text = getBlockText(value);
+	const style = normalizeRichTextStyle(value);
+	const children = normalizeRichTextChildren(value);
+	if (type === "heading") return {
+		...value,
+		type: "heading",
+		level: getShorthandHeadingLevel(value),
+		children: value.children !== void 0 ? children ?? value.children : text !== void 0 ? [textInline(text, style)] : void 0
+	};
+	if (type === "bulletList") {
+		if (!Array.isArray(value.items)) return value;
+		return {
+			...value,
+			type: "bulletList",
+			items: value.items.map((item) => {
+				const itemText = typeof item === "string" ? item : isRecord$2(item) ? getBlockText(item) : void 0;
+				if (isRecord$2(item) && Array.isArray(item.children)) return {
+					type: "listItem",
+					...item,
+					children: item.children.map(normalizeRichTextParagraph)
+				};
+				return itemText !== void 0 ? {
+					type: "listItem",
+					...isRecord$2(item) ? item : {},
+					children: [paragraphBlock(itemText)]
+				} : item;
+			})
+		};
+	}
+	if (type === "infoBox") return {
+		...value,
+		type: "infoBox",
+		title: typeof value.title === "string" ? [textInline(value.title)] : Array.isArray(value.title) ? value.title.map((inline) => normalizeRichTextInline(inline)) : value.title,
+		children: Array.isArray(value.children) ? value.children.map(normalizeRichTextParagraph) : value.children !== void 0 ? value.children : text !== void 0 ? [paragraphBlock(text)] : void 0
+	};
+	if (type === "image") return {
+		...value,
+		type: "image",
+		caption: Array.isArray(value.caption) ? value.caption.map(normalizeRichTextParagraph) : value.caption
+	};
+	if (type === "separator") return {
+		...value,
+		type: "separator"
+	};
+	if (type === "paragraph" || !type) {
+		if (!children && text === void 0) return value;
+		return {
+			...value,
+			type: "paragraph",
+			children: value.children !== void 0 ? children ?? value.children : [textInline(text ?? "", style)]
+		};
+	}
+	return value;
+};
+const RICH_TEXT_BODY_KEYS = [
+	"text",
+	"content",
+	"label",
+	"children",
+	"items",
+	"blocks"
+];
+const MAX_RICH_TEXT_NORMALIZATION_ISSUES = 32;
+const INSPECTABLE_RICH_TEXT_NODE_TYPES = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"bulletList",
+	"listItem",
+	"image",
+	"infoBox",
+	"separator",
+	"blockExtension",
+	"text",
+	"template",
+	"link",
+	"lineBreak",
+	"inlineExtension"
+]);
+const inspectRichTextNode = (value, path, issues, shorthand, implicitType = "paragraph", depth = 0) => {
+	if (!isRecord$2(value) || issues.length >= MAX_RICH_TEXT_NORMALIZATION_ISSUES) return;
+	const report = (field, message) => {
+		if (issues.length < MAX_RICH_TEXT_NORMALIZATION_ISSUES) issues.push({
+			path: field ? `${path}.${field}` : path,
+			message
+		});
+	};
+	if (depth > 8) {
+		report("", "Rich-text nesting exceeds the supported node structure. Use the documented block and inline grammar.");
+		return;
+	}
+	const type = shorthand ? resolveRichTextShorthandNodeType(value.type) ?? implicitType : getString(value.type);
+	if (!type || !INSPECTABLE_RICH_TEXT_NODE_TYPES.has(type)) return;
+	const textBody = type === "text" || shorthand && [
+		"paragraph",
+		"heading",
+		"infoBox",
+		"listItem",
+		"link"
+	].includes(type ?? "");
+	const acceptsChildren = [
+		"paragraph",
+		"heading",
+		"infoBox",
+		"listItem",
+		"link"
+	].includes(type ?? "");
+	const bodyKeys = RICH_TEXT_BODY_KEYS.filter((key) => value[key] !== void 0);
+	if (bodyKeys.length > 1) report("", `Conflicting rich-text body representations: ${bodyKeys.join(", ")}. Provide one body representation; preserve all intended content in it.`);
+	for (const key of bodyKeys) {
+		if (!(key === "children" ? acceptsChildren : key === "items" ? type === "bulletList" : key === "blocks" ? false : textBody && (shorthand || key === "text"))) report(key, key === "blocks" ? "Nested blocks is not a supported node body. Use children for canonical nested content, items for a bulletList, or text for a simple shorthand body." : `The ${type ?? "untyped"} node does not support the ${key} body field. Use the documented node structure; image captions use caption paragraph blocks and separators have no body.`);
+		if ([
+			"text",
+			"content",
+			"label"
+		].includes(key) && typeof value[key] !== "string") report(key, "Rich-text shorthand text must be a string. Use the documented children structure for nested content.");
+	}
+	for (const key of ["href", "url"]) if (value[key] !== void 0 && (type !== "link" || !shorthand && key === "url")) report(key, "Links must use a link inline node with href and children (or text shorthand). A URL on another node is not rendered as a link.");
+	for (const key of ["title", "caption"]) if (value[key] !== void 0 && !(key === "title" ? type === "infoBox" || type === "link" : type === "image")) report(key, `The ${type ?? "untyped"} node does not support ${key}. Use the documented node structure to preserve this content.`);
+	for (const key of [
+		"children",
+		"items",
+		"title",
+		"caption"
+	]) {
+		const children = value[key];
+		if (Array.isArray(children)) {
+			const childType = key === "items" ? "listItem" : key === "title" || key === "children" && [
+				"paragraph",
+				"heading",
+				"link"
+			].includes(type ?? "") ? "text" : "paragraph";
+			for (let index = 0; index < children.length && issues.length < MAX_RICH_TEXT_NORMALIZATION_ISSUES; index++) inspectRichTextNode(children[index], `${path}.${key}.${index}`, issues, shorthand, childType, depth + 1);
+		}
+	}
+};
+const normalizeRichTextContent = (value, path, issues) => {
+	if (!isRecord$2(value)) return value;
+	if (value.type === ContentType.richText && isRecord$2(value.doc) && value.version === 1) {
+		if (Array.isArray(value.doc.blocks)) for (let index = 0; index < value.doc.blocks.length && issues.length < MAX_RICH_TEXT_NORMALIZATION_ISSUES; index++) inspectRichTextNode(value.doc.blocks[index], `${path}.doc.blocks.${index}`, issues, false);
+		return value;
+	}
+	const candidateBlocks = Array.isArray(value.richTextBlocks) ? value.richTextBlocks : Array.isArray(value.blocks) ? value.blocks : void 0;
+	if (!candidateBlocks) return value;
+	const shorthandKey = Array.isArray(value.richTextBlocks) ? "richTextBlocks" : "blocks";
+	const issueCount = issues.length;
+	for (let index = 0; index < candidateBlocks.length && issues.length < MAX_RICH_TEXT_NORMALIZATION_ISSUES; index++) inspectRichTextNode(candidateBlocks[index], `${path}.${shorthandKey}.${index}`, issues, true);
+	if (issues.length > issueCount || issues.length >= MAX_RICH_TEXT_NORMALIZATION_ISSUES) return value;
+	const blocks = candidateBlocks.map(normalizeRichTextBlock);
+	return {
+		type: ContentType.richText,
+		version: 1,
+		doc: {
+			type: "doc",
+			blocks
+		}
+	};
+};
+const inspectTranslationRepresentations = (value, path, issues) => {
+	if (!isRecord$2(value)) return;
+	const shorthandKeys = ["richTextBlocks", "blocks"].filter((key) => Object.prototype.hasOwnProperty.call(value, key));
+	if (value.plainText !== void 0 && value.content !== void 0) issues.push({
+		path,
+		message: "Do not combine plainText with content; provide one representation."
+	});
+	if (shorthandKeys.length === 0) return;
+	if (shorthandKeys.length > 1) issues.push({
+		path,
+		message: "Provide only richTextBlocks; do not combine it with the blocks alias."
+	});
+	const shorthandKey = shorthandKeys[0];
+	const shorthand = value[shorthandKey];
+	if (!Array.isArray(shorthand)) issues.push({
+		path: `${path}.${shorthandKey}`,
+		message: `${shorthandKey} must be an array of rich-text blocks.`
+	});
+	else if (shorthand.length === 0) issues.push({
+		path: `${path}.${shorthandKey}`,
+		message: `${shorthandKey} must contain at least one block. Use an explicit canonical content value when intentionally clearing a surface.`
+	});
+	if (value.plainText !== void 0 || value.content !== void 0) issues.push({
+		path,
+		message: "Do not combine richTextBlocks with plainText or content; provide one representation."
+	});
+};
+/** Accept unambiguous model-facing shorthand without changing the canonical document grammar. */
+const normalizeSurveyChangeOperations = (operations, defaultLocale) => {
+	const issues = [];
+	const text = (value, path) => {
+		if (!isRecord$2(value)) return value;
+		const candidate = { ...value };
+		const aliases = ["text", "label"].filter((key) => Object.hasOwn(candidate, key));
+		const explicit = [
+			"plainText",
+			"content",
+			"richTextBlocks",
+			"blocks"
+		].some((key) => Object.hasOwn(candidate, key));
+		if (aliases.length > 1 || aliases.length && explicit) issues.push({
+			path,
+			message: "Provide one content representation; do not combine text/label with plainText, content or richTextBlocks."
+		});
+		else if (aliases.length === 1 && typeof candidate[aliases[0]] === "string") {
+			candidate.plainText = candidate[aliases[0]];
+			delete candidate[aliases[0]];
+		}
+		if (typeof candidate.content === "string" && candidate.plainText === void 0) {
+			candidate.plainText = candidate.content;
+			delete candidate.content;
+		}
+		inspectTranslationRepresentations(candidate, path, issues);
+		const content = normalizeRichTextContent(candidate.content ?? (Array.isArray(candidate.richTextBlocks) || Array.isArray(candidate.blocks) ? candidate : void 0), `${path}.content`, issues);
+		const { richTextBlocks: _rich, blocks: _blocks, ...rest } = candidate;
+		return {
+			...rest,
+			locale: candidate.locale ?? defaultLocale,
+			...content !== void 0 ? { content } : {}
+		};
+	};
+	const translations = (value, path) => {
+		if (Array.isArray(value)) return value.map((entry, index) => text(entry, `${path}.${index}`));
+		if (!isRecord$2(value)) return value;
+		const result = [];
+		for (const [locale, branch] of Object.entries(value)) {
+			if (!isRecord$2(branch)) {
+				issues.push({
+					path: `${path}.${locale}`,
+					message: "Expected a map of exact owner IDs and their content roles."
+				});
+				continue;
+			}
+			const owners = Object.hasOwn(branch, "content") ? branch.content : branch;
+			if (!isRecord$2(owners) || Object.hasOwn(branch, "content") && Object.keys(branch).length !== 1) {
+				issues.push({
+					path: `${path}.${locale}`,
+					message: "Use an owner-role content map only; survey-level translations need their own typed operation."
+				});
+				continue;
+			}
+			for (const [ownerId, roles] of Object.entries(owners)) {
+				if (!isRecord$2(roles)) {
+					issues.push({
+						path: `${path}.${locale}.${ownerId}`,
+						message: "Expected a map from content roles to translated values."
+					});
+					continue;
+				}
+				for (const [role, content] of Object.entries(roles)) {
+					const leafPath = `${path}.${locale}.${ownerId}.${role}`;
+					const leaf = typeof content === "string" ? { plainText: content } : content === null ? { content: null } : isRecord$2(content) && typeof content.type === "string" ? { content } : content;
+					if (!isRecord$2(leaf)) {
+						issues.push({
+							path: leafPath,
+							message: "Expected text, canonical content, richTextBlocks, or null to clear."
+						});
+						continue;
+					}
+					if ([
+						"ownerId",
+						"role",
+						"locale"
+					].some((key) => Object.hasOwn(leaf, key))) {
+						issues.push({
+							path: leafPath,
+							message: "Put ownerId, role and locale either in array entries or in map keys, not both."
+						});
+						continue;
+					}
+					result.push(text({
+						...leaf,
+						ownerId,
+						role,
+						locale
+					}, leafPath));
+				}
+			}
+		}
+		return result;
+	};
+	return {
+		operations: operations.map((value, index) => {
+			if (!isRecord$2(value)) return value;
+			const candidate = { ...value };
+			if (typeof candidate.op === "string") {
+				if (candidate.kind !== void 0 && candidate.kind !== candidate.op) issues.push({
+					path: String(index),
+					message: "Conflicting operation kind and op alias; provide one intended operation."
+				});
+				else {
+					candidate.kind = candidate.op;
+					delete candidate.op;
+				}
+			}
+			const normalized = candidate.kind === "update-content" || candidate.kind === "update-survey-translation" ? text(candidate, String(index)) : candidate;
+			if (isRecord$2(normalized) && normalized.translations !== void 0) normalized.translations = translations(normalized.translations, `${index}.translations`);
+			if (isRecord$2(normalized) && normalized.kind === "create-item" && isRecord$2(normalized.item)) {
+				const item = normalized.item;
+				if (Object.hasOwn(normalized, "itemId")) {
+					if (typeof item.id === "string" && normalized.itemId === item.id) delete normalized.itemId;
+					else issues.push({
+						path: `${index}.itemId`,
+						message: "Conflicting create-item itemId and item.id; use item.id for the new item identity."
+					});
+				}
+				if (Object.hasOwn(item, "translations")) {
+					const nested = translations(item.translations, `${index}.item.translations`);
+					const outer = normalized.translations ?? [];
+					if (Array.isArray(nested) && Array.isArray(outer)) {
+						const combined = [];
+						const byTarget = /* @__PURE__ */ new Map();
+						for (const entry of [...outer, ...nested]) {
+							if (!isRecord$2(entry) || ![
+								entry.locale,
+								entry.ownerId,
+								entry.role
+							].every((value) => typeof value === "string")) {
+								combined.push(entry);
+								continue;
+							}
+							const key = JSON.stringify([
+								entry.locale,
+								entry.ownerId,
+								entry.role
+							]);
+							if (byTarget.has(key)) {
+								if (stableStringify(byTarget.get(key)) !== stableStringify(entry)) issues.push({
+									path: `${index}.item.translations`,
+									message: `Conflicting translations for owner "${entry.ownerId}", role "${entry.role}", locale "${entry.locale}"; provide one intended value beside item.`
+								});
+								continue;
+							}
+							byTarget.set(key, entry);
+							combined.push(entry);
+						}
+						const { translations: _nested, ...canonicalItem } = item;
+						normalized.item = canonicalItem;
+						normalized.translations = combined;
+					} else issues.push({
+						path: `${index}.item.translations`,
+						message: "Creation translations must be an owner-role entry array or locale/owner/role map; put them beside item."
+					});
+				}
+			}
+			return normalized;
+		}),
+		issues
+	};
+};
+//#endregion
+//#region src/engine/reference-diagnostics.ts
+const MAX_REFERENCE_LENGTH = 256;
+const MAX_DISTANCE = 3;
+const spellingDistance = (left, right) => {
+	if (Math.abs(left.length - right.length) > MAX_DISTANCE) return Infinity;
+	let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let row = 1; row <= left.length; row++) {
+		const current = [row];
+		for (let column = 1; column <= right.length; column++) current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1));
+		if (Math.min(...current) > MAX_DISTANCE) return Infinity;
+		previous = current;
+	}
+	return previous[right.length];
+};
+const suggestExactReferences = (supplied, known) => {
+	if (supplied.length > MAX_REFERENCE_LENGTH) return [];
+	const candidates = [];
+	for (const value of new Set(known)) {
+		if (value.length > MAX_REFERENCE_LENGTH || value === supplied) continue;
+		const distance = supplied.endsWith(`.${value}`) ? 0 : spellingDistance(supplied, value);
+		if (distance <= MAX_DISTANCE) candidates.push({
+			value,
+			distance
+		});
+	}
+	candidates.sort((left, right) => left.distance - right.distance || left.value.localeCompare(right.value));
+	return candidates.filter((entry) => entry.distance === candidates[0]?.distance).slice(0, 3).map(({ value }) => value);
+};
+const formatExactReferenceSuggestions = (supplied, known, label) => {
+	const suggestions = suggestExactReferences(supplied, known);
+	return suggestions.length ? ` Similar valid ${label}: ${suggestions.map((value) => JSON.stringify(value)).join(", ")}. Confirm the intended target and copy its exact identifier.` : "";
+};
+//#endregion
+//#region src/engine/operation-execution.ts
+const pointer = (parts) => `/${parts.map((part) => encodeJsonPointerSegment(String(part))).join("/")}`;
+const buildContent = (value) => value.content === null ? void 0 : value.content ?? (value.plainText !== void 0 ? {
+	type: "plain",
+	content: value.plainText
+} : void 0);
+const metadata = {
+	label: "Assistant change",
+	source: "assistant"
+};
+/** Private validation simulation. Accepted results still enter the host's normal editor transaction. */
+var SurveyOperationExecutionSession = class {
+	editor;
+	baseline;
+	/** Identities removed while other content still referenced them. */
+	removedDependencies = /* @__PURE__ */ new Set();
+	constructor(survey, capabilities, answerTypes) {
+		this.editor = new SurveyEditor(createAssistantSurvey(survey, capabilities), { answerTypes });
+		this.baseline = this.model;
+	}
+	get model() {
+		return this.editor.survey;
+	}
+	getAnswerTypes() {
+		return this.editor.getAnswerTypes();
+	}
+	hasLocale(locale) {
+		return Object.hasOwn(this.model.data.translations ?? {}, locale);
+	}
+	writeContent(ref, value) {
+		if (ref.scope === "content") {
+			const owner = this.model.owners.get(ref.ownerId);
+			if (!owner) throw new Error(`Unknown content owner "${ref.ownerId}".${formatExactReferenceSuggestions(ref.ownerId, this.model.owners.keys(), "owner IDs")}`);
+			if (!owner.roles.some((role) => role.role === ref.role)) throw new Error(`Unknown content role "${ref.role}" on owner "${ref.ownerId}".${formatExactReferenceSuggestions(ref.role, owner.roles.map((role) => role.role), "content roles")}`);
+		}
+		this.editor.setLocalizedContent(ref, value.locale, buildContent(value), metadata);
+	}
+	translations(values) {
+		for (const entry of values ?? []) this.writeContent({
+			scope: "content",
+			ownerId: entry.ownerId,
+			role: entry.role
+		}, entry);
+	}
+	/**
+	* The editor lets people leave broken references to repair later; the assistant never does.
+	* Remember what a removal leaves dangling, so repairs may follow later in the same change.
+	*/
+	recordRemoval(id) {
+		for (const reference of this.editor.deletionImpact(id)) this.removedDependencies.add(reference.id);
+	}
+	/** Reject a change that still leaves references to content it removed. */
+	assertNoDanglingRemovals() {
+		if (!this.removedDependencies.size) return;
+		const survey = this.model;
+		const references = annotatedReferences(inspectAnnotated(survey.registry.surveySchema, survey.data)).filter((reference) => reference.path[0] !== "translations" && this.removedDependencies.has(reference.id) && !survey.identities.has(reference.id));
+		if (!references.length) return;
+		throw new DefinitionError(references.map((reference) => ({
+			severity: "error",
+			code: "deletion-has-dependencies",
+			path: [...reference.path],
+			message: `This reference to ${reference.target} "${reference.id}" depends on the content being removed. Update or remove this exact reference in the same change; inspect expression-diagnostics and the owning item for context.`
+		})));
+	}
+	patch(patches, cleanOwnedContent = false) {
+		this.editor.transact(metadata, (draft) => {
+			const patched = this.model.registry.surveySchema.parse(applyJsonPatch(draft, patches));
+			if (cleanOwnedContent) {
+				const remaining = contentOwnerIds(this.model.registry.surveySchema, patched);
+				for (const translation of Object.values(patched.translations ?? {})) for (const id of this.model.owners.keys()) if (!remaining.has(id)) delete translation.content[id];
+			}
+			for (const key of Object.keys(draft)) Reflect.deleteProperty(draft, key);
+			Object.assign(draft, patched);
+		});
+	}
+	apply(operation) {
+		this.editor.runAction(() => {
+			switch (operation.kind) {
+				case "insert-preset": throw new Error("Materialize trusted presets before executing a change set");
+				case "create-item": {
+					const parent = this.model.getItem(operation.target.parentItemId);
+					if (parent?.itemType !== "group") throw new DefinitionError([{
+						severity: "error",
+						code: "target-parent-not-found",
+						path: [],
+						message: `The target must be an existing group. Current group IDs: ${this.model.data.surveyItems.filter((item) => item.itemType === "group").map((item) => JSON.stringify(item.id)).join(", ")}.`
+					}]);
+					if (operation.target.index !== void 0 && operation.target.index > parent.config.items.length) throw new Error("Insertion index exceeds the current sibling count");
+					this.editor.addItem({
+						parentId: parent.id,
+						index: operation.target.index
+					}, operation.item);
+					this.translations(operation.translations);
+					break;
+				}
+				case "insert-element": {
+					const path = this.model.identities.get(operation.target.layoutId)?.path.slice(0, -1);
+					if (!path || this.model.identities.get(operation.target.layoutId)?.kind !== "layout") throw new Error("Unknown layout target");
+					const length = [...this.model.elements.values()].filter((element) => element.path.length === path.length + 2 && path.every((part, index) => element.path[index] === part)).length;
+					if (operation.target.index !== void 0 && operation.target.index > length) throw new Error("Insertion index exceeds the layout child count");
+					this.editor.insertElement(operation.element, operation.target, metadata);
+					this.translations(operation.translations);
+					break;
+				}
+				case "insert-blocks": {
+					const body = this.model.bodies.get(operation.bodyOwnerId);
+					if (!body) throw new Error("Unknown body owner");
+					const position = operation.index;
+					this.patch(operation.body.blocks.map((block, index) => ({
+						op: "add",
+						path: `${pointer(body.path)}/blocks/${position === void 0 ? "-" : position + index}`,
+						value: block
+					})), false);
+					this.translations(operation.translations);
+					break;
+				}
+				case "update-content":
+					this.writeContent(operation.ref, operation);
+					break;
+				case "update-survey-translation":
+					this.writeContent({
+						scope: "survey",
+						surface: operation.surface,
+						contentKey: operation.contentKey
+					}, operation);
+					break;
+				case "patch-element-config":
+					if (!this.model.elements.get(operation.elementId)) throw new Error(`Unknown element "${operation.elementId}".${formatExactReferenceSuggestions(operation.elementId, this.model.elements.keys(), "element IDs")}`);
+					this.editor.updateElement(operation.elementId, (node) => {
+						const config = applyJsonPatch(node.config, operation.patches);
+						node.config = this.model.registry.get(node.elementType).schema.parse({
+							...node,
+							config
+						}).config;
+					}, metadata);
+					this.translations(operation.translations);
+					break;
+				case "patch-item-config": {
+					const owner = this.model.owners.get(operation.itemId);
+					if (!this.model.getItem(operation.itemId) || !owner) throw new Error(`Unknown item "${operation.itemId}". Inspect current item IDs before editing.`);
+					const root = `${pointer(owner.path)}/config`;
+					this.patch(operation.patches.map((patch) => ({
+						...patch,
+						path: root + patch.path,
+						..."from" in patch ? { from: root + patch.from } : {}
+					})), true);
+					this.translations(operation.translations);
+					break;
+				}
+				case "update-item-label":
+				case "update-item-color":
+					if (!this.model.getItem(operation.itemId)) throw new Error(`Unknown item "${operation.itemId}". Inspect current item IDs before editing.`);
+					this.editor.transact(metadata, (draft) => {
+						const item = draft.surveyItems.find((item) => item.id === operation.itemId);
+						item.metadata = {
+							...item.metadata,
+							...operation.kind === "update-item-label" ? { itemLabel: operation.itemLabel } : { editorItemColor: operation.color }
+						};
+					});
+					break;
+				case "remove-item": {
+					const item = this.model.getItem(operation.itemId);
+					if (!item) throw new Error(`Unknown item "${operation.itemId}". Inspect current item IDs before editing.`);
+					if (item.itemType === "group" && item.config.items.length && !operation.includeChildren) throw new Error("Set includeChildren to remove a group and its descendants");
+					this.recordRemoval(item.id);
+					this.editor.removeItem(item.id);
+					break;
+				}
+				case "remove-content":
+					this.recordRemoval(operation.ownerId);
+					this.editor.remove(operation.ownerId);
+					break;
+				case "move-item":
+					this.editor.moveItem(operation.itemId, {
+						parentId: operation.target.parentItemId,
+						index: operation.target.index
+					}, metadata);
+					break;
+				case "reorder-items": {
+					const parent = this.model.getItem(operation.parentItemId);
+					if (parent?.itemType !== "group") throw new Error("Unknown parent group");
+					if (operation.itemIds.length !== parent.config.items.length || new Set(operation.itemIds).size !== parent.config.items.length || operation.itemIds.some((id) => !parent.config.items.includes(id))) throw new Error("Supply every existing direct child exactly once");
+					this.editor.transact(metadata, (draft) => {
+						const item = draft.surveyItems.find((item) => item.id === parent.id);
+						if (item.itemType === "group") item.config.items = [...operation.itemIds];
+					});
+					break;
+				}
+				case "move-element":
+					this.editor.moveElement(operation.elementId, operation.target.layoutId, operation.target.index, operation.ruleTransfer);
+					break;
+				case "move-block":
+					this.editor.moveBlock(operation.blockId, operation.bodyOwnerId, operation.index, operation.ruleTransfer);
+					break;
+				case "update-layout":
+					this.editor.updateLayout(operation.layoutId, operation.layout);
+					break;
+				case "update-response-settings":
+					this.editor.updateResponseSettings(operation.naming, operation.settings);
+					break;
+				case "add-survey-locale":
+					if (!this.editor.addLocale(operation.locale)) throw new DefinitionError([{
+						severity: "error",
+						code: "survey-locale-already-exists",
+						path: ["translations", operation.locale],
+						message: "The survey locale already exists"
+					}]);
+					break;
+				case "remove-survey-locale":
+					if (!this.editor.removeLocale(operation.locale)) throw new DefinitionError([{
+						severity: "error",
+						code: "survey-locale-not-found",
+						path: ["translations", operation.locale],
+						message: "Unknown survey locale"
+					}]);
+					break;
+				case "update-survey-metadata":
+					this.editor.transact(metadata, (draft) => {
+						draft.metadata ??= {};
+						for (const [key, value] of Object.entries(operation.values)) if (value === null) delete draft.metadata[key];
+						else setOwnValue(draft.metadata, key, value);
+					});
+					break;
+				case "update-survey-pagination":
+					this.editor.updateMaxItemsPerPage(operation.value ?? void 0);
+					break;
+				case "set-image-asset":
+					this.editor.setAsset(operation.assetId, operation.asset);
+					break;
+				case "update-image-asset-metadata": {
+					const asset = this.model.getAsset(operation.assetId);
+					if (!asset) throw new Error("Unknown image asset");
+					const next = structuredClone(asset);
+					next.metadata ??= {};
+					for (const [key, value] of Object.entries(operation.metadata)) if (value === null) Reflect.deleteProperty(next.metadata, key);
+					else if (value !== void 0) setOwnValue(next.metadata, key, value);
+					this.editor.setAsset(operation.assetId, next);
+					break;
+				}
+				case "remove-image-asset":
+					if (!this.model.hasAsset(operation.assetId)) throw new Error("Unknown image asset");
+					if (this.model.getAssetUsages(operation.assetId).length) throw new DefinitionError([{
+						severity: "error",
+						code: "image-asset-still-referenced",
+						path: ["assets", operation.assetId],
+						message: "Remove image placements before deleting this asset"
+					}]);
+					this.editor.removeAsset(operation.assetId);
+					break;
+				case "update-placed-image": {
+					const content = this.editor.getLocalizedContent(operation.ref, operation.locale);
+					if (content?.type !== "richText") throw new Error("Image placement is not rich text");
+					const next = structuredClone(content);
+					const image = next.doc.blocks.filter((block) => block.type === "image")[operation.imageIndex];
+					if (!image) throw new Error("Unknown image placement");
+					if (operation.expectedAssetId && (image.source.type !== "asset" || image.source.assetId !== operation.expectedAssetId)) throw new DefinitionError([{
+						severity: "error",
+						code: "placed-image-asset-mismatch",
+						path: ["imageIndex"],
+						message: "Image placement changed; inspect it again"
+					}]);
+					const changes = operation.changes;
+					if (changes.source) image.source = changes.source;
+					if (changes.alt === null) delete image.alt;
+					else if (changes.alt !== void 0) image.alt = changes.alt;
+					if (changes.caption !== void 0) {
+						if (!changes.caption) delete image.caption;
+						else image.caption = [{
+							type: "paragraph",
+							children: [{
+								type: "text",
+								text: changes.caption
+							}]
+						}];
+					}
+					const size = { ...image.size };
+					for (const key of [
+						"width",
+						"height",
+						"maxWidth",
+						"maxHeight"
+					]) if (changes[key] === null) delete size[key];
+					else if (changes[key] !== void 0) size[key] = changes[key];
+					if (Object.keys(size).length) image.size = size;
+					else delete image.size;
+					if (changes.alignment === null) delete image.alignment;
+					else if (changes.alignment) image.alignment = changes.alignment;
+					this.editor.setLocalizedContent(operation.ref, operation.locale, next, metadata);
+					break;
+				}
+				case "survey-json-patch":
+					this.patch(operation.patches);
+					break;
+				default: throw new Error(`Unknown operation ${String(operation)}`);
+			}
+			const diagnostics = getAnswerTypeChangeDiagnostics(this.baseline, this.model);
+			if (diagnostics.length) throw new DefinitionError(diagnostics);
+		});
+	}
+	serialize() {
+		return this.model.serialize();
+	}
+};
+const executeSurveyOperationsOnRawSurvey = ({ operations, survey, capabilities, answerTypes }) => {
+	const session = new SurveyOperationExecutionSession(survey, capabilities, answerTypes);
+	for (const operation of operations) session.apply(operation);
+	session.assertNoDanglingRemovals();
+	return session.serialize();
+};
+//#endregion
+//#region src/engine/authoring-content.ts
+function requirements(survey) {
+	const result = /* @__PURE__ */ new Map();
+	for (const { node, itemId, facts } of survey.elements.values()) {
+		const add = (ownerId, role, renderable = false) => {
+			const ref = {
+				scope: "content",
+				ownerId,
+				role
+			};
+			result.set(getLocalizationEntryKey(ref), {
+				elementId: node.id,
+				itemId,
+				ref,
+				renderable
+			});
+		};
+		if (node.elementType === "information" || node.elementType === "consent") add(node.id, "body", true);
+		for (const binding of facts.bindings) {
+			if (binding.labelRefs) for (const ref of binding.labelRefs) add(ref.ownerId, ref.role);
+			else result.set(JSON.stringify(["element-name", node.id]), {
+				elementId: node.id,
+				itemId
+			});
+			for (const id of binding.selection?.options ?? []) if (survey.owners.get(id)?.roles.some((role) => role.role === "label")) add(id, "label");
+		}
+	}
+	return result;
+}
+/** Changes to existing inputs must not introduce unnamed components or erase naming content.
+* New elements may be blank presets awaiting later authoring; they retain normal warnings.
+* Presence in any actual language counts, separately from translation completeness.
+*/
+function getIntroducedMissingAuthoringContent(before, after) {
+	const previous = requirements(before);
+	const locales = after.locales;
+	const present = (survey, requirement) => requirement.ref ? locales.some((locale) => {
+		const content = readLocalizationContent(survey, requirement.ref, locale);
+		return requirement.renderable ? !isContentEmpty(content) : hasLocalizationText(content);
+	}) : Boolean(resolveElementName(survey, requirement.elementId, locales));
+	const issues = [];
+	for (const [key, requirement] of requirements(after)) {
+		if (present(after, requirement)) continue;
+		const prior = previous.get(key);
+		if (prior ? !present(before, prior) : !before.elements.has(requirement.elementId)) continue;
+		if (!requirement.ref && prior) {
+			const name = resolveElementName(before, requirement.elementId, locales);
+			if (name && locales.some((locale) => hasLocalizationText(readLocalizationContent(after, {
+				scope: "content",
+				ownerId: name.ownerId,
+				role: name.role
+			}, locale)))) continue;
+		}
+		issues.push({
+			severity: "error",
+			code: "missing-authoring-content",
+			itemId: requirement.itemId,
+			message: requirement.ref ? `Provide non-empty localized content for owner "${requirement.ref.ownerId}" role "${requirement.ref.role}" in the same proposal. Preserve previously authored content unless its control is also removed.` : `Element "${requirement.elementId}" needs a localized label or an unambiguous enclosing title in the same proposal. Preserve its previously authored naming content.`
+		});
+	}
+	return issues;
+}
+//#endregion
+//#region src/engine/operations.ts
+const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL = 200;
+const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT = 1e3;
+const buildSurveyDocumentVersion = (snapshot) => ({ ...snapshot.version });
+function materialize(operation, model, caps) {
+	if (operation.kind !== "insert-preset") return operation;
+	const capability = caps.byElementType.get(operation.elementType);
+	if (capability?.manifest.create !== "deterministic" || !capability.manifest.creationPresets?.some((preset) => preset.id === operation.presetId) || !capability.materializePreset) throw new Error("This preset is not available from the trusted registry");
+	if (capability.supportsOperation && !capability.supportsOperation(operation)) throw new Error("The host does not permit this preset operation");
+	const created = capability.materializePreset(operation.presetId, operation.locale, new Set(model.slots.definitions.map((slot) => slot.variableName)));
+	if (created.element.elementType !== operation.elementType) throw new Error("Preset returned the wrong element type");
+	for (const ownerId of Object.keys(created.content ?? {})) if (model.owners.has(ownerId)) throw new Error(`Initial localized owner '${ownerId}' already exists`);
+	const translations = Object.entries(created.content ?? {}).flatMap(([ownerId, roles]) => Object.entries(roles).map(([role, content]) => ({
+		ownerId,
+		role,
+		locale: operation.locale,
+		content
+	})));
+	if ("layoutId" in operation.target) return {
+		kind: "insert-element",
+		id: operation.id,
+		target: operation.target,
+		element: elementTransportSchema.parse(created.element),
+		translations
+	};
+	const editor = new SurveyEditor(model);
+	const { itemId } = editor.insertElement(elementTransportSchema.parse(created.element), {
+		parentId: operation.target.parentItemId,
+		index: operation.target.index
+	}, {
+		label: "Assistant preset",
+		source: "assistant"
+	}, created.content ? {
+		locale: operation.locale,
+		content: created.content
+	} : void 0);
+	return surveyOperationSchema.parse({
+		kind: "create-item",
+		id: operation.id,
+		target: operation.target,
+		item: editor.survey.getItem(itemId),
+		translations
+	});
+}
+function elementContext(model, id) {
+	const entry = model.elements.get(id);
+	if (!entry) return void 0;
+	const ancestors = [];
+	let owner = model.owners.get(id);
+	while (owner) {
+		ancestors.push({
+			id: owner.id,
+			disabled: owner.disabled,
+			visibility: owner.visibility
+		});
+		owner = owner.parentId ? model.owners.get(owner.parentId) : void 0;
+	}
+	const owners = new Set([...model.owners.values()].filter((owner) => owner.elementId === id).map((owner) => owner.id));
+	for (const ancestor of ancestors) owners.add(ancestor.id);
+	return {
+		node: entry.node,
+		itemId: entry.itemId,
+		ancestors,
+		content: Object.fromEntries(Object.entries(model.data.translations ?? {}).map(([locale, translation]) => [locale, Object.fromEntries(Object.entries(translation.content).filter(([ownerId]) => owners.has(ownerId)))]))
+	};
+}
+function requireCapabilities(operation, before, after, caps) {
+	if ([
+		"add-survey-locale",
+		"remove-survey-locale",
+		"update-survey-metadata",
+		"update-survey-pagination",
+		"update-survey-translation",
+		"set-image-asset",
+		"update-image-asset-metadata",
+		"remove-image-asset",
+		"update-item-label",
+		"update-item-color"
+	].includes(operation.kind)) return;
+	const direct = /* @__PURE__ */ new Set();
+	if ("elementId" in operation) direct.add(operation.elementId);
+	if (operation.kind === "update-layout") {
+		const path = before.identities.get(operation.layoutId)?.path.slice(0, -1);
+		if (path) {
+			for (const entry of before.elements.values()) if (path.every((part, index) => entry.path[index] === part)) direct.add(entry.node.id);
+		}
+	}
+	if (operation.kind === "reorder-items" || operation.kind === "move-item") {
+		const affected = operation.kind === "move-item" ? [operation.itemId] : operation.itemIds;
+		for (const entry of before.elements.values()) if (affected.includes(entry.itemId)) direct.add(entry.node.id);
+	}
+	if (operation.kind === "survey-json-patch" || operation.kind === "patch-item-config") {
+		for (const [id, entry] of before.elements) if (stableStringify(entry.path) !== stableStringify(after.elements.get(id)?.path)) direct.add(id);
+	}
+	if ("blockId" in operation || "ownerId" in operation) {
+		const id = "blockId" in operation ? operation.blockId : operation.ownerId;
+		const path = before.identities.get(id)?.path.slice(0, -1);
+		if (path) {
+			for (const element of before.elements.values()) if (path.every((part, index) => element.path[index] === part)) direct.add(element.node.id);
+		}
+	}
+	for (const id of /* @__PURE__ */ new Set([...before.elements.keys(), ...after.elements.keys()])) {
+		if (!direct.has(id) && stableStringify(elementContext(before, id)) === stableStringify(elementContext(after, id))) continue;
+		const previous = before.elements.get(id);
+		const next = after.elements.get(id);
+		const entry = next ?? previous;
+		const changesType = previous !== void 0 && next !== void 0 && previous.node.elementType !== next.node.elementType;
+		if (changesType) {
+			const sourceCapability = caps.byElementType.get(previous.node.elementType);
+			if (!sourceCapability?.manifest.supportedOperations.includes(operation.kind) || sourceCapability.supportsOperation && !sourceCapability.supportsOperation(operation)) throw new Error(`Element '${previous.node.elementType}' does not permit '${operation.kind}' through the assistant`);
+		}
+		const capability = caps.byElementType.get(entry.node.elementType);
+		if (!capability?.manifest.supportedOperations.includes(operation.kind) || capability.supportsOperation && !capability.supportsOperation(operation)) throw new Error(`Element '${entry.node.elementType}' does not permit '${operation.kind}' through the assistant`);
+		if ((!previous || changesType) && capability.manifest.create !== "deterministic") throw new Error(`Element '${entry.node.elementType}' is not deterministically creatable`);
+		if (!next || !capability.validateElement) continue;
+		const existingErrors = /* @__PURE__ */ new Map();
+		if (previous?.node.elementType === next.node.elementType) for (const issue of capability.validateElement(previous.node)) {
+			if (issue.severity !== "error") continue;
+			const key = stableStringify(issue);
+			existingErrors.set(key, (existingErrors.get(key) ?? 0) + 1);
+		}
+		const errors = capability.validateElement(next.node).filter((issue) => {
+			if (issue.severity !== "error") return false;
+			const key = stableStringify(issue);
+			const count = existingErrors.get(key) ?? 0;
+			if (!count) return true;
+			existingErrors.set(key, count - 1);
+			return false;
+		});
+		if (errors.length) throw new Error(errors.map((issue) => issue.message).join("\n"));
+	}
+}
+/** Preserve sibling wording when a model uses the low-level escape hatch. */
+function validateTranslationPatchSafety(operation, model) {
+	for (const patch of operation.patches) {
+		if (patch.op === "test") continue;
+		for (const path of patch.op === "move" ? [patch.path, patch.from] : [patch.path]) {
+			const segments = parseJsonPointer(path);
+			if (segments[0] !== "translations") continue;
+			let current = model.data;
+			for (const segment of segments) current = current && typeof current === "object" ? ownValue(current, segment) : void 0;
+			if ((segments.length <= 2 || segments.length === 3 || segments[2] === "content" && segments.length === 4) && (segments.length === 1 || current !== void 0)) throw new Error("Raw patches cannot replace or remove a translation container. Use update-content for an owner/role leaf or the typed locale operations.");
+		}
+	}
+}
+const expressionsKey = (model) => stableStringify(model.expressions.map((entry) => ({
+	path: entry.path,
+	expression: entry.expression
+})));
+function validateSurveyOperations({ allowExpressionJsonPatches = false, scope = "proposal", maxOperations = 200, operations, snapshot: input }) {
+	const issues = [], warnings = [], normalizedOperations = [];
+	const fail = (code, message, operationIndex) => issues.push({
+		severity: "error",
+		code,
+		message,
+		operationIndex
+	});
+	if (!input) {
+		fail("missing-snapshot", "No live editor snapshot was provided");
+		return {
+			valid: false,
+			issues,
+			warnings,
+			normalizedOperations
+		};
+	}
+	if (!operations.length || operations.length > maxOperations) {
+		fail(operations.length ? "too-many-operations" : "empty-operations", `Provide 1-${maxOperations} operations`);
+		return {
+			valid: false,
+			issues,
+			warnings,
+			normalizedOperations
+		};
+	}
+	try {
+		const caps = ("model" in input ? input.trustedCapabilities : void 0) ?? defaultSurveyAssistantCapabilitySet;
+		const snapshot = "model" in input ? input : createSurveyAssistantEngineContext(input, caps);
+		assertSurveyAssistantCapabilities({
+			manifest: snapshot.capabilities,
+			trustedCapabilities: caps,
+			versionDigest: snapshot.version.capabilityDigest
+		});
+		const session = new SurveyOperationExecutionSession(snapshot.survey, caps, snapshot.document.answerTypes);
+		for (const [operationIndex, unparsed] of operations.entries()) try {
+			const operation = materialize(surveyOperationSchema.parse(unparsed), session.model, caps);
+			if (operation.kind === "survey-json-patch") {
+				validateTranslationPatchSafety(operation, session.model);
+				if (scope === "proposal" && operations.length !== 1) {
+					fail("raw-patch-must-be-single-operation", "Put all raw patches in one operation", operationIndex);
+					break;
+				}
+				if (operation.patches.some((patch) => [patch.path, ..."from" in patch ? [patch.from] : []].some((path) => path === "" || /^\/(\$schema|schemaVersion)(\/|$)/.test(path)))) {
+					fail("survey-schema-is-immutable", "Raw patches cannot replace the document root or its schema identity", operationIndex);
+					break;
+				}
+			}
+			const before = session.model;
+			session.apply(operation);
+			const after = session.model;
+			if (operation.kind === "update-item-label" || operation.kind === "update-item-color") {
+				const key = operation.kind === "update-item-label" ? "itemLabel" : "editorItemColor";
+				if (before.data.surveyItems.find((item) => item.id === operation.itemId)?.metadata?.[key] === after.data.surveyItems.find((item) => item.id === operation.itemId)?.metadata?.[key]) warnings.push({
+					severity: "warning",
+					code: key === "itemLabel" ? "no-label-change" : "no-color-change",
+					operationIndex,
+					itemId: operation.itemId,
+					message: "The editor metadata already has this value."
+				});
+			}
+			if (operation.kind === "add-survey-locale") warnings.push({
+				severity: "warning",
+				code: "empty-locale-registration",
+				operationIndex,
+				message: "Registering an empty locale does not complete a request to localize or translate the survey. Add the requested localized content as well."
+			});
+			if (operation.kind === "update-content" || operation.kind === "update-survey-translation") {
+				const ref = operation.kind === "update-content" ? operation.ref : {
+					scope: "survey",
+					surface: operation.surface,
+					contentKey: operation.contentKey
+				};
+				if (stableStringify(readLocalizationContent(before, ref, operation.locale)) === stableStringify(readLocalizationContent(after, ref, operation.locale))) warnings.push({
+					severity: "warning",
+					code: "no-content-change",
+					operationIndex,
+					itemId: ref.scope === "content" ? after.owners.get(ref.ownerId)?.itemId : void 0,
+					message: "The localized content already has this value."
+				});
+			}
+			if (!allowExpressionJsonPatches && (operation.kind === "survey-json-patch" || operation.kind === "patch-element-config" || operation.kind === "patch-item-config") && expressionsKey(before) !== expressionsKey(after)) {
+				fail("expression-patch-requires-specialized-tool", "Use survey_expression for condition, validation, prefill and template expression changes", operationIndex);
+				break;
+			}
+			requireCapabilities(operation, before, after, caps);
+			if (operation.kind !== "add-survey-locale") for (const locale of Object.keys(after.data.translations ?? {})) {
+				if (Object.hasOwn(before.data.translations ?? {}, locale)) continue;
+				warnings.push({
+					severity: "warning",
+					code: "introduced-locale",
+					operationIndex,
+					operationId: operation.id,
+					message: `Locale "${locale}" is not currently present and will be introduced by this translation change. Confirm that this is the intended locale code.`
+				});
+			}
+			const oldExpressions = new Set(before.expressions.map((entry) => stableStringify([getDiagnosticLocation(before, entry.path), entry.expression])));
+			for (const entry of after.expressions) if (!oldExpressions.has(stableStringify([getDiagnosticLocation(after, entry.path), entry.expression]))) validateExpression({
+				expression: entry.expression,
+				expectedReturnType: [
+					"visibility",
+					"disabled",
+					"when"
+				].includes(String(entry.path.at(-1))) || entry.path.at(-1) === "expression" && entry.path.includes("validationRules") ? "boolean" : void 0,
+				issues,
+				operationIndex,
+				responseSlotTypes: Object.fromEntries(after.slots.definitions.map((slot) => [slot.slotId, slot.valueType])),
+				stateTargets: new Set(after.owners.keys()),
+				scope: JSON.stringify(entry.path)
+			});
+			if (issues.length) break;
+			normalizedOperations.push(operation);
+		} catch (error) {
+			if (error instanceof DefinitionError) issues.push(...error.diagnostics.filter((issue) => issue.severity === "error").map((issue) => ({
+				severity: "error",
+				code: issue.code,
+				message: `${JSON.stringify(issue.path)}: ${issue.message}`,
+				operationIndex
+			})));
+			else if (error instanceof JsonPatchError) {
+				const patch = "patches" in unparsed ? unparsed.patches[error.operationIndex ?? 0] : void 0;
+				const location = patch ? `${unparsed.kind === "survey-json-patch" ? "Survey" : "Config"} patch ${(error.operationIndex ?? 0) + 1} (${patch.op} ${patch.path}): ` : "";
+				const hint = error.code === "path-not-found" && patch?.op === "replace" ? " Use add for a new property; replace requires an existing property." : "";
+				fail(error.code, `${location}${error.message}${hint}`, operationIndex);
+			} else if (error instanceof z.ZodError) fail("invalid-operation", error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("\n"), operationIndex);
+			else fail("invalid-operation", error instanceof Error ? error.message : String(error), operationIndex);
+			break;
+		}
+		if (!issues.length) try {
+			session.assertNoDanglingRemovals();
+		} catch (error) {
+			if (!(error instanceof DefinitionError)) throw error;
+			issues.push(...error.diagnostics.map((issue) => ({
+				severity: "error",
+				code: issue.code,
+				message: `${JSON.stringify(issue.path)}: ${issue.message}`
+			})));
+		}
+		if (!issues.length) {
+			issues.push(...getIntroducedMissingAuthoringContent(snapshot.model, session.model));
+			new SurveyStateGraph(session.model, { admission: "draft" });
+			const existingExports = new Set(getDefaultProjectionIssues(snapshot.model));
+			for (const message of getDefaultProjectionIssues(session.model)) if (!existingExports.has(message)) fail("invalid-response-export", message);
+			for (const issue of getIntroducedDefinitionIssues(snapshot.model, session.model, snapshot.ui.selectedLocale)) if (issue.severity === "error") issues.push(issue);
+			else warnings.push(issue);
+		}
+	} catch (error) {
+		fail("invalid-survey-definition", error instanceof Error ? error.message : String(error));
+	}
+	return {
+		valid: issues.length === 0,
+		issues,
+		warnings,
+		normalizedOperations
+	};
+}
+const createSurveyChangeSet = ({ allowExpressionJsonPatches, maxOperations, operations, snapshot, summary, turnId }) => {
+	const validation = validateSurveyOperations({
+		allowExpressionJsonPatches,
+		maxOperations,
+		operations,
+		snapshot
+	});
+	return {
+		protocolVersion: 1,
+		id: generateId(),
+		turnId,
+		status: validation.valid ? "validated" : "rejected",
+		summary: summary.trim(),
+		operations: validation.normalizedOperations,
+		precondition: snapshot ? buildSurveyDocumentVersion(snapshot) : void 0,
+		validation,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+};
+//#endregion
+//#region src/engine/operation-state.ts
+const getGroupChildren = (item) => item?.itemType === "group" ? item.config.items : [];
+//#endregion
+//#region src/engine/audit.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+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: "key-semantic-consistency",
+		title: "Variable-name and export-code consistency",
+		prompt: "Do response variable names and option export codes follow the survey's established convention and avoid contradicting the content they currently identify? Generic, numeric, or opaque keys are acceptable when that is the survey's consistent pattern; flag descriptive keys when they have become stale or misleading, and mixed conventions when the inconsistency appears accidental."
+	},
+	{
+		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 collectKeyReviewEntries = (context, sourceLocale) => {
+	const model = context.model;
+	const entries = [];
+	const text = (refs) => refs.map((ref) => getContentPlainText(readLocalizationContent(model, ref, sourceLocale)).trim()).filter(Boolean).join(" / ");
+	for (const slot of model.slots.definitions) {
+		const binding = model.elements.get(slot.elementId).facts.bindings.find((entry) => entry.slotId === slot.slotId);
+		const resolved = resolveElementName(model, slot.elementId, [sourceLocale]);
+		const refs = binding?.labelRefs?.map((ref) => ({
+			scope: "content",
+			...ref
+		})) ?? (resolved ? [{
+			scope: "content",
+			ownerId: resolved.ownerId,
+			role: resolved.role
+		}] : []);
+		entries.push({
+			kind: "response-variable",
+			slotId: slot.slotId,
+			valueType: slot.valueType,
+			computed: !!slot.computed,
+			itemId: slot.itemId,
+			itemKey: model.resolveItemEditorName(slot.itemId, sourceLocale),
+			key: slot.variableName,
+			keySource: "explicit",
+			localizationRefs: refs,
+			content: text(refs)
+		});
+		const codes = new Map(Object.entries(slot.referenceValueKeys ?? {}));
+		const declaredLabels = new Map(Object.entries(new Map(Object.entries(slot.referenceValueLabels ?? {})).get(sourceLocale) ?? {}));
+		const optionIds = /* @__PURE__ */ new Set([...(slot.allowedValues ?? []).flatMap((value) => value.type === "reference" ? [value.value] : value.type === "reference[]" ? value.value : []), ...codes.keys()]);
+		for (const id of optionIds) {
+			const code = codes.get(id);
+			const explicit = !!code?.trim();
+			const optionRefs = model.owners.get(id)?.roles.some((role) => role.role === "label") ? [{
+				scope: "content",
+				ownerId: id,
+				role: "label"
+			}] : [];
+			entries.push({
+				kind: "choice-option",
+				slotId: slot.slotId,
+				itemId: slot.itemId,
+				itemKey: model.resolveItemEditorName(slot.itemId, sourceLocale),
+				key: explicit ? code : id,
+				keySource: explicit ? "explicit" : "fallback-id",
+				localizationRefs: optionRefs,
+				content: optionRefs.length ? text(optionRefs) : declaredLabels.get(id)
+			});
+		}
+	}
+	return entries;
+};
+const auditSurvey = (context, options = {}) => {
+	const findings = [];
+	const add = (finding) => findings.push(finding);
+	const items = context.survey.surveyItems;
+	const itemTypes = {}, elementTypes = {};
+	for (const item of items) setOwnValue(itemTypes, item.itemType, (ownValue(itemTypes, item.itemType) ?? 0) + 1);
+	for (const element of context.model.elements.values()) setOwnValue(elementTypes, element.node.elementType, (ownValue(elementTypes, element.node.elementType) ?? 0) + 1);
+	const locales = context.inspection.locales;
+	const sourceLocale = options.sourceLocale ?? context.ui.selectedLocale ?? locales[0];
+	const targetLocales = options.targetLocales ?? (options.sourceLocale ? locales.filter((locale) => locale !== sourceLocale) : locales);
+	const allKeyReviewEntries = collectKeyReviewEntries(context, sourceLocale);
+	const keyReviewOffset = Math.min(options.keyReviewOffset ?? 0, allKeyReviewEntries.length);
+	const keyReviewLimit = options.keyReviewLimit ?? 30;
+	const keyReviewEntries = allKeyReviewEntries.slice(keyReviewOffset, keyReviewOffset + keyReviewLimit);
+	for (const entry of listLocalizationEntries(context.model, { sourceLocale: options.sourceLocale })) for (const locale of targetLocales) if (!hasLocalizationText(ownValue(entry.contents, locale)) && Object.entries(entry.contents).some(([other, content]) => other !== locale && hasLocalizationText(content))) add({
+		code: "missing-translation",
+		severity: "warning",
+		category: "localization",
+		...entry.ref.scope === "content" ? { itemId: context.model.owners.get(entry.ref.ownerId)?.itemId } : {},
+		locale,
+		localizationRefs: [entry.ref],
+		message: `Content "${entry.ref.scope === "content" ? entry.ref.role : entry.ref.contentKey}" is available in another language but has no ${locale} translation.`
+	});
+	for (const element of context.model.elements.values()) {
+		const emptyControls = /* @__PURE__ */ new Set();
+		for (const binding of element.facts.bindings) {
+			if (!binding.selection || binding.selection.options.length || emptyControls.has(binding.controlId)) continue;
+			emptyControls.add(binding.controlId);
+			add({
+				code: "choice-without-options",
+				severity: "error",
+				category: "content",
+				itemId: element.itemId,
+				path: context.model.owners.get(binding.controlId)?.path ?? element.path,
+				message: `Choice input "${binding.controlId}" has no options.`,
+				suggestion: "Add at least one option with localized wording, or remove the input."
+			});
+		}
+	}
+	for (const diagnostic of getDefinitionDiagnostics(context.model, sourceLocale)) add({
+		code: diagnostic.code,
+		severity: diagnostic.severity,
+		category: diagnostic.code.startsWith("missing-") ? "content" : "logic",
+		message: diagnostic.message,
+		itemId: diagnostic.ownerItemId,
+		path: diagnostic.path,
+		suggestion: getSurveyAssistantExpressionDiagnosticGuidance(diagnostic)
+	});
+	for (const issue of getAssistantResponseSchemaIssues(context.survey, context.trustedCapabilities)) if (!findings.some((finding) => finding.code === issue.code && finding.message === issue.message)) add({
+		...issue,
+		category: "responses"
+	});
+	const assets = context.survey.assets ?? {};
+	for (const [assetId, asset] of Object.entries(assets)) {
+		const metadata = isRecord$1(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: findings.reduce((acc, entry) => {
+			acc[entry.severity] += 1;
+			acc.total += 1;
+			return acc;
+		}, {
+			error: 0,
+			warning: 0,
+			info: 0,
+			total: 0
+		}),
+		findingCount: findings.length,
+		truncated: limited.length < findings.length,
+		metrics: {
+			itemCount: context.inspection.itemCount,
+			localeCount: locales.length,
+			responseSlotCount: context.inspection.responseSlots.length,
+			assetCount: Object.keys(assets).length,
+			itemTypes,
+			elementTypes
+		},
+		findings: limited,
+		qualityReviewPrinciples: QUALITY_PRINCIPLES,
+		keyReview: {
+			sourceLocale,
+			entryCount: allKeyReviewEntries.length,
+			offset: keyReviewOffset,
+			returnedEntryCount: keyReviewEntries.length,
+			truncated: keyReviewOffset + keyReviewEntries.length < allKeyReviewEntries.length,
+			entries: keyReviewEntries,
+			note: "These key/content pairs are evidence for qualitative review, not deterministic defects. Judge them against the survey's own naming pattern; generic or opaque keys are not inherently problematic."
+		},
+		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
+//#region src/engine/mutation-recovery.ts
+const UNIDENTIFIED_MUTATION_TARGET = "unidentified-mutation";
+const SATISFIED_MUTATION_TARGET = "satisfied-mutation";
+const SATISFIED_ISSUES = /* @__PURE__ */ new Set([
+	"survey-locale-already-exists",
+	"item-already-in-target-parent",
+	"no-expression-patches"
+]);
+const VALUE_ONLY_ISSUES = /* @__PURE__ */ new Set([
+	"invalid-mutation-value",
+	"target-index-after-end",
+	"option-index-after-end",
+	"missing-create-content",
+	"missing-choice-options",
+	"missing-choice-option-label",
+	"missing-choice-option-labels",
+	"missing-form-field-content",
+	"missing-form-field-labels",
+	"missing-form-select-option-labels",
+	"missing-embedded-form-field-labels",
+	"missing-field-groups-wrapper",
+	"invalid-form-layout-columns",
+	"missing-expression",
+	"invalid-expression",
+	"unknown-response-ref",
+	"expression-function-signature-mismatch",
+	"expression-return-type-mismatch",
+	"missing-date-format",
+	"image-asset-still-referenced"
+]);
+const exceptionalRecoveryTarget = (operationIndex, issues) => {
+	const errors = issues.filter((issue) => issue.severity === "error" && (issue.operationIndex === operationIndex || issue.operationIndex === void 0));
+	if (errors.length === 0) return void 0;
+	if (errors.every((issue) => SATISFIED_ISSUES.has(issue.code))) return SATISFIED_MUTATION_TARGET;
+	if (!errors.every((issue) => VALUE_ONLY_ISSUES.has(issue.code))) return UNIDENTIFIED_MUTATION_TARGET;
+};
+const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const at = (value, path) => path.split(".").reduce((entry, key) => record(entry)[key], value);
+const identityFields = {
+	"create-item": ["target.parentItemId", "item.id"],
+	"insert-element": ["target.layoutId", "element.id"],
+	"insert-preset": [
+		"elementType",
+		"presetId",
+		"locale",
+		"target.layoutId?",
+		"target.parentItemId?",
+		"target.index?"
+	],
+	"insert-blocks": ["bodyOwnerId"],
+	"update-content": [
+		"ref.scope",
+		"ref.ownerId?",
+		"ref.role?",
+		"ref.surface?",
+		"ref.contentKey?",
+		"locale"
+	],
+	"update-placed-image": [
+		"ref.scope",
+		"ref.ownerId?",
+		"ref.role?",
+		"ref.surface?",
+		"ref.contentKey?",
+		"locale",
+		"imageIndex"
+	],
+	"patch-element-config": ["elementId"],
+	"patch-item-config": ["itemId"],
+	"update-item-label": ["itemId"],
+	"update-item-color": ["itemId"],
+	"remove-item": ["itemId"],
+	"move-item": ["itemId"],
+	"reorder-items": ["parentItemId"],
+	"move-element": ["elementId"],
+	"move-block": ["blockId"],
+	"remove-content": ["ownerId"],
+	"update-layout": ["layoutId"],
+	"update-response-settings": ["naming", "settings"],
+	"set-image-asset": ["assetId"],
+	"update-image-asset-metadata": ["assetId"],
+	"remove-image-asset": ["assetId"],
+	"update-survey-metadata": [],
+	"update-survey-pagination": [],
+	"update-survey-translation": [
+		"locale",
+		"surface",
+		"contentKey"
+	],
+	"add-survey-locale": ["locale"],
+	"remove-survey-locale": ["locale"],
+	"survey-json-patch": []
+};
+const identities = (kind, value, fields, context) => {
+	const parts = [kind];
+	for (const field of fields) {
+		const optional = field.endsWith("?");
+		const path = optional ? field.slice(0, -1) : field;
+		let part = at(value, path);
+		if (typeof part === "string" && context && /(?:^|\.)(?:itemId|parentItemId)$/.test(path)) {
+			const direct = context.survey.surveyItems.find((item) => item.id === part);
+			if (!direct) return void 0;
+			part = direct.id;
+		}
+		if (part === void 0 && optional) parts.push(null);
+		else if (typeof part === "string" && part.length > 0 || (path === "imageIndex" || path.endsWith("index")) && typeof part === "number" && Number.isInteger(part) && part >= 0) parts.push(part);
+		else return void 0;
+	}
+	return parts;
+};
+const collectSurveyOperationRecoveryTargets = (operations, context, issues = []) => {
+	const targets = operations.flatMap((operation, operationIndex) => {
+		const value = record(operation);
+		const kind = value.kind;
+		if (typeof kind !== "string" || !Object.hasOwn(identityFields, kind)) return [UNIDENTIFIED_MUTATION_TARGET];
+		if (kind === "survey-json-patch" || kind === "patch-item-config") return [UNIDENTIFIED_MUTATION_TARGET];
+		const exceptional = exceptionalRecoveryTarget(operationIndex, issues);
+		if (exceptional) return [exceptional];
+		if (kind === "update-response-settings") {
+			const targets = ["naming", "settings"].flatMap((surface) => Array.isArray(value[surface]) ? value[surface].map((edit) => {
+				const entry = record(edit);
+				const identity = entry.slotId ?? entry.elementId;
+				return typeof identity === "string" && identity.length ? JSON.stringify([
+					kind,
+					surface,
+					identity
+				]) : UNIDENTIFIED_MUTATION_TARGET;
+			}) : []);
+			return targets.length ? targets : [UNIDENTIFIED_MUTATION_TARGET];
+		}
+		const parts = identities(kind, value, identityFields[kind], context);
+		if (!parts) return [UNIDENTIFIED_MUTATION_TARGET];
+		const fields = kind === "update-survey-metadata" ? value.values : kind === "update-image-asset-metadata" ? value.metadata : kind === "update-placed-image" ? value.changes : void 0;
+		if ([
+			"update-survey-metadata",
+			"update-image-asset-metadata",
+			"update-placed-image"
+		].includes(kind)) {
+			const keys = Object.keys(record(fields));
+			return keys.length > 0 ? keys.map((key) => JSON.stringify([...parts, key])) : [UNIDENTIFIED_MUTATION_TARGET];
+		}
+		return [JSON.stringify(parts)];
+	});
+	return new Set(targets.length > 0 ? targets : [UNIDENTIFIED_MUTATION_TARGET]);
+};
+const expressionIdentityFields = {
+	"set-condition": ["ownerId", "property"],
+	"clear-condition": ["ownerId", "property"],
+	"set-config-expression": ["elementId", "path"],
+	"clear-config-expression": ["elementId", "path"],
+	"set-validation-rule": ["itemId", "rule.id"],
+	"remove-validation-rule": ["itemId", "ruleId"],
+	"set-prefill": [
+		"elementId",
+		"slotId",
+		"prefill.id"
+	],
+	"clear-prefill": [
+		"elementId",
+		"slotId",
+		"prefillId"
+	],
+	"set-template-value": ["templateKey"],
+	"clear-template-value": ["templateKey"]
+};
+const collectExpressionMutationRecoveryTargets = (mutations, context, issues = []) => [...new Set(mutations.map((mutation, operationIndex) => {
+	const kind = record(mutation).kind;
+	if (typeof kind !== "string" || !Object.hasOwn(expressionIdentityFields, kind)) return UNIDENTIFIED_MUTATION_TARGET;
+	const parsed = expressionMutationSchema.safeParse(mutation);
+	if (!parsed.success && !parsed.error.issues.every((issue) => issue.path[0] === "expression" || issue.path[0] === "templateValue" || issue.path[0] === "rule" && issue.path.length > 1 && issue.path[1] !== "id" || issue.path[0] === "prefill" && issue.path.length > 1 && issue.path[1] !== "id")) return UNIDENTIFIED_MUTATION_TARGET;
+	const exceptional = exceptionalRecoveryTarget(operationIndex, issues);
+	if (exceptional) return exceptional;
+	const parts = identities(kind, mutation, expressionIdentityFields[kind], context);
+	return parts ? JSON.stringify(parts) : UNIDENTIFIED_MUTATION_TARGET;
+}))];
+/** Classify a malformed batch without staging any of its parseable siblings.
+* The canonical validator sees those siblings in order, retaining dependencies;
+* all diagnostic indexes are mapped back to the original, unfiltered input.
+*/
+const collectMalformedSurveyOperationRecoveryTargets = (operations, context, normalizationIssues = []) => {
+	const parsedOperations = [];
+	const originalIndexes = [];
+	const issues = [];
+	operations.forEach((operation, operationIndex) => {
+		const parsed = surveyOperationSchema.safeParse(operation);
+		const normalizationFailed = normalizationIssues.some((issue) => Number(issue.path.split(".")[0]) === operationIndex);
+		if (parsed.success && !normalizationFailed) {
+			if (parsed.data.kind === "survey-json-patch") return;
+			parsedOperations.push(parsed.data);
+			originalIndexes.push(operationIndex);
+			return;
+		}
+		const value = record(operation);
+		const kind = value.kind;
+		const valueField = kind === "update-item-label" ? "itemLabel" : kind === "update-item-color" ? "color" : void 0;
+		const parts = typeof kind === "string" && Object.hasOwn(identityFields, kind) ? identities(kind, value, identityFields[kind], context) : void 0;
+		const supported = !!context?.survey.surveyItems.find((entry) => entry.id === parts?.[1]);
+		const valueOnly = !normalizationFailed && !parsed.success && valueField && supported && parsed.error.issues.every((issue) => issue.path[0] === valueField);
+		issues.push({
+			severity: "error",
+			operationIndex,
+			code: valueOnly ? "invalid-mutation-value" : "invalid-operation-shape",
+			message: "Malformed operation recovery classification."
+		});
+	});
+	if (parsedOperations.length > 0) {
+		const validation = validateSurveyOperations({
+			operations: parsedOperations,
+			snapshot: context
+		});
+		issues.push(...validation.issues.map((issue) => ({
+			...issue,
+			...issue.operationIndex !== void 0 ? { operationIndex: originalIndexes[issue.operationIndex] } : {}
+		})));
+	}
+	return collectSurveyOperationRecoveryTargets(operations, context, issues);
+};
+/** Later validation can disprove an earlier target assumption. Refine only the
+* same attempted operation's exact identities; this does not discharge work.
+*/
+const collectRecoveryTargetRefinements = (values, context, issues, collect) => values.flatMap((value, operationIndex) => {
+	const operationIssues = issues.filter((issue) => issue.operationIndex === operationIndex || issue.operationIndex === void 0).map((issue) => ({
+		...issue,
+		operationIndex: 0
+	}));
+	const before = [...collect([value], context)];
+	const replacement = [...collect([value], context, operationIssues)].find((target) => target === "unidentified-mutation" || target === "satisfied-mutation");
+	const targets = before.filter((target) => target !== "unidentified-mutation" && target !== "satisfied-mutation");
+	return replacement && targets.length ? [{
+		targets,
+		replacement
+	}] : [];
+});
+const collectSurveyOperationRecoveryRefinements = (values, context, issues) => collectRecoveryTargetRefinements(values, context, issues, collectSurveyOperationRecoveryTargets);
+const collectExpressionMutationRecoveryRefinements = (values, context, issues) => collectRecoveryTargetRefinements(values, context, issues, collectExpressionMutationRecoveryTargets);
+/** Refine only resource identities present before a successful delta and absent
+* after it. Values, other items' components, and opaque recovery markers do not
+* count as references. Comparing canonical states also covers raw deletions.
+*/
+const collectRemovedRecoveryTargetRefinements = (targets, before, after) => {
+	const resourceExists = (field, id, context) => {
+		if (typeof id !== "string") return false;
+		if (/(?:^|\.)(?:itemId|parentItemId)$/.test(field)) return context.survey.surveyItems.some((item) => item.id === id);
+		if (field === "locale") return Object.hasOwn(context.survey.translations ?? {}, id);
+		if (field === "assetId") return Object.hasOwn(context.survey.assets ?? {}, id);
+		if (/(?:^|\.)(?:ownerId|bodyOwnerId|elementId|layoutId|blockId|slotId)$/.test(field)) return context.model.identities.has(id);
+		return false;
+	};
+	return [...new Set(targets)].flatMap((target) => {
+		if (!target.startsWith("[")) return [];
+		let parts;
+		try {
+			parts = JSON.parse(target);
+		} catch {
+			return [];
+		}
+		if (!Array.isArray(parts) || typeof parts[0] !== "string") return [];
+		const kind = parts[0];
+		const fields = Object.hasOwn(identityFields, kind) ? identityFields[kind] : Object.hasOwn(expressionIdentityFields, kind) ? expressionIdentityFields[kind] : void 0;
+		if (!fields) return [];
+		const bindings = Object.fromEntries(fields.map((field, index) => [field.replace(/\?$/, ""), parts[index + 1]]));
+		return Object.entries(bindings).some(([field, id]) => resourceExists(field, id, before) && !resourceExists(field, id, after)) ? [{
+			targets: [target],
+			replacement: UNIDENTIFIED_MUTATION_TARGET
+		}] : [];
+	});
+};
+//#endregion
+//#region src/engine/turn-survey-draft.ts
+const createId = () => globalThis.crypto.randomUUID();
+const operationTargets = (operation, context) => {
+	const ownerTarget = (id) => {
+		const identity = context?.model.identities.get(id), owner = context?.model.owners.get(id) ?? (identity?.ownerId ? context?.model.owners.get(identity.ownerId) : void 0);
+		return owner ? [`item:${owner.itemId}`] : [`owner:${id}`];
+	};
+	switch (operation.kind) {
+		case "create-item": return [`item:${operation.item.id}`];
+		case "insert-element": return ownerTarget(operation.target.layoutId);
+		case "insert-preset": return "layoutId" in operation.target ? ownerTarget(operation.target.layoutId) : [`item:${operation.target.parentItemId}`];
+		case "insert-blocks":
+		case "move-block": return [...ownerTarget(operation.bodyOwnerId), ...operation.kind === "move-block" ? ownerTarget(operation.blockId) : []];
+		case "update-layout": return ownerTarget(operation.layoutId);
+		case "remove-content": return ownerTarget(operation.ownerId);
+		case "move-element": return [...ownerTarget(operation.elementId), ...ownerTarget(operation.target.layoutId)];
+		case "patch-element-config": return ownerTarget(operation.elementId);
+		case "update-content":
+		case "update-placed-image": return operation.ref.scope === "content" ? ownerTarget(operation.ref.ownerId) : ["survey"];
+		case "update-item-label":
+		case "update-item-color":
+		case "patch-item-config":
+		case "remove-item":
+		case "move-item": return [`item:${operation.itemId}`];
+		case "reorder-items": return [`item:${operation.parentItemId}`];
+		case "set-image-asset":
+		case "update-image-asset-metadata":
+		case "remove-image-asset": return [`asset:${operation.assetId}`];
+		case "update-response-settings": return [...new Set(context?.responseVariables.filter((slot) => operation.naming.some((edit) => "slotId" in edit ? edit.slotId === slot.slotId : edit.elementId === slot.elementId) || operation.settings.some((edit) => edit.slotId === slot.slotId)).map((slot) => `item:${slot.itemId}`) ?? ["survey"])];
+		case "update-survey-metadata":
+		case "update-survey-pagination":
+		case "update-survey-translation":
+		case "add-survey-locale":
+		case "remove-survey-locale": return ["survey"];
+		case "survey-json-patch": return operation.patches.map((patch) => `path:${patch.path}`);
+		default: throw new Error(String(operation));
+	}
+};
+const collectOperationTargets = (operations, context) => new Set(operations.flatMap((operation) => operationTargets(operation, context)));
+const mutationRecoveryRouteByIssueCode = { "expression-patch-requires-specialized-tool": "expression" };
+const mutationRouteTarget = (route) => `mutation-route:${route}`;
+const collectExclusiveMutationRecoveryTargets = (changeSet) => {
+	const errorIssues = changeSet.validation.issues.filter((issue) => issue.severity === "error");
+	if (errorIssues.length === 0) return void 0;
+	const routes = errorIssues.map((issue) => mutationRecoveryRouteByIssueCode[issue.code]);
+	const knownRoutes = routes.filter((route) => route !== void 0);
+	if (knownRoutes.length !== routes.length) return void 0;
+	return new Set(knownRoutes.map(mutationRouteTarget));
+};
+const MAX_POST_CHANGE_TARGETS = 16;
+const MAX_POST_CHANGE_ITEMS = 6;
+const MAX_POST_CHANGE_CHILDREN = 16;
+const MAX_POST_CHANGE_TRANSLATIONS = 12;
+const MAX_POST_CHANGE_RESPONSE_SLOTS = 12;
+const MAX_POST_CHANGE_TEXT_CHARS = 100;
+const MAX_VERIFICATION_AUDIT_FINDINGS = 8;
+const MAX_VERIFICATION_MESSAGE_CHARS = 240;
+const SUBSTANTIAL_CHANGE_ITEM_COUNT = 6;
+const SUBSTANTIAL_CHANGE_OPERATION_COUNT = 12;
+const createPostChangeProjection = (context, targets, before, reorderedParentIds) => {
+	const beforeItems = new Map(before?.survey.surveyItems.map((item) => [item.id, item]));
+	const previewedChildOrders = new Set(reorderedParentIds);
+	for (const item of context.survey.surveyItems) {
+		if (item.itemType !== "group") continue;
+		const previous = beforeItems.get(item.id);
+		const children = getGroupChildren(item);
+		const previousChildren = getGroupChildren(previous);
+		if (!previous || children.length !== previousChildren.length || children.some((id, index) => id !== previousChildren[index])) previewedChildOrders.add(item.id);
+	}
+	const allTargets = [.../* @__PURE__ */ new Set([...targets, ...[...previewedChildOrders].map((id) => `item:${id}`)])];
+	const requestedItemIds = allTargets.filter((target) => target.startsWith("item:")).map((target) => target.slice(5));
+	const itemEntries = requestedItemIds.map((itemId) => context.inspection.itemIndex.find((entry) => entry.itemId === itemId)).filter((entry) => entry !== void 0);
+	const itemsById = new Map(context.survey.surveyItems.map((item) => [item.id, item]));
+	const outlineById = new Map(context.inspection.outline.map((item) => [item.itemId, item]));
+	let truncated = allTargets.length > MAX_POST_CHANGE_TARGETS || itemEntries.length > MAX_POST_CHANGE_ITEMS;
+	const touchedItems = itemEntries.slice(0, MAX_POST_CHANGE_ITEMS).map((entry) => {
+		const ownerIds = new Set([...context.model.owners.values()].filter((owner) => owner.itemId === entry.itemId).map((owner) => owner.id));
+		const allTranslations = Object.entries(context.survey.translations ?? {}).flatMap(([locale, translation]) => Object.entries(translation.content).filter(([ownerId]) => ownerIds.has(ownerId)).flatMap(([ownerId, roles]) => Object.entries(roles).map(([role, content]) => {
+			const characters = [...getContentPlainText(content)];
+			return {
+				locale,
+				ownerId,
+				role,
+				textPreview: characters.slice(0, MAX_POST_CHANGE_TEXT_CHARS).join(""),
+				textLength: characters.length,
+				truncated: characters.length > MAX_POST_CHANGE_TEXT_CHARS
+			};
+		})));
+		const translations = allTranslations.slice(0, MAX_POST_CHANGE_TRANSLATIONS);
+		const allResponseSlots = context.responseVariables.filter((slot) => slot.itemId === entry.itemId).map((slot) => slot.slotId);
+		const responseSlots = allResponseSlots.slice(0, MAX_POST_CHANGE_RESPONSE_SLOTS);
+		if (allTranslations.length > translations.length || allResponseSlots.length > responseSlots.length || translations.some((translation) => translation.truncated)) truncated = true;
+		const parentId = outlineById.get(entry.itemId)?.parentId;
+		const parent = parentId ? itemsById.get(parentId) : void 0;
+		const siblings = parent?.itemType === "group" ? getGroupChildren(parent) : void 0;
+		const index = siblings?.indexOf(entry.itemId) ?? -1;
+		const placement = parent && siblings && index >= 0 ? {
+			parentItemId: parent.id,
+			index,
+			siblingCount: siblings.length,
+			...index > 0 ? { previousItemId: siblings[index - 1] } : {},
+			...index + 1 < siblings.length ? { nextItemId: siblings[index + 1] } : {},
+			shuffled: parent.itemType === "group" && parent.config.shuffleItems === true
+		} : void 0;
+		const item = itemsById.get(entry.itemId);
+		const children = previewedChildOrders.has(entry.itemId) ? getGroupChildren(item) : void 0;
+		const childOrder = children ? {
+			itemIds: children.slice(0, MAX_POST_CHANGE_CHILDREN),
+			total: children.length,
+			truncated: children.length > MAX_POST_CHANGE_CHILDREN,
+			shuffled: item?.itemType === "group" && item.config.shuffleItems === true
+		} : void 0;
+		if (childOrder?.truncated) truncated = true;
+		return {
+			itemId: entry.itemId,
+			...placement ? { placement } : {},
+			...childOrder ? { childOrder } : {},
+			itemType: entry.itemType,
+			editorName: entry.editorName,
+			breadcrumb: entry.breadcrumb,
+			...entry.itemLabel ? { itemLabel: entry.itemLabel } : {},
+			translationCount: allTranslations.length,
+			translations,
+			responseSlotCount: allResponseSlots.length,
+			responseSlots,
+			responseVariables: context.responseVariables.filter((slot) => responseSlots.includes(slot.slotId))
+		};
+	});
+	return {
+		version: context.version,
+		itemCount: context.inspection.itemCount,
+		localeCount: context.inspection.locales.length,
+		locales: context.inspection.locales.slice(0, 32),
+		targetCount: allTargets.length,
+		touchedTargets: allTargets.slice(0, MAX_POST_CHANGE_TARGETS),
+		touchedItemCount: requestedItemIds.length,
+		availableTouchedItemCount: itemEntries.length,
+		touchedItems,
+		truncated: truncated || context.inspection.locales.length > 32
+	};
+};
+const auditFindingKey = (finding, context) => [
+	finding.code,
+	finding.category,
+	finding.itemId ?? "",
+	finding.locale ?? "",
+	JSON.stringify(finding.localizationRefs ?? getDiagnosticLocation(context.model, finding.path))
+].join("\0");
+const isComplexOperation = (operation) => [
+	"survey-json-patch",
+	"patch-item-config",
+	"patch-element-config",
+	"insert-blocks",
+	"move-element",
+	"move-block",
+	"create-item"
+].includes(operation.kind);
+const createChangeVerification = ({ after, before, operations, postChange }) => {
+	const beforeFindingKeys = new Set(auditSurvey(before, { maxFindings: 1e4 }).findings.map((finding) => auditFindingKey(finding, before)));
+	const newAuditFindings = auditSurvey(after, { maxFindings: 1e4 }).findings.filter((finding) => !beforeFindingKeys.has(auditFindingKey(finding, after)));
+	const reasons = [];
+	if (operations.length > SUBSTANTIAL_CHANGE_OPERATION_COUNT || postChange.touchedItemCount > SUBSTANTIAL_CHANGE_ITEM_COUNT) reasons.push("substantial-change");
+	if (operations.some(isComplexOperation)) reasons.push("complex-change");
+	if (postChange.truncated) reasons.push("bounded-preview");
+	if (newAuditFindings.length > 0) reasons.push("new-audit-findings");
+	if (reasons.length === 0) return void 0;
+	let truncated = newAuditFindings.length > MAX_VERIFICATION_AUDIT_FINDINGS;
+	const auditFindings = newAuditFindings.slice(0, MAX_VERIFICATION_AUDIT_FINDINGS).map((finding) => {
+		const messageCharacters = [...finding.message];
+		const messagePreview = messageCharacters.slice(0, MAX_VERIFICATION_MESSAGE_CHARS).join("");
+		const messageTruncated = messageCharacters.length > MAX_VERIFICATION_MESSAGE_CHARS;
+		if (messageTruncated) truncated = true;
+		return {
+			code: finding.code,
+			severity: finding.severity,
+			category: finding.category,
+			...finding.itemId ? { itemId: finding.itemId } : {},
+			...finding.locale ? { locale: finding.locale } : {},
+			...finding.localizationRefs ? { localizationRefs: finding.localizationRefs } : {},
+			messagePreview,
+			messageLength: messageCharacters.length,
+			truncated: messageTruncated
+		};
+	});
+	return {
+		required: true,
+		reasons,
+		newAuditFindingCount: newAuditFindings.length,
+		auditFindings,
+		truncated
+	};
+};
+/**
+* Request-scoped transactional draft for one assistant response.
+*
+* Mutation tools submit deltas. A successful delta replaces the previous
+* candidate with a newly validated, cumulative change set. A rejected delta
+* leaves the accepted draft intact and blocks authorization until all of its
+* operation/surface obligations have been repaired. Only the latest cumulative
+* candidate can be authorized.
+*/
+var TurnSurveyDraft = class {
+	turnId;
+	#candidates = /* @__PURE__ */ new Map();
+	#draftOperations = [];
+	#context;
+	#baseline;
+	#operationWarnings = [];
+	#reportingTargets = /* @__PURE__ */ new Set();
+	#latestChangeSetId;
+	#unresolvedCandidates = /* @__PURE__ */ new Map();
+	#final = null;
+	constructor(turnId = createId()) {
+		this.turnId = turnId;
+	}
+	initialize(context) {
+		if (this.#context) throw new Error("The survey turn draft was initialized more than once.");
+		this.#context = context;
+		this.#baseline = context;
+	}
+	stage({ addressedTargets = [], allowExpressionJsonPatches = false, handledMutationRoutes = [], retryOfChangeIds = [], operations, snapshot, summary }) {
+		this.#assertOpen();
+		if (!this.#context && snapshot && "document" in snapshot && "trustedCapabilities" in snapshot) {
+			this.#context = snapshot;
+			this.#baseline = snapshot;
+		}
+		const currentContext = this.#context ?? snapshot;
+		const recoveryTargets = addressedTargets.length > 0 ? new Set(addressedTargets) : collectSurveyOperationRecoveryTargets(operations, currentContext);
+		const delta = createSurveyChangeSet({
+			allowExpressionJsonPatches,
+			operations,
+			snapshot: currentContext,
+			summary,
+			turnId: this.turnId
+		});
+		if (operations.length === 0 && retryOfChangeIds.some((id) => this.#unresolvedCandidates.get(id)?.has("satisfied-mutation")) && delta.validation.issues.length > 0 && delta.validation.issues.every((issue) => issue.code === "empty-operations")) {
+			delta.status = "validated";
+			delta.validation = {
+				...delta.validation,
+				valid: true,
+				issues: []
+			};
+		}
+		if (delta.status !== "validated" || !delta.validation.valid) return this.reject(delta, collectExclusiveMutationRecoveryTargets(delta) ?? (addressedTargets.length > 0 ? recoveryTargets : collectSurveyOperationRecoveryTargets(operations, currentContext, delta.validation.issues)), addressedTargets.length === 0 ? collectSurveyOperationRecoveryRefinements(operations, currentContext, delta.validation.issues) : []);
+		const rejectMissingLinks = (missingRetryLinks) => this.reject({
+			...delta,
+			status: "rejected",
+			validation: {
+				...delta.validation,
+				valid: false,
+				issues: [{
+					severity: "error",
+					code: "mutation-retry-link-required",
+					message: `No operations from this call were staged. Retry the complete corrected call with retryOfChangeIds: ${JSON.stringify(missingRetryLinks)} before further mutations.`
+				}]
+			}
+		}, recoveryTargets);
+		const missingRetryLinks = this.#pendingRepairs().filter((repair) => repair.requiresExplicitRetry && !retryOfChangeIds.includes(repair.changeId)).map((repair) => repair.changeId);
+		if (missingRetryLinks.length > 0 && operations.length > 0) return rejectMissingLinks(missingRetryLinks);
+		const cumulativeOperations = [...this.#draftOperations, ...delta.operations];
+		if (cumulativeOperations.length > 1e3) return this.reject(createSurveyChangeSet({
+			maxOperations: MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT,
+			operations: cumulativeOperations,
+			snapshot: currentContext,
+			summary,
+			turnId: this.turnId
+		}), recoveryTargets);
+		const beforeContext = this.#context;
+		let nextContext = beforeContext;
+		if (this.#context && delta.operations.length > 0) {
+			const execution = new SurveyOperationExecutionSession(this.#context.survey, this.#context.trustedCapabilities, this.#context.document.answerTypes);
+			for (const operation of delta.operations) execution.apply(operation);
+			execution.assertNoDanglingRemovals();
+			nextContext = createSurveyAssistantEngineContext({
+				...this.#context.document,
+				survey: execution.serialize(),
+				answerTypes: execution.getAnswerTypes()
+			}, this.#context.trustedCapabilities);
+		}
+		if (this.#baseline && nextContext) {
+			const diagnostics = getAnswerTypeChangeDiagnostics(this.#baseline.model, nextContext.model);
+			if (diagnostics.length) return this.reject({
+				...delta,
+				status: "rejected",
+				validation: {
+					...delta.validation,
+					valid: false,
+					issues: diagnostics.map((issue) => ({
+						severity: "error",
+						code: issue.code,
+						message: `${JSON.stringify(issue.path)}: ${issue.message}`
+					}))
+				}
+			}, recoveryTargets);
+		}
+		const removedRefinements = beforeContext && nextContext && delta.operations.length > 0 ? collectRemovedRecoveryTargetRefinements([...this.#unresolvedCandidates.values()].flatMap((pending) => [...pending].filter((target) => !recoveryTargets.has(target))), beforeContext, nextContext) : [];
+		const removedTargets = new Set(removedRefinements.flatMap((refinement) => refinement.targets));
+		const removalLinks = [...this.#unresolvedCandidates].filter(([id, pending]) => !retryOfChangeIds.includes(id) && [...pending].some((target) => removedTargets.has(target))).map(([id]) => id);
+		if (removalLinks.length > 0) return rejectMissingLinks(removalLinks);
+		this.#context = nextContext;
+		this.#refineRecoveryTargets(removedRefinements);
+		const priorCandidate = this.#latestChangeSetId ? this.#candidates.get(this.#latestChangeSetId) : void 0;
+		const acknowledgment = delta.operations.length === 0;
+		const reportingTargets = /* @__PURE__ */ new Set([
+			...collectOperationTargets(delta.operations, nextContext),
+			...addressedTargets,
+			...handledMutationRoutes.map(mutationRouteTarget),
+			...this.#reportingTargets
+		]);
+		const operationWarnings = [...this.#operationWarnings, ...delta.validation.warnings.flatMap((warning) => warning.operationIndex === void 0 ? [] : [{
+			...warning,
+			operationIndex: warning.operationIndex + this.#draftOperations.length
+		}])];
+		const definitionWarnings = this.#baseline && this.#context ? getIntroducedDefinitionIssues(this.#baseline.model, this.#context.model, this.#context.ui.selectedLocale).filter((issue) => issue.severity === "warning") : delta.validation.warnings.filter((warning) => warning.operationIndex === void 0);
+		const postChange = acknowledgment ? priorCandidate?.postChange : this.#context ? createPostChangeProjection(this.#context, reportingTargets, this.#baseline, cumulativeOperations.flatMap((operation) => operation.kind === "reorder-items" ? [operation.parentItemId] : [])) : void 0;
+		const verification = acknowledgment ? priorCandidate?.verification : this.#baseline && this.#context && postChange ? createChangeVerification({
+			after: this.#context,
+			before: this.#baseline,
+			operations: cumulativeOperations,
+			postChange
+		}) : void 0;
+		const registered = surveyChangeSetSchema.parse({
+			...delta,
+			operations: cumulativeOperations,
+			...acknowledgment && priorCandidate ? { summary: priorCandidate.summary } : {},
+			...postChange ? { postChange } : {},
+			...verification ? { verification } : {},
+			validation: {
+				valid: true,
+				issues: [],
+				warnings: [...operationWarnings, ...definitionWarnings],
+				normalizedOperations: cumulativeOperations
+			},
+			...this.#latestChangeSetId ? { supersedesChangeIds: [this.#latestChangeSetId] } : {}
+		});
+		this.#operationWarnings = operationWarnings;
+		this.#reportingTargets = reportingTargets;
+		this.#draftOperations = registered.operations;
+		this.#latestChangeSetId = registered.operations.length > 0 ? registered.id : void 0;
+		const resolvedTargets = /* @__PURE__ */ new Set([...recoveryTargets, ...handledMutationRoutes.map(mutationRouteTarget)]);
+		for (const [changeSetId, unresolvedTargets] of this.#unresolvedCandidates) {
+			for (const target of resolvedTargets) if (target !== "unidentified-mutation" && target !== "satisfied-mutation") unresolvedTargets.delete(target);
+			if (retryOfChangeIds.includes(changeSetId)) {
+				unresolvedTargets.delete(SATISFIED_MUTATION_TARGET);
+				if (delta.operations.length > 0) unresolvedTargets.delete(UNIDENTIFIED_MUTATION_TARGET);
+			}
+			if (unresolvedTargets.size === 0) this.#unresolvedCandidates.delete(changeSetId);
+		}
+		registered.pendingRepairs = this.#pendingRepairs();
+		this.#candidates.set(registered.id, registered);
+		return registered;
+	}
+	reject(candidate, addressedTargets = [], refinements = []) {
+		this.#assertOpen();
+		if (this.#candidates.has(candidate.id)) throw new Error(`Survey change "${candidate.id}" was registered more than once.`);
+		const registered = surveyChangeSetSchema.parse({
+			...candidate,
+			turnId: this.turnId,
+			status: "rejected",
+			validation: {
+				...candidate.validation,
+				valid: false
+			}
+		});
+		this.#refineRecoveryTargets(refinements);
+		const targets = new Set(addressedTargets);
+		if (targets.size === 0) targets.add(UNIDENTIFIED_MUTATION_TARGET);
+		this.#unresolvedCandidates.set(registered.id, targets);
+		registered.pendingRepairs = this.#pendingRepairs();
+		this.#candidates.set(registered.id, registered);
+		return registered;
+	}
+	#refineRecoveryTargets(refinements) {
+		for (const refinement of refinements) for (const unresolved of this.#unresolvedCandidates.values()) {
+			let matched = false;
+			for (const target of refinement.targets) matched = unresolved.delete(target) || matched;
+			if (matched) unresolved.add(refinement.replacement);
+		}
+	}
+	#pendingRepairs() {
+		return [...this.#unresolvedCandidates].map(([changeId, targets]) => ({
+			changeId,
+			targets: [...targets].filter((target) => target !== "unidentified-mutation" && target !== "satisfied-mutation"),
+			requiresExplicitRetry: targets.has("unidentified-mutation") || targets.has("satisfied-mutation"),
+			...targets.has("satisfied-mutation") ? { allowsAcknowledgment: true } : {}
+		}));
+	}
+	finalize(status, createdAt = (/* @__PURE__ */ new Date()).toISOString(), details = {}) {
+		if (this.#final) return this.#final;
+		const blockedChangeSetIds = [...this.#unresolvedCandidates.keys()];
+		const canAuthorize = status === "completed" && blockedChangeSetIds.length === 0 && this.#latestChangeSetId !== void 0;
+		this.#final = surveyAssistantTurnFinalSchema.parse({
+			protocolVersion: 1,
+			turnId: this.turnId,
+			status,
+			executableChangeSetIds: canAuthorize ? [this.#latestChangeSetId] : [],
+			...blockedChangeSetIds.length > 0 ? { blockedChangeSetIds } : {},
+			...details,
+			createdAt
+		});
+		return this.#final;
+	}
+	getCandidate(changeSetId) {
+		return this.#candidates.get(changeSetId);
+	}
+	get draftOperations() {
+		return this.#draftOperations;
+	}
+	get context() {
+		return this.#context;
+	}
+	get final() {
+		return this.#final;
+	}
+	#assertOpen() {
+		if (this.#final) throw new Error("Cannot register a survey change after the turn was finalized.");
+	}
+};
+//#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 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getItemLabel = (item) => {
+	if (!isRecord(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 engineContext = createSurveyAssistantEngineContext(snapshot, options.capabilities, { focusItemId: options.focusItemId });
+	const { inspection } = engineContext;
+	const model = engineContext.model;
+	const itemName = (id) => model.resolveItemEditorName(id, snapshot.ui.selectedLocale);
+	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 breadcrumbById = new Map(inspection.itemIndex.map((item) => [item.itemId, item.breadcrumb]));
+	const summarizeItem = (item) => {
+		const allVisibleText = [];
+		let visibleTextValueTruncated = false;
+		for (const entry of listLocalizationEntries(model, { itemIds: [item.id] })) {
+			if (entry.ref.scope !== "content" || model.owners.get(entry.ref.ownerId)?.itemId !== item.id) continue;
+			for (const [locale, content] of Object.entries(entry.contents)) {
+				const text = content ? getContentPlainText(content).trim() : "";
+				if (!text) continue;
+				if (text.length > MAX_VISIBLE_TEXT_CHARS) visibleTextValueTruncated = true;
+				allVisibleText.push({
+					locale,
+					ownerId: entry.ref.ownerId,
+					role: entry.ref.role,
+					text: text.length > MAX_VISIBLE_TEXT_CHARS ? `${text.slice(0, MAX_VISIBLE_TEXT_CHARS)}...` : text
+				});
+			}
+		}
+		return {
+			id: item.id,
+			editorName: itemName(item.id),
+			breadcrumb: breadcrumbById.get(item.id) ?? itemName(item.id),
+			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 slots = model.slots.definitions;
+	const requested = options.slotIds ?? (options.focusSlotId ? [options.focusSlotId] : []);
+	const selectedSlots = slots.filter((slot) => requested.includes(slot.slotId));
+	const matrixIds = new Set(selectedSlots.filter((slot) => slot.naming?.kind === "matrix").map((slot) => slot.elementId));
+	const result = {
+		existingVariableNames: slots.map((slot) => slot.variableName),
+		responseVariables: slots.filter((slot) => requested.includes(slot.slotId) || matrixIds.has(slot.elementId)).map((slot) => ({ ...slot })),
+		responseOwners: [...new Set(slots.filter((slot) => requested.includes(slot.slotId) || matrixIds.has(slot.elementId)).map((slot) => slot.itemId))].map((id) => ({
+			item: summarizeItem(itemsById.get(id)),
+			configuration: itemsById.get(id).config,
+			content: Object.fromEntries([...model.owners.values()].filter((owner) => owner.itemId === id).map((owner) => [owner.id, ownValue(ownValue(snapshot.survey.translations, snapshot.ui.selectedLocale)?.content, owner.id) ?? {}]))
+		})),
+		document: {
+			revision: snapshot.version.revision,
+			contentHash: snapshot.version.contentHash,
+			capabilityDigest: snapshot.version.capabilityDigest
+		},
+		survey: {
+			key: snapshot.survey.metadata?.surveyKey,
+			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),
+			siblingNames: siblingItems.map((item) => itemName(item.id)),
+			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-response-name" || options.purpose === "suggest-response-settings" || 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 = model.slots.definitions.filter((slot) => !requested.includes(slot.slotId) && !matrixIds.has(slot.elementId)).map((slot) => ({
+			itemId: slot.itemId,
+			itemType: itemsById.get(slot.itemId).itemType,
+			key: slot.variableName,
+			slotId: slot.slotId,
+			relationship: "survey"
+		}));
+		const allLabelExamples = rankedItems.flatMap(({ item, relationship }) => {
+			const label = getItemLabel(item);
+			return label ? [{
+				itemId: item.id,
+				itemType: item.itemType,
+				key: itemName(item.id),
+				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 = [];
+		listLocalizationEntries(model, { sourceLocale }).forEach((entry, order) => {
+			if (entry.ref.scope !== "content") return;
+			const owner = model.owners.get(entry.ref.ownerId);
+			const values = {};
+			for (const locale of relevantLocales) {
+				const content = ownValue(entry.contents, locale);
+				const text = content ? getContentPlainText(content).trim() : "";
+				if (text) setOwnValue(values, locale, text.slice(0, MAX_VISIBLE_TEXT_CHARS));
+			}
+			const sourceText = ownValue(values, sourceLocale);
+			if (!sourceText || Object.keys(values).length < 2) return;
+			const normalizedSource = sourceText.toLocaleLowerCase();
+			const score = [...sourceTokens].reduce((total, token) => total + (normalizedSource.includes(token) ? 1 : 0), 0);
+			allExamples.push({
+				itemId: owner.itemId,
+				ownerId: owner.id,
+				role: entry.ref.role,
+				values,
+				score,
+				order
+			});
+		});
+		allExamples.sort((left, right) => right.score - left.score || left.order - right.order);
+		result.translation = {
+			examples: allExamples.slice(0, MAX_TRANSLATION_EXAMPLES).map(({ itemId, ownerId, role, values }) => ({
+				itemId,
+				ownerId,
+				role,
+				values
+			})),
+			exampleCount: allExamples.length,
+			examplesTruncated: allExamples.length > MAX_TRANSLATION_EXAMPLES
+		};
+	}
+	return result;
+};
+//#endregion
+//#region src/engine/task-result-cache.ts
+const DEFAULT_TTL_MS = 9e5;
+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
+export { validateExpression as $, itemSummarySchema as A, summarizeItemIndexEntries as B, elementDetailsSchema as C, getRawSurveyItems as D, getRawSurvey as E, parseCursor as F, unique as G, summarizeOutlineNode as H, resolveItemSummary as I, expressionSchema$1 as J, buildExpressionMutationBatch as K, sliceWithCursor as L, mapOutlineById as M, mapRawItemsById as N, itemConfigDetailsSchema as O, normalizeText as P, inferExpressionReturnType$1 as Q, summarizeFocusItemNode as R, contentOwnerDetailsSchema as S, getItemIndexEntries as T, summarizeRawItem as U, summarizeItemIndexEntry as V, translationEntrySchema as W, getSurveyAssistantExpressionDiagnosticGuidance as X, analyzeSurveyAssistantExpressionReferences as Y, getIntroducedDefinitionIssues as Z, MAX_LIMIT as _, collectExpressionMutationRecoveryTargets as a, buildItemTranslationEntries as b, auditSurvey as c, buildSurveyDocumentVersion as d, createSurveyAssistantEngineContext as et, createSurveyChangeSet as f, DEFAULT_LIMIT as g, normalizeSurveyChangeOperations as h, collectExpressionMutationRecoveryRefinements as i, mapItemIndexById as j, itemMatchesQuery as k, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL as l, executeSurveyOperationsOnRawSurvey as m, buildSurveyAssistantTaskContext as n, createAssistantSurvey as nt, collectMalformedSurveyOperationRecoveryTargets as o, validateSurveyOperations as p, expressionMutationSchema as q, TurnSurveyDraft as r, getAssistantVisibilityIssues as rt, collectSurveyOperationRecoveryTargets as s, SurveyAssistantTaskResultCache as t, deriveResponseSlotTypes as tt, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT as u, buildConfigSearchText as v, findDirectChildrenByParentId as w, clampLimit as x, buildItemConfigDetails as y, summarizeItemById as z };
+
+//# sourceMappingURL=engine-D950TfvC.mjs.map