@case-framework/survey-core 0.7.0 → 0.9.0

package/build/index.mjs

@@ -1,891 +1,274 @@
-import { $ as generateId, A as DurationUnits, B as ConstExpression, C as ReservedSurveyItemTypes, D as deserializeSurveyItemPrefill, E as SurveyItemPrefillTargetType, F as TemplateDefTypes, G as FunctionExpression, H as ContextVariableType, I as deserializeTemplateValue, J as ReferenceUsageType, K as FunctionExpressionNames, L as deserializeTemplateValues, M as ValueType, N as assertResponseValue, O as prefillTargetsEqual, P as isResponseValue, Q as generateCodingKey, R as serializeTemplateValue, S as SurveyItemKey, T as SurveyItemPrefillApplyMode, U as Expression, V as ContextVariableExpression, W as ExpressionType, X as ValueReferenceMethod, Y as ValueReference, Z as createSeededRandom, _ as toItemTypeDefinitionRegistry, a as getContentPlainText, b as builtInItemCoreRegistry, c as hasRenderableRichTextContent, d as SurveyTranslations, et as shuffleArray, f as validateLocale, g as createItemTypeDefinitionRegistry, h as createItemCore, i as getAssetUsagesFromContent, j as NumberPrecision, k as serializeSurveyItemPrefill, l as isContentEmpty, m as createFullRegistry, n as ContentType, nt as structuredCloneMethod, o as getPlainTextFromRichTextContent, p as CURRENT_SURVEY_SCHEMA, q as ResponseVariableExpression, r as createRichTextContent, s as hasRenderableRichTextBlock, t as Survey, tt as shuffleIndices, u as SurveyItemTranslations, v as GroupItemCore, w as SurveyItemCore, x as isBuiltInItemType, y as PageBreakItemCore, z as serializeTemplateValues } from "./survey-BKblV5rN.mjs";
-import { SURVEY_EDITOR_ITEM_COLORS } from "./editor/colors.mjs";
-import { format } from "date-fns";
-import { enUS } from "date-fns/locale";
-//#region src/to_mirgrate/data_types/legacy-types.ts
-const isLegacyItemGroupComponent = (item) => {
-	const items = item.items;
-	return items !== void 0 && items.length > 0;
-};
-const isLegacySurveyGroupItem = (item) => {
-	const items = item.items;
-	return items !== void 0 && items.length > 0;
-};
-//#endregion
-//#region src/survey/responses/item-response.ts
-/**
-* SurveyItemResponse to store the response of a survey item.
-*/
-var SurveyItemResponse = class SurveyItemResponse {
-	itemId;
-	meta;
-	response;
-	itemType;
-	constructor(itemDef, response) {
-		this.itemId = itemDef.itemId;
-		this.response = response;
-		this.itemType = itemDef.itemType;
-	}
-	serialize() {
-		return {
-			itemId: this.itemId,
-			itemType: this.itemType,
-			meta: this.meta,
-			response: this.response?.serialize()
-		};
-	}
-	static deserialize(json) {
-		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid survey item response payload");
-		if (typeof json.itemId !== "string" || json.itemId.trim().length === 0) throw new Error("Survey item response is missing a valid itemId");
-		if (typeof json.itemType !== "string" || json.itemType.trim().length === 0) throw new Error("Survey item response is missing a valid itemType");
-		const newResponse = new SurveyItemResponse({
-			itemId: json.itemId,
-			itemType: json.itemType
-		}, json.response ? ResponseItem.deserialize(json.response) : void 0);
-		newResponse.meta = json.meta;
-		return newResponse;
-	}
-};
-var ResponseItem = class ResponseItem {
-	_slots;
-	constructor(initialValues) {
-		this._slots = new Map(initialValues ?? []);
-	}
-	get(slotId) {
-		return this._slots.get(slotId);
-	}
-	setSlotValue(slotId, slotResponse) {
-		if (slotResponse) this._slots.set(slotId, slotResponse);
-		else this._slots.delete(slotId);
-	}
-	serialize() {
-		if (this._slots.size === 0) return;
-		return { slots: Object.fromEntries(this._slots.entries()) };
-	}
-	isEmpty() {
-		return this._slots.size === 0;
-	}
-	clone() {
-		return new ResponseItem(Array.from(this._slots.entries()));
-	}
-	static deserialize(json) {
-		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid response item payload");
-		const { slots } = json;
-		if (!slots || typeof slots !== "object" || Array.isArray(slots)) throw new Error("Invalid response slots payload");
-		return new ResponseItem(Object.entries(slots).map(([slotId, slotResponse]) => {
-			if (slotId.trim().length === 0) throw new Error("Response slot id cannot be empty");
-			assertResponseValue(slotResponse, `response.slots.${slotId}`);
-			return [slotId, slotResponse];
-		}));
+import { $ as inspectAnnotated, A as slotPrefillSchema, B as ValueType, C as createCompositionSchema, Ct as calendarDaySchema, D as followUpBody, Dt as isCalendarDate, E as elementShape, Et as formatCalendarDate, F as richTextImageDimensionSchema, G as stringRecord, H as isResponseValue, I as richTextImageSourceSchema, J as boundField, K as annotated, L as surveyContentSchema, M as templateValueSchema, N as validationRuleSchema, O as itemEditorMetadataSchema, Ot as isCalendarDateUnit, P as jsonValueSchema, Q as extendObject, R as DurationUnits, S as conditionsShape, St as calendarDateToLocalDate, T as createSurveySchema, Tt as differenceCalendarDates, U as ownValue, V as assertResponseValue, W as setOwnValue, X as contentOwnerIds, Y as contentOwner, Z as expressionField, _ as hasRenderableRichTextBlock, _t as CALENDAR_DATE_UNITS, a as getLocalizationItems, at as expressionEditorConfigSchema, b as CURRENT_SURVEY_SCHEMA, bt as calendarDateFromLocalDate, c as listLocalizationEntries, ct as responseValueSchema, d as validateLocalizationRef, dt as remapExpression, et as ownedId, f as ContentType, ft as expressionArguments, g as getPlainTextFromRichTextContent, gt as visitExpression, h as getContentPlainText, ht as unreachable, i as getLocalizationEntryKey, it as transformAnnotated, j as slotTransformSchema, k as layoutPolicySchema, l as readLocalizationContent, lt as valueTypeSchema, m as getAssetUsagesFromContent, mt as transformExpression, n as getLocalizationCellKey, nt as remapAnnotated, o as hasLocalizationText, ot as expressionSchema, p as createRichTextContent, pt as operand, q as annotatedReferences, r as getLocalizationCoverage, rt as schemaAnnotation, s as isEmptySurveyLocalizationEntry, st as functionNameSchema, t as SURVEY_LOCALIZATION_SURFACES, tt as referenceId, u as resolveParticipantContent, ut as collectExpressionDependencies, v as hasRenderableRichTextContent, vt as addCalendarDate, w as createFlowItemSchema, wt as compareCalendarDates, x as CURRENT_SURVEY_SCHEMA_VERSION, xt as calendarDatePrecision, y as isContentEmpty, yt as calendarDateBounds, z as NumberPrecision } from "./localization-1lzNpyFX.mjs";
+import { $ as shuffleArray, A as isAdmissibleInDraft, B as expressionIssues, C as surveyEventSchema, D as DefinitionError, E as hasPermittedChange, F as allocateResponseVariableName, G as responseValueElements, H as functionTypeIssues, I as isValidResponseVariableName, J as FUNCTION_SIGNATURES, K as responseValuesEqual, L as suggestResponseVariableName, M as getCompositionLabel, N as ResponseSlotRegistry, O as Survey, P as RESPONSE_VARIABLE_NAME_MAX_LENGTH, Q as resolveUniqueItemKey, R as ExpressionEvaluationError, S as itemResponseMetadataSchema, T as canWriteSelection, U as inferExpressionReturnType, V as expressionTypeIssues, W as invalidResponseDomainValues, X as generateCodingKey, Y as createSeededRandom, Z as generateId, _ as SlotTransformMode, a as optionIds, b as surveyResponseSchema, c as resolvedSlotEncoding, d as exportSingleResponseSlot, et as shuffleIndices, f as decodeExportColumnId, g as META_COLUMN_ORDER, h as ExportColumnSource, i as localizedExportSlots, j as surveyLocales, k as checkDocumentBudget, l as BooleanExportValues, m as EXPORTER_PROFILE_SCHEMA_VERSION, n as getDefaultProjectionDiagnostics, o as optionMapping, p as encodeExportColumnId, q as validateResponseSlotValue, r as getDefaultProjectionIssues, s as projectSlot, t as formatProjectedValue, tt as structuredCloneMethod, u as DEFAULT_TRANSFORM, v as SURVEY_RESPONSE_SCHEMA_VERSION, w as SurveyStateGraph, x as SurveyEventTypes, y as SurveyResponse, z as evaluateExpression } from "./projection-DrLPFroE.mjs";
+import { t as strictKeyedObject } from "./keyed-object-D1yh_W5v.mjs";
+import { format } from "date-fns/format";
+import { z } from "zod";
+//#region src/json-patch.ts
+var JsonPatchError = class extends Error {
+	code;
+	path;
+	operationIndex;
+	constructor(message, code, path, operationIndex) {
+		super(message);
+		this.code = code;
+		this.path = path;
+		this.operationIndex = operationIndex;
+		this.name = "JsonPatchError";
 	}
 };
-//#endregion
-//#region src/survey/responses/response-meta.ts
-const SurveyEventTypes = {
-	openSurvey: "openSurvey",
-	pageChanged: "pageChanged",
-	responeChanged: "responeChanged",
-	languageChanged: "languageChanged"
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assertValidPointerSegment = (segment, pointer) => {
+	if (/~(?![01])/.test(segment)) throw new JsonPatchError(`Invalid JSON pointer segment "${segment}" in "${pointer}". Only "~0" and "~1" escapes are allowed.`, "invalid-json-pointer", pointer);
 };
-//#endregion
-//#region src/survey/responses/survey-response.ts
-const SURVEY_RESPONSE_SCHEMA_VERSION = 1;
-/**
-* SurveyResponse to store the responses of a survey.
-*/
-var SurveyResponse = class SurveyResponse {
-	key;
-	participantId;
-	submittedAt;
-	versionId;
-	responses;
-	events;
-	context;
-	constructor(key, versionId) {
-		this.key = key;
-		this.participantId = "";
-		this.submittedAt = 0;
-		this.versionId = versionId;
-		this.responses = /* @__PURE__ */ new Map();
-		this.events = [];
-	}
-	serialize() {
-		const items = Object.fromEntries(Array.from(this.responses.entries()).flatMap(([itemId, response]) => {
-			const serialized = response.serialize();
-			if (!serialized.response && !serialized.meta) return [];
-			return [[itemId, serialized]];
-		}));
-		return {
-			schemaVersion: 1,
-			key: this.key,
-			participantId: this.participantId,
-			submittedAt: this.submittedAt,
-			versionId: this.versionId,
-			items,
-			events: this.events,
-			context: this.context
-		};
-	}
-	static deserialize(json) {
-		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid survey response payload");
-		if (json.schemaVersion !== 1) throw new Error(`Unsupported survey response schema version: ${String(json.schemaVersion)}`);
-		if (typeof json.key !== "string" || json.key.trim().length === 0) throw new Error("Survey response is missing a valid key");
-		if (typeof json.versionId !== "string" || json.versionId.trim().length === 0) throw new Error("Survey response is missing a valid versionId");
-		if (!json.items || typeof json.items !== "object" || Array.isArray(json.items)) throw new Error("Survey response is missing a valid items object");
-		const response = new SurveyResponse(json.key, json.versionId);
-		response.participantId = json.participantId;
-		response.submittedAt = json.submittedAt;
-		response.responses = new Map(Object.entries(json.items).map(([itemId, itemResponse]) => {
-			const deserialized = SurveyItemResponse.deserialize(itemResponse);
-			if (deserialized.itemId !== itemId) throw new Error(`Survey response item key mismatch for '${itemId}'`);
-			return [itemId, deserialized];
-		}));
-		response.events = json.events ?? [];
-		response.versionId = json.versionId;
-		response.key = json.key;
-		if (json.context) {
-			if (typeof json.context !== "object" || Array.isArray(json.context)) throw new Error("Survey response context must be an object");
-			response.context = Object.fromEntries(Object.entries(json.context).map(([contextKey, value]) => {
-				assertResponseValue(value, `context.${contextKey}`);
-				return [contextKey, value];
-			}));
-		}
-		return response;
-	}
+const decodeJsonPointerSegment = (segment) => {
+	assertValidPointerSegment(segment, segment);
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
 };
-//#endregion
-//#region src/survey/responses/utils.ts
-const initValueForType = (returnType) => {
-	switch (returnType) {
-		case ValueType.string: return {
-			type: ValueType.string,
-			value: ""
-		};
-		case ValueType.number: return {
-			type: ValueType.number,
-			value: 0
-		};
-		case ValueType.boolean: return {
-			type: ValueType.boolean,
-			value: false
-		};
-		case ValueType.date: return {
-			type: ValueType.date,
-			value: Math.floor(Date.now() / 1e3)
-		};
-		case ValueType.stringArray: return {
-			type: ValueType.stringArray,
-			value: []
-		};
-		case ValueType.numberArray: return {
-			type: ValueType.numberArray,
-			value: []
-		};
-		case ValueType.dateArray: return {
-			type: ValueType.dateArray,
-			value: []
-		};
-		case ValueType.duration: return {
-			type: ValueType.duration,
-			value: 0,
-			unit: DurationUnits.seconds
-		};
-		case ValueType.reference: return {
-			type: ValueType.reference,
-			value: ""
-		};
-		case ValueType.durationArray: return {
-			type: ValueType.durationArray,
-			value: [],
-			unit: DurationUnits.seconds
-		};
-		case ValueType.referenceArray: return {
-			type: ValueType.referenceArray,
-			value: []
-		};
-		default: throw new Error("Invalid return type: " + returnType);
-	}
+const encodeJsonPointerSegment = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
+const parseJsonPointer = (pointer) => {
+	if (pointer === "") return [];
+	if (!pointer.startsWith("/")) throw new JsonPatchError(`Invalid JSON pointer "${pointer}". It must be empty or start with "/".`, "invalid-json-pointer", pointer);
+	return pointer.slice(1).split("/").map((segment) => {
+		assertValidPointerSegment(segment, pointer);
+		return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+	});
 };
-//#endregion
-//#region src/expressions/expression-evaluator.ts
-var ExpressionEvaluator = class {
-	context;
-	constructor(context) {
-		this.context = context;
-	}
-	eval(expression) {
-		if (expression === void 0) return;
-		switch (expression.type) {
-			case ExpressionType.Const: return this.evaluateConst(expression);
-			case ExpressionType.Function: return this.evaluateFunction(expression);
-			case ExpressionType.ResponseVariable: return this.evaluateResponseVariable(expression);
-			case ExpressionType.ContextVariable: return this.evaluateContextVariable(expression);
-			default: throw new Error(`Unsupported expression type: ${expression.type}`);
-		}
-	}
-	setContext(context) {
-		this.context = context;
-	}
-	evaluateConst(expression) {
-		return expression.value;
-	}
-	evaluateResponseVariable(expression) {
-		const varRef = expression.responseVariableRef;
-		switch (varRef.name) {
-			case "get": return this.context?.responses[varRef.itemId]?.response?.get(varRef.slotId);
-			case "isDefined": return {
-				type: ValueType.boolean,
-				value: this.context?.responses[varRef.itemId]?.response?.get(varRef.slotId) !== void 0
-			};
-			default: throw new Error(`Unsupported value reference method: ${varRef.name}`);
-		}
-	}
-	evaluateFunction(expression) {
-		switch (expression.functionName) {
-			case "and": return this.evaluateAnd(expression);
-			case "or": return this.evaluateOr(expression);
-			case "not": return this.evaluateNot(expression);
-			case "str_eq": return this.evaluateStrEq(expression);
-			case "eq": return this.evaluateEq(expression);
-			case "gt": return this.evaluateGt(expression);
-			case "gte": return this.evaluateGte(expression);
-			case "lt": return this.evaluateLt(expression);
-			case "lte": return this.evaluateLte(expression);
-			case "in_range": return this.evaluateInRange(expression);
-			case "sum": return this.evaluateSum(expression);
-			case "min": return this.evaluateMin(expression);
-			case "max": return this.evaluateMax(expression);
-			case "list_contains": return this.evaluateListContains(expression);
-			default: throw new Error(`Unsupported function: ${expression.functionName}`);
-		}
+const parseArrayIndex = ({ segment, arrayLength, allowAppend, allowEnd, path }) => {
+	if (segment === "-") {
+		if (allowAppend) return arrayLength;
+		throw new JsonPatchError(`JSON pointer "${path}" uses "-" where an existing array index is required.`, "invalid-array-index", path);
 	}
-	evaluateContextVariable(expression) {
-		if (!this.context?.surveyContext) return;
-		const surveyContext = this.context.surveyContext;
-		switch (expression.contextType) {
-			case ContextVariableType.Locale: return {
-				type: ValueType.string,
-				value: surveyContext.locale
-			};
-			case ContextVariableType.ParticipantFlag: {
-				if (!expression.key) return;
-				const flagKey = this.eval(expression.key);
-				if (flagKey?.type !== ValueType.string || flagKey.value === void 0) return;
-				const flagValue = surveyContext.participantFlags?.[flagKey.value];
-				switch (expression.asType) {
-					case ValueType.boolean: return {
-						type: ValueType.boolean,
-						value: flagValue !== void 0
-					};
-					case ValueType.string:
-						if (flagValue === void 0) return;
-						return {
-							type: ValueType.string,
-							value: flagValue
-						};
-					case ValueType.number: {
-						if (flagValue === void 0) return;
-						const numValue = parseFloat(flagValue);
-						return isNaN(numValue) ? void 0 : {
-							type: ValueType.number,
-							value: numValue
-						};
-					}
-					case ValueType.date: {
-						if (flagValue === void 0) return;
-						const timestamp = parseFloat(flagValue);
-						return isNaN(timestamp) ? void 0 : {
-							type: ValueType.date,
-							value: timestamp
-						};
-					}
-					default:
-						if (flagValue === void 0) return;
-						return {
-							type: ValueType.string,
-							value: flagValue
-						};
-				}
-			}
-			case ContextVariableType.CustomValue: {
-				if (!expression.key) return;
-				const customKey = this.eval(expression.key);
-				if (customKey?.type !== ValueType.string || customKey.value === void 0) return;
-				const customValue = surveyContext.customValues?.[customKey.value];
-				if (customValue === void 0) return;
-				if (expression.asType !== void 0) {
-					if (customValue?.type !== expression.asType) throw new Error(`Custom value type does not match expected type, got ${customValue?.type} and expected ${expression.asType}`);
-				}
-				return customValue;
-			}
-			case ContextVariableType.CustomExpression: {
-				if (!expression.key) return;
-				const expressionKey = this.eval(expression.key);
-				if (expressionKey?.type !== ValueType.string || expressionKey.value === void 0) return;
-				const customExpression = surveyContext.customExpressions?.[expressionKey.value];
-				if (typeof customExpression !== ExpressionType.Function || customExpression === void 0) return;
-				try {
-					const args = expression.arguments;
-					const result = customExpression(args);
-					if (expression.asType !== void 0) {
-						if (result?.type !== expression.asType) throw new Error(`Custom expression result type does not match expected type, got ${result?.type} and expected ${expression.asType}`);
-					}
-					return result;
-				} catch (error) {
-					throw new Error(`Error evaluating custom expression: ${error}`);
-				}
-			}
+	if (!/^(0|[1-9][0-9]*)$/.test(segment)) throw new JsonPatchError(`JSON pointer "${path}" uses invalid array index "${segment}".`, "invalid-array-index", path);
+	const index = Number(segment);
+	const maximum = allowEnd ? arrayLength : arrayLength - 1;
+	if (index < 0 || index > maximum) throw new JsonPatchError(`JSON pointer "${path}" array index ${index} is out of bounds.`, "array-index-out-of-bounds", path);
+	return index;
+};
+const getValueAtSegments = (document, segments, path) => {
+	let current = document;
+	for (const segment of segments) {
+		if (Array.isArray(current)) {
+			const index = parseArrayIndex({
+				segment,
+				arrayLength: current.length,
+				allowAppend: false,
+				allowEnd: false,
+				path
+			});
+			current = current[index];
+			continue;
 		}
+		if (!isRecord(current) || !hasOwn(current, segment)) throw new JsonPatchError(`JSON pointer "${path}" does not exist.`, "path-not-found", path);
+		current = current[segment];
 	}
-	evaluateAnd(expression) {
-		return {
-			type: ValueType.boolean,
-			value: expression.arguments.every((arg) => this.eval(arg)?.value === true)
-		};
-	}
-	evaluateOr(expression) {
-		return {
-			type: ValueType.boolean,
-			value: expression.arguments.some((arg) => this.eval(arg)?.value === true)
-		};
-	}
-	evaluateNot(expression) {
-		if (expression.arguments.length !== 1 || expression.arguments[0] === void 0) throw new Error(`Not function expects 1 argument, got ${expression.arguments.length}`);
-		const resolvedValue = this.eval(expression.arguments[0]);
-		if (resolvedValue?.type !== ValueType.boolean) throw new Error(`Not function expects a boolean argument, got ${resolvedValue?.type}`);
-		if (resolvedValue === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		return {
-			type: ValueType.boolean,
-			value: !resolvedValue.value
-		};
-	}
-	evaluateListContains(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`List contains function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedList = this.eval(expression.arguments[0]);
-		const resolvedItem = this.eval(expression.arguments[1]);
-		if (resolvedList === void 0 || resolvedItem === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		const allowedListTypes = [ValueType.stringArray, ValueType.referenceArray];
-		const allowedItemTypes = [ValueType.string, ValueType.reference];
-		const resolvedListType = resolvedList.type;
-		const resolvedItemType = resolvedItem.type;
-		if (!allowedListTypes.includes(resolvedListType) || !allowedItemTypes.includes(resolvedItemType)) throw new Error(`List contains function expects a string array list and a string item, got ${resolvedList?.type} and ${resolvedItem?.type}`);
-		const list = resolvedList.value;
-		const item = resolvedItem.value;
-		return {
-			type: ValueType.boolean,
-			value: list.includes(item)
-		};
-	}
-	evaluateStrEq(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`String equals function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== ValueType.string || resolvedB?.type !== ValueType.string) throw new Error(`String equals function expects strings for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value === resolvedB.value
-		};
-	}
-	evaluateEq(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`Equals function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Equals function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value === resolvedB.value
-		};
-	}
-	evaluateGt(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`Greater than function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value > resolvedB.value
-		};
-	}
-	evaluateGte(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`Greater than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value >= resolvedB.value
-		};
-	}
-	evaluateLt(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`Less than function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value < resolvedB.value
-		};
-	}
-	evaluateLte(expression) {
-		if (expression.arguments.length !== 2) throw new Error(`Less than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
-		const resolvedA = this.eval(expression.arguments[0]);
-		const resolvedB = this.eval(expression.arguments[1]);
-		if (resolvedA === void 0 || resolvedB === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
-		return {
-			type: ValueType.boolean,
-			value: resolvedA.value <= resolvedB.value
-		};
-	}
-	evaluateInRange(expression) {
-		if (expression.arguments.length !== 4) throw new Error(`In range function expects 4 arguments, got ${expression.arguments.length}`);
-		const resolvedValue = this.eval(expression.arguments[0]);
-		const resolvedMin = this.eval(expression.arguments[1]);
-		const resolvedMax = this.eval(expression.arguments[2]);
-		const resolvedInclusive = this.eval(expression.arguments[3])?.value === true;
-		if (resolvedValue === void 0 || resolvedMin === void 0 || resolvedMax === void 0) return {
-			type: ValueType.boolean,
-			value: false
-		};
-		if (resolvedValue?.type !== ValueType.number || resolvedMin?.type !== ValueType.number || resolvedMax?.type !== ValueType.number) throw new Error(`In range function expects numbers for all arguments, got ${resolvedValue?.type} and ${resolvedMin?.type} and ${resolvedMax?.type}`);
-		if (resolvedInclusive) return {
-			type: ValueType.boolean,
-			value: resolvedValue.value >= resolvedMin.value && resolvedValue.value <= resolvedMax.value
-		};
-		return {
-			type: ValueType.boolean,
-			value: resolvedValue.value > resolvedMin.value && resolvedValue.value < resolvedMax.value
-		};
-	}
-	evaluateSum(expression) {
-		if (expression.arguments.length < 1) throw new Error(`Sum function expects at least 1 argument, got ${expression.arguments.length}`);
-		return expression.arguments.reduce((sum, arg) => {
-			if (arg === void 0) return sum;
-			const resolvedValue = this.eval(arg);
-			if (resolvedValue === void 0) return sum;
-			if (resolvedValue?.type === ValueType.number) return {
-				type: ValueType.number,
-				value: sum.value + resolvedValue.value
-			};
-			throw new Error(`Sum function expects all arguments to be numbers, got ${resolvedValue?.type}`);
-		}, {
-			type: ValueType.number,
-			value: 0
-		});
-	}
-	evaluateMin(expression) {
-		if (expression.arguments.length < 1) throw new Error(`Min function expects at least 1 argument, got ${expression.arguments.length}`);
-		return expression.arguments.reduce((min, arg) => {
-			if (arg === void 0) return min;
-			const resolvedValue = this.eval(arg);
-			if (resolvedValue === void 0) return min;
-			if (resolvedValue?.type === ValueType.number) return {
-				type: ValueType.number,
-				value: Math.min(min.value, resolvedValue.value)
-			};
-			throw new Error(`Min function expects all arguments to be numbers, got ${typeof resolvedValue}`);
-		}, {
-			type: ValueType.number,
-			value: Infinity
-		});
+	return current;
+};
+const getValueAtJsonPointer = (document, pointer) => {
+	const segments = parseJsonPointer(pointer);
+	return getValueAtSegments(document, segments, pointer);
+};
+const deepEqualJson = (left, right) => {
+	if (left === right) return true;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((entry, index) => deepEqualJson(entry, right[index]));
 	}
-	evaluateMax(expression) {
-		if (expression.arguments.length < 1) throw new Error(`Max function expects at least 1 argument, got ${expression.arguments.length}`);
-		return expression.arguments.reduce((max, arg) => {
-			if (arg === void 0) return max;
-			const resolvedValue = this.eval(arg);
-			if (resolvedValue === void 0) return max;
-			if (resolvedValue?.type === ValueType.number) return {
-				type: ValueType.number,
-				value: Math.max(max.value, resolvedValue.value)
-			};
-			throw new Error(`Max function expects all arguments to be numbers, got ${typeof resolvedValue}`);
-		}, {
-			type: ValueType.number,
-			value: -Infinity
-		});
+	if (isRecord(left) || isRecord(right)) {
+		if (!isRecord(left) || !isRecord(right)) return false;
+		const leftKeys = Object.keys(left).sort();
+		const rightKeys = Object.keys(right).sort();
+		if (leftKeys.length !== rightKeys.length) return false;
+		return leftKeys.every((key, index) => key === rightKeys[index] && deepEqualJson(left[key], right[key]));
 	}
+	return false;
 };
-//#endregion
-//#region src/expressions/item-expression-registry.ts
-function getItemExpressionDefinition(definitions, expressionId) {
-	return definitions?.find((definition) => definition.id === expressionId);
-}
-function buildItemExpression(item, definitions, expressionId, params) {
-	const definition = getItemExpressionDefinition(definitions, expressionId);
-	if (!definition) throw new Error(`Unknown item expression: ${expressionId}`);
-	return definition.buildExpression(item, params);
-}
-//#endregion
-//#region src/expressions/reference-integrity.ts
-const ITEM_DISPLAY_DEPENDENCY_OWNER_SCOPE_POLICY = {
-	component: false,
-	item: true,
-	survey: false
-};
-const ITEM_DISPLAY_DEPENDENCY_SURFACE_POLICY = {
-	"display-condition": true,
-	"disabled-condition": false,
-	validation: false,
-	"prefill-condition": false,
-	"prefill-source": false,
-	"template-value": false
-};
-/**
-* Display-condition cycles are advisory because responses may be populated before visibility is
-* evaluated, including through runtime prefills that are unavailable to static survey analysis.
-* Concrete expression integrity failures remain blocking. This exhaustive map is the source of
-* truth copied onto every analyzer-produced diagnostic.
-*/
-const SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY = {
-	"invalid-expression": {
-		category: "reference-integrity",
-		disposition: "blocking"
-	},
-	"unknown-response-ref": {
-		category: "reference-integrity",
-		disposition: "blocking"
-	},
-	"expression-reference-type-mismatch": {
-		category: "reference-integrity",
-		disposition: "blocking"
-	},
-	"unknown-reference-value": {
-		category: "reference-integrity",
-		disposition: "blocking"
-	},
-	"display-condition-cycle": {
-		category: "display-dependency",
-		disposition: "advisory"
-	}
-};
-const createExpressionReferenceDiagnostic = (diagnostic) => ({
-	...diagnostic,
-	...SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY[diagnostic.code]
-});
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const isJsonExpression = (value) => isRecord$1(value) && typeof value.type === "string";
-const collectItemExpressionLocations = (item) => {
-	const locations = [];
-	const add = (expression, location, ownerScope, surface) => {
-		if (!isJsonExpression(expression)) return;
-		locations.push({
-			expression,
-			location,
-			ownerItemId: item.id,
-			ownerItemKey: item.key,
-			ownerScope,
-			surface
+const applyAdd = (document, path, value) => {
+	const segments = parseJsonPointer(path);
+	if (segments.length === 0) return structuredCloneMethod(value);
+	const parentSegments = segments.slice(0, -1);
+	const key = segments[segments.length - 1];
+	const parent = getValueAtSegments(document, parentSegments, path);
+	if (Array.isArray(parent)) {
+		const index = parseArrayIndex({
+			segment: key,
+			arrayLength: parent.length,
+			allowAppend: true,
+			allowEnd: true,
+			path
 		});
-	};
-	add(item.displayConditions?.root, "displayConditions.root", "item", "display-condition");
-	for (const [componentId, expression] of Object.entries(item.displayConditions?.components ?? {})) add(expression, `displayConditions.components.${componentId}`, "component", "display-condition");
-	for (const [componentId, expression] of Object.entries(item.disabledConditions?.components ?? {})) add(expression, `disabledConditions.components.${componentId}`, "component", "disabled-condition");
-	for (const [validationKey, expression] of Object.entries(item.validations ?? {})) add(expression, `validations.${validationKey}`, "item", "validation");
-	for (const [prefillIndex, prefill] of (item.prefills ?? []).entries()) {
-		const prefillId = prefill.id || String(prefillIndex);
-		add(prefill.when, `prefills.${prefillId}.when`, "item", "prefill-condition");
-		if (prefill.source.type === "expression") add(prefill.source.expression, `prefills.${prefillId}.source.expression`, "item", "prefill-source");
-	}
-	return locations;
-};
-const collectSurveyExpressionLocations = (survey) => [...survey.surveyItems.flatMap(collectItemExpressionLocations), ...Object.entries(survey.templateValues ?? {}).flatMap(([templateKey, templateValue]) => templateValue.expression ? [{
-	expression: templateValue.expression,
-	location: `templateValues.${templateKey}.expression`,
-	ownerScope: "survey",
-	surface: "template-value"
-}] : [])];
-const candidateRefs = (unknownRef, availableRefs) => {
-	let parsed;
-	try {
-		parsed = new ValueReference(unknownRef);
-	} catch {
-		return availableRefs.slice(0, 5);
-	}
-	const sameItemAndMethod = availableRefs.filter((candidate) => {
-		try {
-			const candidateRef = new ValueReference(candidate);
-			return candidateRef.itemId === parsed?.itemId && candidateRef.name === parsed?.name;
-		} catch {
-			return false;
-		}
-	});
-	return (sameItemAndMethod.length > 0 ? sameItemAndMethod : availableRefs).slice(0, 5);
-};
-const findCyclicItemDisplayDependencyEdges = ({ edges, itemIds }) => {
-	const adjacency = new Map(itemIds.map((itemId) => [itemId, /* @__PURE__ */ new Set()]));
-	const reverseAdjacency = new Map(itemIds.map((itemId) => [itemId, /* @__PURE__ */ new Set()]));
-	for (const edge of edges) {
-		adjacency.get(edge.fromItemId)?.add(edge.toItemId);
-		reverseAdjacency.get(edge.toItemId)?.add(edge.fromItemId);
-	}
-	const finishOrder = [];
-	const visited = /* @__PURE__ */ new Set();
-	for (const startItemId of itemIds) {
-		if (visited.has(startItemId)) continue;
-		const stack = [{
-			expanded: false,
-			itemId: startItemId
-		}];
-		while (stack.length > 0) {
-			const current = stack.pop();
-			if (!current) break;
-			if (current.expanded) {
-				finishOrder.push(current.itemId);
-				continue;
-			}
-			if (visited.has(current.itemId)) continue;
-			visited.add(current.itemId);
-			stack.push({
-				expanded: true,
-				itemId: current.itemId
-			});
-			const dependencies = [...adjacency.get(current.itemId) ?? []];
-			for (let index = dependencies.length - 1; index >= 0; index -= 1) {
-				const dependencyId = dependencies[index];
-				if (visited.has(dependencyId)) continue;
-				stack.push({
-					expanded: false,
-					itemId: dependencyId
-				});
-			}
-		}
+		parent.splice(index, 0, structuredCloneMethod(value));
+		return document;
 	}
-	const componentByItemId = /* @__PURE__ */ new Map();
-	const componentMembers = /* @__PURE__ */ new Map();
-	for (const startItemId of finishOrder.reverse()) {
-		if (componentByItemId.has(startItemId)) continue;
-		const componentId = componentMembers.size;
-		const members = [];
-		const stack = [startItemId];
-		componentByItemId.set(startItemId, componentId);
-		while (stack.length > 0) {
-			const itemId = stack.pop();
-			if (!itemId) break;
-			members.push(itemId);
-			for (const dependencyOwnerId of reverseAdjacency.get(itemId) ?? []) {
-				if (componentByItemId.has(dependencyOwnerId)) continue;
-				componentByItemId.set(dependencyOwnerId, componentId);
-				stack.push(dependencyOwnerId);
-			}
-		}
-		componentMembers.set(componentId, members.sort());
-	}
-	return edges.flatMap((edge) => {
-		const componentId = componentByItemId.get(edge.fromItemId);
-		if (componentId === void 0 || componentId !== componentByItemId.get(edge.toItemId)) return [];
-		const cycleItemIds = componentMembers.get(componentId) ?? [];
-		if (edge.fromItemId !== edge.toItemId && cycleItemIds.length < 2) return [];
-		return [{
-			edge,
-			cycleItemIds
-		}];
+	if (!isRecord(parent)) throw new JsonPatchError(`JSON pointer "${path}" parent is not an object or array.`, "invalid-target-parent", path);
+	Object.defineProperty(parent, key, {
+		configurable: true,
+		enumerable: true,
+		value: structuredCloneMethod(value),
+		writable: true
 	});
+	return document;
 };
-const inferExpressionType = (expression, slots) => {
-	if (!expression) return void 0;
-	if (expression.type === ExpressionType.Const) return expression.value?.type;
-	if (expression.type === ExpressionType.ResponseVariable) return slots.get(expression.variableRef)?.valueType;
-	if (expression.type === ExpressionType.ContextVariable) return expression.contextType === "locale" ? ValueType.string : expression.asType;
-	switch (expression.functionName) {
-		case "and":
-		case "or":
-		case "not":
-		case "eq":
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte":
-		case "in_range":
-		case "list_contains":
-		case "str_eq":
-		case "date_eq": return ValueType.boolean;
-		case "sum":
-		case "min":
-		case "max": return ValueType.number;
-	}
-};
-const itemTypeForList = (type) => {
-	switch (type) {
-		case ValueType.stringArray: return ValueType.string;
-		case ValueType.referenceArray: return ValueType.reference;
-		case ValueType.numberArray: return ValueType.number;
-		case ValueType.dateArray: return ValueType.date;
-		case ValueType.durationArray: return ValueType.duration;
-		default: return;
-	}
-};
-const inspectFunctionReferenceCompatibility = ({ diagnostics, expression, location, slots }) => {
-	if (expression.type !== ExpressionType.Function) return;
-	expression.arguments.forEach((argument) => {
-		if (argument) inspectFunctionReferenceCompatibility({
-			diagnostics,
-			expression: argument,
-			location,
-			slots
-		});
-	});
-	const [left, right] = expression.arguments;
-	const leftType = inferExpressionType(left, slots);
-	const rightType = inferExpressionType(right, slots);
-	if (expression.functionName === "list_contains" ? Boolean(leftType && rightType && itemTypeForList(leftType) !== rightType) : expression.functionName === "eq" ? Boolean(leftType && rightType && leftType !== rightType) : false) diagnostics.push({
-		code: "expression-reference-type-mismatch",
-		message: `${location.location} compares incompatible values (${leftType} and ${rightType}).`,
-		location: location.location,
-		ownerItemId: location.ownerItemId,
-		ownerItemKey: location.ownerItemKey
-	});
-	if (expression.functionName !== "eq" && expression.functionName !== "list_contains") return;
-	const pairs = [[left, right], [right, left]];
-	for (const [variable, constant] of pairs) {
-		if (variable?.type !== ExpressionType.ResponseVariable || constant?.type !== ExpressionType.Const || constant.value?.type !== ValueType.reference) continue;
-		const slot = slots.get(variable.variableRef);
-		if (slot?.allowedReferenceValues && !slot.allowedReferenceValues.includes(constant.value.value)) diagnostics.push({
-			code: "unknown-reference-value",
-			message: `${location.location} compares "${variable.variableRef}" with missing option "${constant.value.value}".`,
-			location: location.location,
-			ownerItemId: location.ownerItemId,
-			ownerItemKey: location.ownerItemKey,
-			reference: variable.variableRef,
-			referenceValue: constant.value.value,
-			candidates: slot.allowedReferenceValues.slice(0, 5)
+const applyRemove = (document, path) => {
+	const segments = parseJsonPointer(path);
+	if (segments.length === 0) throw new JsonPatchError("Removing the document root is not supported.", "remove-root", path);
+	const parentSegments = segments.slice(0, -1);
+	const key = segments[segments.length - 1];
+	const parent = getValueAtSegments(document, parentSegments, path);
+	if (Array.isArray(parent)) {
+		const index = parseArrayIndex({
+			segment: key,
+			arrayLength: parent.length,
+			allowAppend: false,
+			allowEnd: false,
+			path
 		});
+		const [removedValue] = parent.splice(index, 1);
+		return {
+			document,
+			removedValue
+		};
 	}
+	if (!isRecord(parent) || !hasOwn(parent, key)) throw new JsonPatchError(`JSON pointer "${path}" does not exist.`, "path-not-found", path);
+	const removedValue = parent[key];
+	delete parent[key];
+	return {
+		document,
+		removedValue
+	};
+};
+const applyReplace = (document, path, value) => {
+	const segments = parseJsonPointer(path);
+	if (segments.length === 0) return structuredCloneMethod(value);
+	getValueAtSegments(document, segments, path);
+	applyRemove(document, path);
+	return applyAdd(document, path, value);
+};
+const assertMoveTargetIsNotDescendant = (from, path) => {
+	if (from === "" || path === from || !path.startsWith(`${from}/`)) return;
+	throw new JsonPatchError(`JSON Patch cannot move "${from}" into its own descendant "${path}".`, "move-into-descendant", path);
 };
-const analyzeSurveyExpressionReferences = ({ responseSlots, survey }) => {
-	const slots = new Map(responseSlots.map((slot) => [slot.ref, slot]));
-	const availableRefs = responseSlots.map((slot) => slot.ref);
-	const diagnostics = [];
-	const surveyItemIds = survey.surveyItems.map((item) => item.id);
-	const surveyItemIdSet = new Set(surveyItemIds);
-	const itemDisplayDependencyEdges = [];
-	for (const location of collectSurveyExpressionLocations(survey)) {
-		let parsed;
+const applyJsonPatch = (document, operations) => {
+	let patchedDocument = structuredCloneMethod(document);
+	operations.forEach((operation, operationIndex) => {
 		try {
-			parsed = Expression.deserialize(location.expression);
+			switch (operation.op) {
+				case "add":
+					patchedDocument = applyAdd(patchedDocument, operation.path, operation.value);
+					break;
+				case "remove":
+					patchedDocument = applyRemove(patchedDocument, operation.path).document;
+					break;
+				case "replace":
+					patchedDocument = applyReplace(patchedDocument, operation.path, operation.value);
+					break;
+				case "move": {
+					assertMoveTargetIsNotDescendant(operation.from, operation.path);
+					if (operation.from === operation.path) break;
+					const { document: withoutValue, removedValue } = applyRemove(patchedDocument, operation.from);
+					patchedDocument = applyAdd(withoutValue, operation.path, removedValue);
+					break;
+				}
+				case "copy": {
+					const value = getValueAtJsonPointer(patchedDocument, operation.from);
+					patchedDocument = applyAdd(patchedDocument, operation.path, value);
+					break;
+				}
+				case "test": {
+					const value = getValueAtJsonPointer(patchedDocument, operation.path);
+					if (!deepEqualJson(value, operation.value)) throw new JsonPatchError(`JSON Patch test failed at "${operation.path}".`, "test-failed", operation.path);
+					break;
+				}
+			}
 		} catch (error) {
-			diagnostics.push({
-				code: "invalid-expression",
-				message: `${location.location} contains invalid expression JSON: ${error instanceof Error ? error.message : String(error)}`,
-				location: location.location,
-				ownerItemId: location.ownerItemId,
-				ownerItemKey: location.ownerItemKey
-			});
-			continue;
-		}
-		for (const ref of parsed?.responseVariableRefs ?? []) {
-			const reference = ref.toString();
-			if (location.ownerItemId && ITEM_DISPLAY_DEPENDENCY_OWNER_SCOPE_POLICY[location.ownerScope] && ITEM_DISPLAY_DEPENDENCY_SURFACE_POLICY[location.surface] && surveyItemIdSet.has(ref.itemId)) itemDisplayDependencyEdges.push({
-				fromItemId: location.ownerItemId,
-				location,
-				reference,
-				toItemId: ref.itemId
-			});
-			if (!slots.has(reference)) diagnostics.push({
-				code: "unknown-response-ref",
-				message: `${location.location} references unknown response slot "${reference}".`,
-				location: location.location,
-				ownerItemId: location.ownerItemId,
-				ownerItemKey: location.ownerItemKey,
-				reference,
-				candidates: candidateRefs(reference, availableRefs)
-			});
-		}
-		inspectFunctionReferenceCompatibility({
-			diagnostics,
-			expression: location.expression,
-			location,
-			slots
-		});
-	}
-	for (const { cycleItemIds, edge } of findCyclicItemDisplayDependencyEdges({
-		edges: itemDisplayDependencyEdges,
-		itemIds: surveyItemIds
-	})) {
-		const isSelfReference = edge.fromItemId === edge.toItemId;
-		diagnostics.push({
-			code: "display-condition-cycle",
-			message: isSelfReference ? `${edge.location.location} for item "${edge.fromItemId}" references its own response "${edge.reference}", creating a circular display dependency.` : `${edge.location.location} for item "${edge.fromItemId}" references item "${edge.toItemId}" within a circular display dependency among ${cycleItemIds.map((itemId) => `"${itemId}"`).join(", ")}.`,
-			location: edge.location.location,
-			ownerItemId: edge.location.ownerItemId,
-			ownerItemKey: edge.location.ownerItemKey,
-			reference: edge.reference
-		});
-	}
-	return diagnostics.map(createExpressionReferenceDiagnostic);
-};
-const expressionReferenceDiagnosticKey = (diagnostic) => [
-	diagnostic.code,
-	diagnostic.ownerItemId ?? "survey",
-	diagnostic.location,
-	diagnostic.reference ?? "",
-	diagnostic.referenceValue ?? ""
-].join("\0");
-const findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories = ({ after, before }) => {
-	const existing = new Set(before.map(expressionReferenceDiagnosticKey));
-	return after.filter((diagnostic) => !existing.has(expressionReferenceDiagnosticKey(diagnostic)));
-};
-const isBlockingSurveyExpressionReferenceDiagnostic = (diagnostic) => {
-	switch (diagnostic.disposition) {
-		case "blocking": return true;
-		case "advisory": return false;
-		default: return true;
-	}
-};
-const findIntroducedBlockingExpressionReferenceDiagnostics = ({ after, before }) => findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories({
-	after,
-	before
-}).filter(isBlockingSurveyExpressionReferenceDiagnostic);
-const replaceResponseVariableReferences = (value, replacements) => {
-	let changed = false;
-	const visit = (current) => {
-		if (Array.isArray(current)) return current.map(visit);
-		if (!isRecord$1(current)) return current;
-		const next = Object.fromEntries(Object.entries(current).map(([key, entry]) => [key, visit(entry)]));
-		if (next.type === ExpressionType.ResponseVariable && typeof next.variableRef === "string" && replacements[next.variableRef]) {
-			next.variableRef = replacements[next.variableRef];
-			changed = true;
+			if (error instanceof JsonPatchError) throw new JsonPatchError(error.message, error.code, error.path, operationIndex);
+			throw error;
 		}
-		return next;
-	};
-	const rewritten = visit(value);
+	});
+	return patchedDocument;
+};
+//#endregion
+//#region src/expressions/shortcuts/selection.ts
+/**
+* Build a selected-option test joined with `not(ownerState.disabled)` for that option.
+* `multiple` chooses membership instead of equality. The result is an ordinary expression tree;
+* no shortcut node is persisted or handled specially by the evaluator.
+*/
+function selectedAndEnabled(selection, optionId, multiple) {
 	return {
-		changed,
-		value: rewritten
+		type: "function",
+		functionName: "and",
+		arguments: [{
+			type: "function",
+			functionName: multiple ? "list_contains" : "eq",
+			arguments: [selection, {
+				type: "const",
+				value: {
+					type: "reference",
+					value: optionId
+				}
+			}]
+		}, {
+			type: "function",
+			functionName: "not",
+			arguments: [{
+				type: "ownerState",
+				state: "disabled",
+				targetRef: { ownerId: optionId }
+			}]
+		}]
 	};
-};
-const responseValueReferenceIds = (values) => values?.flatMap((value) => value.type === ValueType.reference ? [value.value] : value.type === ValueType.referenceArray ? value.value : []);
+}
+//#endregion
+//#region src/survey/utils/group-utils.ts
+/**
+* Shared utilities for array operations.
+*/
+/**
+* Swap two elements in an array by index.
+* @returns A new array with the elements swapped
+*/
+function swapArrayElements(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	[result[fromIndex], result[toIndex]] = [result[toIndex], result[fromIndex]];
+	return result;
+}
+/**
+* Move an element from one index to another.
+* @returns A new array with the element moved
+*/
+function moveArrayElement(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	const [moved] = result.splice(fromIndex, 1);
+	result.splice(toIndex, 0, moved);
+	return result;
+}
 //#endregion
 //#region src/expressions/editors/expression-editor.ts
+const constantNode = (value, editorConfig) => {
+	const node = expressionSchema.parse({
+		type: "const",
+		value,
+		editorConfig
+	});
+	if (node.type !== "const") throw new Error("Expected constant node");
+	return node;
+};
+/** Editor-state builders produce the canonical JSON tree, never runtime wrappers. */
+const createFunctionExpression = (functionName, args, editorConfig) => ({
+	type: "function",
+	functionName,
+	arguments: expressionArguments(args),
+	editorConfig
+});
+const contextNode = (contextType, key, args, asType, editorConfig) => ({
+	type: "contextVariable",
+	contextType,
+	...key ? { key } : {},
+	...args ? { arguments: expressionArguments(args) } : {},
+	asType,
+	editorConfig
+});
 var ExpressionEditor = class {
 	returnType;
 	_editorConfig;
@@ -912,7 +295,7 @@ var ConstStringArrayEditor = class extends ExpressionEditor {
 		this._values = values;
 	}
 	getExpression() {
-		return new ConstExpression({
+		return constantNode({
 			type: ValueType.stringArray,
 			value: this._values
 		}, this._editorConfig);
@@ -933,7 +316,7 @@ var ConstStringEditor = class extends ExpressionEditor {
 		this._value = value;
 	}
 	getExpression() {
-		return new ConstExpression({
+		return constantNode({
 			type: ValueType.string,
 			value: this._value
 		}, this._editorConfig);
@@ -954,7 +337,7 @@ var ConstNumberEditor = class extends ExpressionEditor {
 		this._value = value;
 	}
 	getExpression() {
-		return new ConstExpression({
+		return constantNode({
 			type: ValueType.number,
 			value: this._value
 		}, this._editorConfig);
@@ -975,7 +358,7 @@ var ConstBooleanEditor = class extends ExpressionEditor {
 		this._value = value;
 	}
 	getExpression() {
-		return new ConstExpression({
+		return constantNode({
 			type: ValueType.boolean,
 			value: this._value
 		}, this._editorConfig);
@@ -996,8 +379,8 @@ var ConstDateEditor = class extends ExpressionEditor {
 		this._value = value;
 	}
 	getExpression() {
-		const value = Math.floor(this._value.getTime() / 1e3);
-		return new ConstExpression({
+		const value = this._value;
+		return constantNode({
 			type: ValueType.date,
 			value
 		}, this._editorConfig);
@@ -1018,7 +401,7 @@ var ConstNumberArrayEditor = class extends ExpressionEditor {
 		this._values = values;
 	}
 	getExpression() {
-		return new ConstExpression({
+		return constantNode({
 			type: ValueType.numberArray,
 			value: this._values
 		}, this._editorConfig);
@@ -1039,31 +422,44 @@ var ConstDateArrayEditor = class extends ExpressionEditor {
 		this._values = values;
 	}
 	getExpression() {
-		const value = this._values.map((date) => Math.floor(date.getTime() / 1e3));
-		return new ConstExpression({
+		const value = this._values;
+		return constantNode({
 			type: ValueType.dateArray,
 			value
 		}, this._editorConfig);
 	}
 };
 var ResponseVariableEditor = class extends ExpressionEditor {
-	_variableName;
-	_variableRef;
-	constructor(variableName, variableType, editorConfig) {
+	variableRef;
+	constructor(variableRef, variableType, editorConfig) {
 		super();
-		this._variableName = variableName;
-		this._variableRef = new ValueReference(variableName);
+		this.variableRef = variableRef;
 		this._editorConfig = editorConfig;
-		this.returnType = variableType;
+		this.returnType = variableRef.method === "isDefined" ? ValueType.boolean : variableType;
 	}
-	get variableName() {
-		return this._variableName;
+	getExpression() {
+		return {
+			type: "responseVariable",
+			variableRef: { ...this.variableRef },
+			editorConfig: this._editorConfig
+		};
 	}
-	get variableRef() {
-		return this._variableRef;
+};
+var DisabledStateEditor = class extends ExpressionEditor {
+	ownerId;
+	returnType = ValueType.boolean;
+	constructor(ownerId, editorConfig) {
+		super();
+		this.ownerId = ownerId;
+		this._editorConfig = editorConfig;
 	}
 	getExpression() {
-		return new ResponseVariableExpression(this._variableName, this._editorConfig);
+		return {
+			type: "ownerState",
+			state: "disabled",
+			targetRef: { ownerId: this.ownerId },
+			editorConfig: this._editorConfig
+		};
 	}
 };
 var ContextVariableEditor = class extends ExpressionEditor {
@@ -1080,48 +476,48 @@ var ContextVariableEditor = class extends ExpressionEditor {
 		this._editorConfig = editorConfig;
 	}
 	getExpression() {
-		return new ContextVariableExpression(this._contextType, this._key?.getExpression(), this._args?.map((arg) => arg.getExpression()), this._asType, this._editorConfig);
+		return contextNode(this._contextType, this._key?.getExpression(), this._args?.map((arg) => arg.getExpression()), this._asType, this._editorConfig);
 	}
 };
 var CtxLocaleEditor = class extends ContextVariableEditor {
 	returnType = ValueType.string;
 	constructor(editorConfig) {
-		super(ContextVariableType.Locale, void 0, void 0, ValueType.string, editorConfig);
+		super("locale", void 0, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxCurrentDateEditor = class extends ContextVariableEditor {
+	returnType = ValueType.date;
+	constructor(editorConfig) {
+		super("currentDate", void 0, void 0, ValueType.date, editorConfig);
 	}
 };
 var CtxPFlagIsDefinedEditor = class extends ContextVariableEditor {
 	returnType = ValueType.boolean;
 	constructor(key, editorConfig) {
-		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.boolean, editorConfig);
+		super("participantFlag", key, void 0, ValueType.boolean, editorConfig);
 	}
 };
 var CtxPFlagStringEditor = class extends ContextVariableEditor {
 	returnType = ValueType.string;
 	constructor(key, editorConfig) {
-		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.string, editorConfig);
+		super("participantFlag", key, void 0, ValueType.string, editorConfig);
 	}
 };
 var CtxPFlagNumEditor = class extends ContextVariableEditor {
 	returnType = ValueType.number;
 	constructor(key, editorConfig) {
-		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.number, editorConfig);
+		super("participantFlag", key, void 0, ValueType.number, editorConfig);
 	}
 };
 var CtxPFlagDateEditor = class extends ContextVariableEditor {
 	returnType = ValueType.date;
 	constructor(key, editorConfig) {
-		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.date, editorConfig);
+		super("participantFlag", key, void 0, ValueType.date, editorConfig);
 	}
 };
 var CtxCustomValueEditor = class extends ContextVariableEditor {
 	constructor(key, asType, editorConfig) {
-		super(ContextVariableType.CustomValue, key, void 0, asType, editorConfig);
-		this.returnType = asType;
-	}
-};
-var CtxCustomExpressionEditor = class extends ContextVariableEditor {
-	constructor(key, args, asType, editorConfig) {
-		super(ContextVariableType.CustomExpression, key, args, asType, editorConfig);
+		super("customValue", key, void 0, asType, editorConfig);
 		this.returnType = asType;
 	}
 };
@@ -1146,10 +542,7 @@ var GroupExpressionEditor = class extends ExpressionEditor {
 		this._args[position] = arg;
 	}
 	swapArgs(activeIndex, overIndex) {
-		const newOrder = [...this._args];
-		newOrder.splice(activeIndex, 1);
-		newOrder.splice(overIndex, 0, this._args[activeIndex]);
-		this._args = newOrder;
+		this._args = moveArrayElement(this._args, activeIndex, overIndex);
 	}
 };
 var AndExpressionEditor = class extends GroupExpressionEditor {
@@ -1159,7 +552,7 @@ var AndExpressionEditor = class extends GroupExpressionEditor {
 		super(args, editorConfig);
 	}
 	getExpression() {
-		return new FunctionExpression("and", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		return createFunctionExpression("and", this.args.map((arg) => arg.getExpression()), this._editorConfig);
 	}
 };
 var OrExpressionEditor = class extends GroupExpressionEditor {
@@ -1169,7 +562,7 @@ var OrExpressionEditor = class extends GroupExpressionEditor {
 		super(args, editorConfig);
 	}
 	getExpression() {
-		return new FunctionExpression("or", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		return createFunctionExpression("or", this.args.map((arg) => arg.getExpression()), this._editorConfig);
 	}
 };
 var StrListContainsExpressionEditor = class extends ExpressionEditor {
@@ -1197,7 +590,7 @@ var StrListContainsExpressionEditor = class extends ExpressionEditor {
 		this._item = item;
 	}
 	getExpression() {
-		return new FunctionExpression("list_contains", [this._list?.getExpression(), this._item?.getExpression()], this._editorConfig);
+		return createFunctionExpression("list_contains", [this._list?.getExpression(), this._item?.getExpression()], this._editorConfig);
 	}
 };
 var StrEqExpressionEditor = class extends ExpressionEditor {
@@ -1223,7 +616,7 @@ var StrEqExpressionEditor = class extends ExpressionEditor {
 		this._b = b;
 	}
 	getExpression() {
-		return new FunctionExpression("str_eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("str_eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var EqExpressionEditor = class extends ExpressionEditor {
@@ -1249,7 +642,7 @@ var EqExpressionEditor = class extends ExpressionEditor {
 		this._b = b;
 	}
 	getExpression() {
-		return new FunctionExpression("eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var GtExpressionEditor = class extends ExpressionEditor {
@@ -1275,7 +668,7 @@ var GtExpressionEditor = class extends ExpressionEditor {
 		this._b = b;
 	}
 	getExpression() {
-		return new FunctionExpression("gt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("gt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var GteExpressionEditor = class extends ExpressionEditor {
@@ -1301,7 +694,7 @@ var GteExpressionEditor = class extends ExpressionEditor {
 		this._b = b;
 	}
 	getExpression() {
-		return new FunctionExpression("gte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("gte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var LtExpressionEditor = class extends ExpressionEditor {
@@ -1327,7 +720,7 @@ var LtExpressionEditor = class extends ExpressionEditor {
 		this._b = b;
 	}
 	getExpression() {
-		return new FunctionExpression("lt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("lt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var LteExpressionEditor = class extends ExpressionEditor {
@@ -1353,7 +746,7 @@ var LteExpressionEditor = class extends ExpressionEditor {
 		this._a = a;
 	}
 	getExpression() {
-		return new FunctionExpression("lte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+		return createFunctionExpression("lte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
 	}
 };
 var InRangeExpressionEditor = class extends ExpressionEditor {
@@ -1371,7 +764,7 @@ var InRangeExpressionEditor = class extends ExpressionEditor {
 		this._editorConfig = editorConfig;
 	}
 	getExpression() {
-		return new FunctionExpression("in_range", [
+		return createFunctionExpression("in_range", [
 			this.value?.getExpression(),
 			this.min?.getExpression(),
 			this.max?.getExpression(),
@@ -1385,7 +778,7 @@ var SumExpressionEditor = class extends GroupExpressionEditor {
 		super(args, editorConfig);
 	}
 	getExpression() {
-		return new FunctionExpression("sum", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		return createFunctionExpression("sum", this.args.map((arg) => arg.getExpression()), this._editorConfig);
 	}
 };
 var MinExpressionEditor = class extends GroupExpressionEditor {
@@ -1394,7 +787,7 @@ var MinExpressionEditor = class extends GroupExpressionEditor {
 		super(args, editorConfig);
 	}
 	getExpression() {
-		return new FunctionExpression("min", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		return createFunctionExpression("min", this.args.map((arg) => arg.getExpression()), this._editorConfig);
 	}
 };
 var MaxExpressionEditor = class extends GroupExpressionEditor {
@@ -1403,7 +796,7 @@ var MaxExpressionEditor = class extends GroupExpressionEditor {
 		super(args, editorConfig);
 	}
 	getExpression() {
-		return new FunctionExpression("max", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		return createFunctionExpression("max", this.args.map((arg) => arg.getExpression()), this._editorConfig);
 	}
 };
 //#endregion
@@ -1453,6 +846,9 @@ const response_date_array = (valueRef) => {
 const ctx_locale = () => {
 	return new CtxLocaleEditor();
 };
+const ctx_current_date = () => {
+	return new CtxCurrentDateEditor();
+};
 const ctx_pflag_is_defined = (key) => {
 	return new CtxPFlagIsDefinedEditor(key);
 };
@@ -1468,9 +864,6 @@ const ctx_pflag_date = (key) => {
 const ctx_custom_value = (key, dType) => {
 	return new CtxCustomValueEditor(key, dType);
 };
-const ctx_custom_expression = (key, args, returnType) => {
-	return new CtxCustomExpressionEditor(key, args, returnType);
-};
 const and = (...args) => {
 	return new AndExpressionEditor(args);
 };
@@ -1480,6 +873,14 @@ const or = (...args) => {
 const str_list_contains = (list, item) => {
 	return new StrListContainsExpressionEditor(list, item);
 };
+/** Number of list entries, or of entries that also appear in `filter` (e.g. listed options). */
+const list_count = (list, filter) => new FunctionCallEditor("list_count", filter ? [list, filter] : [list], ValueType.number);
+/** `then` when the condition is true, otherwise `otherwise` (missing when omitted). */
+const if_else = (condition, then, otherwise) => new FunctionCallEditor("if", otherwise ? [
+	condition,
+	then,
+	otherwise
+] : [condition, then], then.returnType ?? otherwise?.returnType);
 const str_eq = (a, b) => {
 	return new StrEqExpressionEditor(a, b);
 };
@@ -1510,757 +911,827 @@ const min = (...args) => {
 const max = (...args) => {
 	return new MaxExpressionEditor(args);
 };
-//#endregion
-//#region src/engine/engine.ts
-var SurveyEngineCore = class {
-	surveyDef;
-	renderedSurveyTree;
-	context;
-	locale;
-	sessionSeedValue;
-	responses;
-	prefills;
-	_events;
-	_openedAt;
-	dateLocales;
-	prefillEnvironment;
-	cache;
-	constructor(survey, context, prefills, dateLocales, options) {
-		this._openedAt = this._getTimestamp();
-		this.sessionSeedValue = generateId();
-		this.surveyDef = survey;
-		this.context = context ? context : { locale: "en" };
-		this.locale = this.context.locale;
-		this.prefills = prefills ? prefills.reduce((acc, p) => {
-			acc[p.itemId] = SurveyItemResponse.deserialize(p);
-			return acc;
-		}, {}) : void 0;
-		this.prefillEnvironment = options?.prefillEnvironment;
-		this.dateLocales = dateLocales || [{
-			code: "en",
-			locale: enUS
-		}];
-		this.responses = this.initResponseObject(this.surveyDef.surveyItems);
-		this.initCache();
-		this.applyConfiguredPrefills();
-		this.evalExpressions();
-		if (!survey.rootItem) throw new Error("constructor: root item not found");
-		this.renderedSurveyTree = this.renderGroup(survey.rootItem);
-		this._events = [{
-			type: SurveyEventTypes.openSurvey,
-			timestamp: this._getTimestamp(),
-			value: this.context.locale
-		}];
-	}
-	setContext(context) {
-		this.context = context;
-	}
-	getDateLocales() {
-		return this.dateLocales.slice();
-	}
-	getCurrentDateLocale() {
-		const found = this.dateLocales.find((dl) => dl.code === this.locale);
-		if (!found) {
-			console.warn(`Locale '${this.locale}' is not available. Using default locale.`);
-			if (this.dateLocales.length > 0) return this.dateLocales[0].locale;
-			return enUS;
-		}
-		return found?.locale;
-	}
-	updateContext(context) {
-		this.context = context;
-		this.locale = context.locale;
-		this._registerSurveyEvent({
-			type: SurveyEventTypes.languageChanged,
-			timestamp: this._getTimestamp(),
-			value: context.locale
-		});
-		this.evalExpressions();
-		this.reRenderSurveyTree();
-	}
-	setResponse(targetKey, response) {
-		const target = this.getResponseItem(targetKey);
-		if (!target) throw new Error("setResponse: target not found for key: " + targetKey);
-		target.response = response;
-		this._registerSurveyEvent({
-			type: SurveyEventTypes.responeChanged,
-			timestamp: this._getTimestamp(),
-			itemId: targetKey
-		});
-		this.evalExpressions();
-		this.reRenderSurveyTree();
-	}
-	get openedAt() {
-		return this._openedAt;
-	}
-	get sessionSeed() {
-		return this.sessionSeedValue;
-	}
-	get survey() {
-		return this.surveyDef;
-	}
-	getSurveyPages(size) {
-		const renderedSurvey = flattenTree(this.renderedSurveyTree);
-		const pages = new Array();
-		if (!size) size = "large";
-		let currentPage = [];
-		renderedSurvey.forEach((item) => {
-			if (item.type === "page-break") {
-				if (currentPage.length > 0) {
-					pages.push([...currentPage]);
-					currentPage = [];
-				}
-				return;
-			}
-			currentPage.push(item);
-			if (!this.surveyDef.maxItemsPerPage) return;
-			let max = 0;
-			switch (size) {
-				case "large":
-					max = this.surveyDef.maxItemsPerPage.large;
-					break;
-				case "small":
-					max = this.surveyDef.maxItemsPerPage.small;
-					break;
-			}
-			if (currentPage.length >= max) {
-				pages.push([...currentPage]);
-				currentPage = [];
-			}
-		});
-		if (currentPage.length > 0) pages.push([...currentPage]);
-		return pages;
-	}
-	getRenderedSurveyItem(itemId) {
-		return flattenTree(this.renderedSurveyTree).find((item) => item.id === itemId);
-	}
-	onPageChanged(pageIndex) {
-		this._registerSurveyEvent({
-			type: SurveyEventTypes.pageChanged,
-			timestamp: this._getTimestamp(),
-			value: pageIndex
-		});
-	}
-	getEvents() {
-		return this._events.slice();
+var FunctionCallEditor = class extends ExpressionEditor {
+	name;
+	args;
+	returnType;
+	constructor(name, args, returnType) {
+		super();
+		this.name = name;
+		this.args = args;
+		this.returnType = returnType;
 	}
-	getResponses() {
-		const renderedPositions = /* @__PURE__ */ new Map();
-		flattenTree(this.renderedSurveyTree).filter((item) => item.type !== "page-break").forEach((item, index) => {
-			if (this.responses[item.id]) renderedPositions.set(item.id, index);
-		});
-		const responses = [];
-		this.surveyDef.surveyItems.forEach((item, itemId) => {
-			if (!item.isInteractive()) return;
-			const response = this.getResponseItem(itemId);
-			if (!response) return;
-			const position = renderedPositions.get(itemId);
-			response.meta = position === void 0 ? void 0 : { position };
-			responses.push(response);
-		});
-		return responses;
-	}
-	getDisplayConditionValue(itemKey, componentKey) {
-		if (componentKey) return this.cache.displayConditions[itemKey]?.components?.[componentKey]?.result;
-		return this.cache.displayConditions[itemKey]?.root?.result;
-	}
-	getDisabledConditionValue(itemKey, componentKey) {
-		return this.cache.disabledConditions[itemKey]?.components?.[componentKey]?.result;
-	}
-	getTemplateValue(templateValueKey) {
-		return this.cache.templateValues[templateValueKey]?.value;
-	}
-	getValidationValues(itemKey) {
-		const validations = this.cache.validations[itemKey];
-		if (!validations) return;
-		return Object.keys(validations).reduce((acc, validationKey) => {
-			acc[validationKey] = validations[validationKey].result;
-			return acc;
-		}, {});
-	}
-	initCache() {
-		this.cache = {
-			validations: {},
-			displayConditions: {},
-			templateValues: {},
-			disabledConditions: {}
-		};
-		this.surveyDef.getTemplateValueKeys().forEach((templateKey) => {
-			this.cache.templateValues[templateKey] = {
-				value: void 0,
-				templateDef: this.surveyDef.getTemplateValue(templateKey)
+	getExpression() {
+		return createFunctionExpression(this.name, this.args.map((arg) => arg.getExpression()), this.editorConfig);
+	}
+};
+const date_eq = (a, b) => new FunctionCallEditor("date_eq", [a, b], ValueType.boolean);
+const date_gt = (a, b) => new FunctionCallEditor("date_gt", [a, b], ValueType.boolean);
+const date_gte = (a, b) => new FunctionCallEditor("date_gte", [a, b], ValueType.boolean);
+const date_lt = (a, b) => new FunctionCallEditor("date_lt", [a, b], ValueType.boolean);
+const date_lte = (a, b) => new FunctionCallEditor("date_lte", [a, b], ValueType.boolean);
+const date_add_days = (a, b) => new FunctionCallEditor("date_add_days", [a, b], ValueType.date);
+const date_add_months = (a, b) => new FunctionCallEditor("date_add_months", [a, b], ValueType.date);
+const date_add_years = (a, b) => new FunctionCallEditor("date_add_years", [a, b], ValueType.date);
+/** Signed completed units in a - b, e.g. age as `date_diff(ctx_current_date(), birth, "years")`. */
+const date_diff = (a, b, unit) => new FunctionCallEditor("date_diff", [
+	a,
+	b,
+	const_string(unit)
+], ValueType.number);
+const date_min = (...args) => new FunctionCallEditor("date_min", args, ValueType.date);
+const date_max = (...args) => new FunctionCallEditor("date_max", args, ValueType.date);
+const is_disabled = (ownerId) => new DisabledStateEditor(ownerId);
+//#endregion
+//#region src/survey/composition/registry.ts
+function defineElement(definition) {
+	const schema = contentOwner(z.strictObject({
+		...elementShape,
+		elementType: z.literal(definition.elementType),
+		config: definition.config.nonoptional()
+	}), definition.roles ?? []);
+	return {
+		elementType: definition.elementType,
+		labelByLocale: definition.labelByLocale,
+		schema,
+		inspect(input) {
+			const node = schema.parse(input);
+			return {
+				slots: [],
+				bindings: [],
+				followUps: [],
+				fullWidth: false,
+				minWidthRem: 12,
+				componentParents: {},
+				...definition.facts?.(node.config, node.id)
 			};
-		});
-		this.surveyDef.surveyItems.forEach((item, itemId) => {
-			if (item.validations && Object.keys(item.validations).length > 0) {
-				this.cache.validations[itemId] = {};
-				Object.keys(item.validations).forEach((validationKey) => {
-					const valExp = item.validations[validationKey];
-					if (!valExp) {
-						console.warn("initCache: validation expression not found: " + itemId + " " + validationKey);
-						return;
-					}
-					this.cache.validations[itemId][validationKey] = {
-						expression: valExp,
-						result: false
-					};
-				});
-			}
-			if (item.displayConditions !== void 0 && (item.displayConditions.root || item.displayConditions.components)) {
-				this.cache.displayConditions[itemId] = {};
-				if (item.displayConditions.root) this.cache.displayConditions[itemId].root = {
-					expression: item.displayConditions.root,
-					result: false
-				};
-				if (item.displayConditions.components) {
-					this.cache.displayConditions[itemId].components = {};
-					Object.keys(item.displayConditions.components).forEach((componentKey) => {
-						const compExp = item.displayConditions?.components?.[componentKey];
-						if (!compExp) {
-							console.warn("initCache: display condition component expression not found: " + itemId + " " + componentKey);
-							return;
-						}
-						this.cache.displayConditions[itemId].components[componentKey] = {
-							expression: compExp,
-							result: false
-						};
-					});
-				}
-			}
-			if (item.disabledConditions !== void 0 && item.disabledConditions.components !== void 0) {
-				this.cache.disabledConditions[itemId] = { components: {} };
-				Object.keys(item.disabledConditions.components).forEach((componentKey) => {
-					const compExp = item.disabledConditions?.components?.[componentKey];
-					if (!compExp) {
-						console.warn("initCache: disabled condition component expression not found: " + itemId + " " + componentKey);
-						return;
-					}
-					this.cache.disabledConditions[itemId].components[componentKey] = {
-						expression: compExp,
-						result: false
-					};
-				});
-			}
-		});
-	}
-	initResponseObject(items) {
-		const respGroup = {};
-		items.forEach((item, itemId) => {
-			if (!item.isInteractive) return;
-			else {
-				const prefill = this.prefills?.[itemId];
-				const applyPrefill = prefill && prefill.itemType === item.type;
-				respGroup[itemId] = new SurveyItemResponse({
-					itemId,
-					itemType: item.type
-				}, applyPrefill ? prefill.response : void 0);
-			}
-		});
-		return respGroup;
-	}
-	applyConfiguredPrefills() {
-		const evalEngine = new ExpressionEvaluator({
-			responses: this.responses,
-			surveyContext: this.context
-		});
-		const maxPasses = Math.max(this.surveyDef.surveyItems.size, 1);
-		for (let pass = 0; pass < maxPasses; pass++) {
-			this.evalTemplateValues(evalEngine);
-			let changedInPass = false;
-			this.surveyDef.surveyItems.forEach((item) => {
-				if (!item.isInteractive()) return;
-				changedInPass = this.applyConfiguredPrefillsForItem(item, evalEngine) || changedInPass;
-			});
-			if (!changedInPass) break;
-		}
-		this.evalTemplateValues(evalEngine);
-	}
-	applyConfiguredPrefillsForItem(item, evalEngine) {
-		const responseItem = this.responses[item.id];
-		if (!responseItem) return false;
-		let changed = false;
-		for (const prefill of item.prefills ?? []) {
-			const targetSlot = item.resolvePrefillTarget(prefill.target);
-			if (!targetSlot) continue;
-			if ((prefill.apply ?? SurveyItemPrefillApplyMode.ifEmpty) === SurveyItemPrefillApplyMode.ifEmpty && responseItem.response?.get(targetSlot.slotId) !== void 0) continue;
-			if (!this.shouldApplyConfiguredPrefill(prefill, evalEngine)) continue;
-			const resolvedValue = this.resolveConfiguredPrefillValue(prefill, targetSlot, evalEngine);
-			if (!resolvedValue) continue;
-			const normalizedValue = item.normalizePrefillValue(prefill, targetSlot, resolvedValue);
-			if (!normalizedValue) continue;
-			const nextResponse = responseItem.response?.clone() ?? new ResponseItem();
-			nextResponse.setSlotValue(targetSlot.slotId, normalizedValue);
-			responseItem.response = nextResponse.isEmpty() ? void 0 : nextResponse;
-			changed = true;
+		},
+		compute(input, slotId, read) {
+			return definition.compute?.(schema.parse(input).config, slotId, read);
+		},
+		validate(input, read, evaluate) {
+			const node = schema.parse(input);
+			return definition.validate?.(node.config, node.id, read, evaluate) ?? [];
 		}
-		return changed;
-	}
-	shouldApplyConfiguredPrefill(prefill, evalEngine) {
-		if (!prefill.when) return true;
-		const resolved = evalEngine.eval(prefill.when);
-		return resolved?.type === ValueType.boolean && resolved.value === true;
-	}
-	resolveConfiguredPrefillValue(prefill, _target, evalEngine) {
-		switch (prefill.source.type) {
-			case "static": return prefill.source.value;
-			case "expression": return evalEngine.eval(prefill.source.expression);
-			case "templateValue": return this.getTemplateValue(prefill.source.key);
-			case "previousResponse": {
-				if (!this.prefillEnvironment?.getPreviousResponse) return;
-				const refTarget = prefill.source.ref.target ?? prefill.target;
-				const resolved = this.prefillEnvironment.getPreviousResponse({
-					surveyKey: prefill.source.ref.surveyKey,
-					itemId: prefill.source.ref.itemId,
-					target: refTarget
-				});
-				if (!resolved) return;
-				return resolved;
-			}
-			default: return;
-		}
-	}
-	shouldRender(itemId, componentId) {
-		const displayConditionResult = this.getDisplayConditionValue(itemId, componentId);
-		if (displayConditionResult !== void 0) return displayConditionResult;
-		return true;
-	}
-	sequentialRender(groupDef) {
-		const newItems = [];
-		for (const itemId of groupDef.items || []) {
-			if (!this.shouldRender(itemId)) continue;
-			const itemDef = this.surveyDef.surveyItems.get(itemId);
-			if (!itemDef) {
-				console.warn("sequentialRender: item not found: " + itemId);
-				continue;
-			}
-			if (itemDef.type === "group") {
-				newItems.push(this.renderGroup(itemDef));
-				continue;
-			}
-			newItems.push({
-				id: itemId,
-				type: itemDef.type
-			});
+	};
+}
+/** A registry is finalized once. Its one recursive schema is shared by built-in and custom bodies. */
+function createElementRegistry(create) {
+	const definitions = create(z.lazy(() => composition));
+	const byType = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		if (byType.has(definition.elementType)) throw new Error(`Duplicate element registration: ${definition.elementType}`);
+		byType.set(definition.elementType, definition);
+	}
+	const variants = definitions.map((definition) => definition.schema);
+	const element = variants.length ? z.union(variants) : z.never();
+	const composition = createCompositionSchema(element);
+	return {
+		definitions,
+		labels: new Map(definitions.map((definition) => [definition.elementType, definition.labelByLocale ?? {}])),
+		elementSchema: element,
+		bodySchema: composition,
+		surveySchema: createSurveySchema(composition),
+		get(elementType) {
+			const definition = byType.get(elementType);
+			if (!definition) throw new Error(`Unknown element type: ${elementType}`);
+			return definition;
 		}
-		return {
-			id: groupDef.id,
-			type: "group",
-			items: newItems
-		};
+	};
+}
+//#endregion
+//#region src/survey/composition/semantics.ts
+/** Structural context is independent of an element's explicit accessible label. */
+function getElementSemanticContext(survey, elementId) {
+	const owner = survey.owners.get(elementId);
+	if (!owner) throw new Error(`Unknown element '${elementId}'`);
+	let ancestor = owner.parentId ? survey.owners.get(owner.parentId) : void 0;
+	while (ancestor && ancestor.followUpTriggerId === owner.followUpTriggerId) {
+		if (ancestor.kind === "section" || ancestor.kind === "item") return ancestor;
+		ancestor = ancestor.parentId ? survey.owners.get(ancestor.parentId) : void 0;
 	}
-	randomizedItemRender(groupDef, parent) {
-		const newItems = parent.items?.filter((rItem) => this.shouldRender(rItem.id)) || [];
-		const itemIds = groupDef.items || [];
-		const shuffledIndices = shuffleIndices(itemIds.length);
-		for (const index of shuffledIndices) {
-			const itemId = itemIds[index];
-			if (parent.items?.find((rItem) => rItem.id === itemId)) continue;
-			if (!this.shouldRender(itemId)) continue;
-			const itemDef = this.surveyDef.surveyItems.get(itemId);
-			if (!itemDef) {
-				console.warn("randomizedItemRender: item not found: " + itemId);
-				continue;
-			}
-			if (itemDef.type === "group") {
-				newItems.push(this.renderGroup(itemDef, parent));
-				continue;
-			}
-			newItems.push({
-				id: itemId,
-				type: itemDef.type
-			});
+}
+function resolveElementName(survey, elementId, locales) {
+	const owner = survey.owners.get(elementId);
+	if (!owner) throw new Error(`Unknown element '${elementId}'`);
+	const name = (ownerId, role) => {
+		if (!survey.owners.get(ownerId)?.roles.some((entry) => entry.role === role)) return void 0;
+		const resolved = resolveParticipantContent(survey, ownerId, role, locales);
+		const text = getContentPlainText(resolved?.content).trim();
+		return text && resolved ? {
+			ownerId,
+			role,
+			text,
+			content: resolved.content,
+			locale: resolved.locale
+		} : void 0;
+	};
+	const own = name(elementId, "label");
+	if (own) return own;
+	let ancestor = owner.parentId ? survey.owners.get(owner.parentId) : void 0;
+	while (ancestor) {
+		const current = ancestor;
+		if ([...survey.elements.values()].filter((element) => {
+			const candidate = survey.owners.get(element.node.id);
+			return element.facts.bindings.length > 0 && candidate.followUpTriggerId === owner.followUpTriggerId && current.path.every((part, index) => candidate.path[index] === part);
+		}).length === 1) {
+			const inherited = name(ancestor.id, "title") ?? name(ancestor.id, "label");
+			if (inherited) return inherited;
 		}
-		return {
-			id: groupDef.id,
-			type: "group",
-			items: newItems
-		};
-	}
-	renderGroup(groupDef, parent) {
-		if (!parent) parent = {
-			id: groupDef.id,
-			type: "group",
-			items: []
-		};
-		if (groupDef.config.shuffleItems) return this.randomizedItemRender(groupDef, parent);
-		return this.sequentialRender(groupDef);
+		if (ancestor.kind === "section" || ancestor.id === owner.followUpTriggerId) return void 0;
+		ancestor = ancestor.parentId ? survey.owners.get(ancestor.parentId) : void 0;
 	}
-	reRenderSurveyTree() {
-		if (!this.surveyDef.rootItem) throw new Error("reRenderSurveyTree: root item not found");
-		this.renderedSurveyTree = this.renderGroup(this.surveyDef.rootItem);
-	}
-	_registerSurveyEvent(event) {
-		this._events.push(event);
-	}
-	_getTimestamp() {
-		return Math.floor(Date.now() / 1e3);
-	}
-	getResponseItem(itemId) {
-		return this.responses[itemId];
-	}
-	evalExpressions() {
-		const evalEngine = new ExpressionEvaluator({
-			responses: this.responses,
-			surveyContext: this.context
-		});
-		this.evalTemplateValues(evalEngine);
-		this.evalDisplayConditions(evalEngine);
-		this.evalDisableConditions(evalEngine);
-		this.evalValidations(evalEngine);
-	}
-	evalTemplateValues(evalEngine) {
-		Object.keys(this.cache.templateValues).forEach((templateValueKey) => {
-			const templateValue = this.cache.templateValues[templateValueKey];
-			this.cache.templateValues[templateValueKey].value = void 0;
-			if (!templateValue.templateDef?.expression) {
-				console.warn("evalTemplateValues: template value expression not found: " + templateValueKey);
-				return;
-			}
-			let evaluatedValue = evalEngine.eval(templateValue.templateDef.expression);
-			if (evaluatedValue === void 0) {
-				console.warn("evalTemplateValues: template value expression returned undefined: " + templateValueKey);
-				return;
-			}
-			switch (templateValue.templateDef.type) {
-				case "date2string":
-					if (evaluatedValue.type !== ValueType.date) {
-						console.warn("evalTemplateValues: template value expression returned non-date value: " + templateValueKey);
-						return;
-					}
-					evaluatedValue = {
-						type: ValueType.string,
-						value: format(/* @__PURE__ */ new Date(evaluatedValue.value * 1e3), templateValue.templateDef.dateFormat)
-					};
-					break;
-				default: break;
-			}
-			this.cache.templateValues[templateValueKey].value = evaluatedValue;
-		});
-	}
-	evalDisplayConditions(evalEngine) {
-		Object.keys(this.cache.displayConditions).forEach((itemKey) => {
-			const displayCondition = this.cache.displayConditions[itemKey];
-			if (displayCondition.root) {
-				const resolvedValue = evalEngine.eval(displayCondition.root.expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalDisplayConditions: display condition expression returned undefined: " + itemKey);
-					return;
-				}
-				this.cache.displayConditions[itemKey].root.result = resolvedValue.value;
-			}
-			if (displayCondition.components) Object.keys(displayCondition.components).forEach((componentKey) => {
-				const resolvedValue = evalEngine.eval(displayCondition.components[componentKey].expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalDisplayConditions: display condition component expression returned undefined: " + itemKey + "." + componentKey);
-					return;
-				}
-				this.cache.displayConditions[itemKey].components[componentKey].result = resolvedValue.value;
-			});
-		});
-	}
-	evalDisableConditions(evalEngine) {
-		Object.keys(this.cache.disabledConditions).forEach((itemKey) => {
-			const disableCondition = this.cache.disabledConditions[itemKey];
-			if (disableCondition.components) Object.keys(disableCondition.components).forEach((componentKey) => {
-				const resolvedValue = evalEngine.eval(disableCondition.components[componentKey].expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalDisableConditions: disable condition component expression returned undefined: " + itemKey + "." + componentKey);
-					return;
-				}
-				this.cache.disabledConditions[itemKey].components[componentKey].result = resolvedValue.value;
-			});
-		});
-	}
-	evalValidations(evalEngine) {
-		Object.keys(this.cache.validations).forEach((itemId) => {
-			const validation = this.cache.validations[itemId];
-			Object.keys(validation).forEach((validationKey) => {
-				const resolvedValue = evalEngine.eval(validation[validationKey].expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalValidations: validation expression returned undefined: " + itemId + "." + validationKey);
-					return;
-				}
-				this.cache.validations[itemId][validationKey].result = resolvedValue.value;
-			});
-		});
-	}
-};
-const flattenTree = (itemTree) => {
-	const flatTree = new Array();
-	itemTree.items?.forEach((item) => {
-		if (item.type === "group") flatTree.push(...flattenTree(item));
-		else flatTree.push({ ...item });
-	});
-	return flatTree;
-};
+}
 //#endregion
-//#region src/json-patch.ts
-var JsonPatchError = class extends Error {
-	constructor(message, code, path, operationIndex) {
-		super(message);
-		this.code = code;
-		this.path = path;
-		this.operationIndex = operationIndex;
-		this.name = "JsonPatchError";
-	}
-};
-const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const assertValidPointerSegment = (segment, pointer) => {
-	if (/~(?![01])/.test(segment)) throw new JsonPatchError(`Invalid JSON pointer segment "${segment}" in "${pointer}". Only "~0" and "~1" escapes are allowed.`, "invalid-json-pointer", pointer);
-};
-const decodeJsonPointerSegment = (segment) => {
-	assertValidPointerSegment(segment, segment);
-	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-};
-const encodeJsonPointerSegment = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
-const parseJsonPointer = (pointer) => {
-	if (pointer === "") return [];
-	if (!pointer.startsWith("/")) throw new JsonPatchError(`Invalid JSON pointer "${pointer}". It must be empty or start with "/".`, "invalid-json-pointer", pointer);
-	return pointer.slice(1).split("/").map((segment) => {
-		assertValidPointerSegment(segment, pointer);
-		return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+//#region src/engine/validation.ts
+function validateSurveyAnswers(plan, answers, context, options) {
+	const snapshot = plan.evaluate({
+		answers,
+		context
 	});
-};
-const parseArrayIndex = ({ segment, arrayLength, allowAppend, allowEnd, path }) => {
-	if (segment === "-") {
-		if (allowAppend) return arrayLength;
-		throw new JsonPatchError(`JSON pointer "${path}" uses "-" where an existing array index is required.`, "invalid-array-index", path);
-	}
-	if (!/^(0|[1-9][0-9]*)$/.test(segment)) throw new JsonPatchError(`JSON pointer "${path}" uses invalid array index "${segment}".`, "invalid-array-index", path);
-	const index = Number(segment);
-	const maximum = allowEnd ? arrayLength : arrayLength - 1;
-	if (index < 0 || index > maximum) throw new JsonPatchError(`JSON pointer "${path}" array index ${index} is out of bounds.`, "array-index-out-of-bounds", path);
-	return index;
-};
-const getValueAtSegments = (document, segments, path) => {
-	let current = document;
-	for (const segment of segments) {
-		if (Array.isArray(current)) {
-			const index = parseArrayIndex({
-				segment,
-				arrayLength: current.length,
-				allowAppend: false,
-				allowEnd: false,
-				path
-			});
-			current = current[index];
-			continue;
-		}
-		if (!isRecord(current) || !hasOwn(current, segment)) throw new JsonPatchError(`JSON pointer "${path}" does not exist.`, "path-not-found", path);
-		current = current[segment];
-	}
-	return current;
-};
-const getValueAtJsonPointer = (document, pointer) => {
-	return getValueAtSegments(document, parseJsonPointer(pointer), pointer);
-};
-const deepEqualJson = (left, right) => {
-	if (left === right) return true;
-	if (Array.isArray(left) || Array.isArray(right)) {
-		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
-		return left.every((entry, index) => deepEqualJson(entry, right[index]));
+	const evaluationDiagnostics = [];
+	const eligible = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		return !!binding && hasPermittedChange(binding, snapshot);
+	};
+	const evaluate = (expression, path) => {
+		try {
+			return evaluateExpression(expression, {
+				...context,
+				answer: snapshot.answer,
+				disabled: snapshot.disabled
+			});
+		} catch (error) {
+			if (!(error instanceof ExpressionEvaluationError)) throw error;
+			evaluationDiagnostics.push({
+				code: "validation-evaluation",
+				severity: "warning",
+				path,
+				message: error.message
+			});
+			return;
+		}
+	};
+	const issues = [];
+	const authorWarnings = [];
+	const active = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		return !!binding && [binding.controlId, ...binding.visibilityIds ?? []].every(snapshot.visible);
+	};
+	const included = (itemId) => !options.itemIds || options.itemIds.includes(itemId);
+	for (const element of plan.document.elements.values()) {
+		if (!included(element.itemId)) continue;
+		for (const binding of element.facts.bindings) {
+			if (!binding.selection || !active(binding.slotId) || [binding.controlId, ...binding.visibilityIds ?? []].some(snapshot.disabled)) continue;
+			if (!hasPermittedChange(binding, snapshot)) authorWarnings.push({
+				ownerId: binding.controlId,
+				code: "non-interactive-choice",
+				message: "Option locks, visibility, or the selection limit leave this choice with no permitted participant change. Its constraints will not block progress; its active answer is still submitted."
+			});
+			if (binding.selection.multiple) {
+				const answer = snapshot.answer(binding.slotId);
+				if (answer?.type === "reference[]") for (const optionId of answer.value.filter(snapshot.disabled)) authorWarnings.push({
+					ownerId: optionId,
+					code: "locked-checkbox-selection",
+					message: "This selected checkbox is now locked and cannot be unticked. It remains an active, submitted answer. Use visibility if the answer should stop applying."
+				});
+			}
+		}
+		for (const issue of plan.document.registry.get(element.node.elementType).validate(element.node, snapshot.answer, (expression) => evaluate(expression, element.path))) if (eligible(issue.slotId)) issues.push(issue);
+		else if (active(issue.slotId)) authorWarnings.push({
+			ownerId: issue.messageOwnerId ?? plan.bindings.get(issue.slotId).controlId,
+			code: "locked-input-constraint",
+			message: `The ${issue.code} constraint is not satisfied, but this input currently permits no participant change. It will not block progress; its active answer is still submitted.`
+		});
 	}
-	if (isRecord(left) || isRecord(right)) {
-		if (!isRecord(left) || !isRecord(right)) return false;
-		const leftKeys = Object.keys(left).sort();
-		const rightKeys = Object.keys(right).sort();
-		if (leftKeys.length !== rightKeys.length) return false;
-		return leftKeys.every((key, index) => key === rightKeys[index] && deepEqualJson(left[key], right[key]));
+	for (const item of plan.document.data.surveyItems) {
+		if (item.itemType !== "content" || !included(item.id)) continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (rule.phase === "submit" && options.phase !== "submit") continue;
+			const targets = rule.targets.filter(eligible);
+			if (!rule.targets.filter(active).length) continue;
+			if (rule.when) {
+				const result = evaluate(rule.when, [...plan.document.owners.get(rule.id).path, "when"]);
+				if (result?.type !== "boolean" || !result.value) continue;
+			}
+			const result = evaluate(rule.expression, [...plan.document.owners.get(rule.id).path, "expression"]);
+			if (result?.type !== "boolean" || !result.value) {
+				issues.push(...targets.map((slotId) => ({
+					slotId,
+					code: "rule",
+					messageOwnerId: rule.id
+				})));
+				if (!targets.length) authorWarnings.push({
+					ownerId: rule.id,
+					code: "locked-rule-targets",
+					message: "This applicable rule fails, but none of its active targets permits a participant change. It will not block progress. Check the rule and disabling conditions."
+				});
+			}
+		}
 	}
-	return false;
-};
-const applyAdd = (document, path, value) => {
-	const segments = parseJsonPointer(path);
-	if (segments.length === 0) return structuredCloneMethod(value);
-	const parentSegments = segments.slice(0, -1);
-	const key = segments[segments.length - 1];
-	const parent = getValueAtSegments(document, parentSegments, path);
-	if (Array.isArray(parent)) {
-		const index = parseArrayIndex({
-			segment: key,
-			arrayLength: parent.length,
-			allowAppend: true,
-			allowEnd: true,
-			path
+	return {
+		issues,
+		diagnostics: [...snapshot.diagnostics, ...evaluationDiagnostics],
+		authorWarnings
+	};
+}
+const authoringDependencyPlans = /* @__PURE__ */ new WeakMap();
+const staticWarnings = /* @__PURE__ */ new WeakMap();
+/** Conservative proofs only: dynamic conditions and prefills are checked in a real preview. */
+function staticConstraintWarnings(survey, plan) {
+	const literal = (expression, value) => expression?.type === "const" && expression.value?.type === "boolean" && expression.value.value === value;
+	const parents = (id) => {
+		const owner = survey.owners.get(id);
+		return [...owner.parentId ? [owner.parentId] : [], ...owner.elementId ? ownValue(survey.elements.get(owner.elementId)?.facts.componentParents, id) ?? [] : []];
+	};
+	const visible = (id) => {
+		const owner = survey.owners.get(id);
+		return !owner.followUpTriggerId && (!owner.visibility || literal(owner.visibility, true)) && parents(id).every(visible);
+	};
+	const hidden = (id) => literal(survey.owners.get(id).visibility, false) || parents(id).some(hidden);
+	const disabled = (id) => literal(survey.owners.get(id).disabled, true) || parents(id).some(disabled);
+	const locked = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		if (!binding) return false;
+		const controls = [binding.controlId, ...binding.visibilityIds ?? []];
+		return controls.every(visible) && (controls.some(disabled) || !!binding.selection?.options.every((id) => hidden(id) || disabled(id)));
+	};
+	const warnings = [];
+	for (const element of survey.elements.values()) {
+		if (!element.facts.bindings.some((binding) => locked(binding.slotId))) continue;
+		for (const issue of survey.registry.get(element.node.elementType).validate(element.node, () => void 0, () => void 0)) if ((issue.code === "required" || issue.code === "mustBeTrue") && locked(issue.slotId) && !ownValue(element.node.prefills, issue.slotId)?.length) warnings.push({
+			ownerId: issue.messageOwnerId ?? plan.bindings.get(issue.slotId).controlId,
+			code: "locked-input-constraint",
+			message: `The ${issue.code} constraint starts unsatisfied on an input with no permitted participant change and no prefill. It will not block progress. Check the requirement and disabling conditions.`
 		});
-		parent.splice(index, 0, structuredCloneMethod(value));
-		return document;
 	}
-	if (!isRecord(parent)) throw new JsonPatchError(`JSON pointer "${path}" parent is not an object or array.`, "invalid-target-parent", path);
-	Object.defineProperty(parent, key, {
-		configurable: true,
-		enumerable: true,
-		value: structuredCloneMethod(value),
-		writable: true
+	for (const item of survey.data.surveyItems) {
+		if (item.itemType !== "content") continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (!literal(rule.expression, false) || rule.when && !literal(rule.when, true)) continue;
+			if (rule.targets.length && rule.targets.every(locked)) warnings.push({
+				ownerId: rule.id,
+				code: "locked-rule-targets",
+				message: "This rule always fails, but all its targets are locked. It will not block progress. Check the rule and disabling conditions."
+			});
+		}
+	}
+	return warnings;
+}
+function getAuthoringWarnings(survey, locale) {
+	const warnings = [];
+	const itemsWithElements = new Set([...survey.elements.values()].map((element) => element.itemId));
+	for (const item of survey.data.surveyItems) if (item.itemType === "content" && !itemsWithElements.has(item.id)) warnings.push({
+		ownerId: item.id,
+		code: "empty-content-item",
+		message: "Add an element to this empty item, or remove the item."
 	});
-	return document;
-};
-const applyRemove = (document, path) => {
-	const segments = parseJsonPointer(path);
-	if (segments.length === 0) throw new JsonPatchError("Removing the document root is not supported.", "remove-root", path);
-	const parentSegments = segments.slice(0, -1);
-	const key = segments[segments.length - 1];
-	const parent = getValueAtSegments(document, parentSegments, path);
-	if (Array.isArray(parent)) {
-		const index = parseArrayIndex({
-			segment: key,
-			arrayLength: parent.length,
-			allowAppend: false,
-			allowEnd: false,
-			path
+	for (const owner of survey.owners.values()) for (const role of owner.roles.filter((role) => role.recommended)) if (!hasLocalizationText(readLocalizationContent(survey, {
+		scope: "content",
+		ownerId: owner.id,
+		role: role.role
+	}, locale))) warnings.push({
+		ownerId: owner.id,
+		code: "missing-content",
+		message: `Add ${role.role} to make this structure understandable`
+	});
+	let plan = authoringDependencyPlans.get(survey.elements);
+	if (!plan) {
+		plan = new SurveyStateGraph(survey, { admission: "draft" });
+		authoringDependencyPlans.set(survey.elements, plan);
+	}
+	let conflicts = staticWarnings.get(survey.elements);
+	if (!conflicts) {
+		conflicts = staticConstraintWarnings(survey, plan);
+		staticWarnings.set(survey.elements, conflicts);
+	}
+	warnings.push(...conflicts);
+	for (const item of survey.data.surveyItems) {
+		if (item.itemType !== "content") continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (rule.phase === "submit") continue;
+			if ([rule.expression, ...rule.when ? [rule.when] : []].flatMap((expression) => [...plan.storedDependencies(expression)]).some((id) => {
+				const dependencyItem = survey.slots.get(id)?.itemId;
+				return dependencyItem && dependencyItem !== item.id && !isStaticallyBefore(survey, dependencyItem, item.id);
+			})) warnings.push({
+				ownerId: rule.id,
+				code: "cross-item-page-rule",
+				message: "This rule runs before leaving the page and reads answers from another item. If those answers are on a later page, the participant may be unable to continue. Consider submit-only validation or an explicit condition for unanswered dependencies."
+			});
+		}
+	}
+	for (const element of survey.elements.values()) for (const binding of element.facts.bindings) if (binding.labelRefs) {
+		for (const ref of binding.labelRefs) if (!hasLocalizationText(readLocalizationContent(survey, {
+			scope: "content",
+			...ref
+		}, locale)) && !warnings.some((warning) => warning.ownerId === ref.ownerId && warning.code === "missing-content")) warnings.push({
+			ownerId: ref.ownerId,
+			code: "missing-accessible-name",
+			message: `Add ${ref.role} to name this input in the selected language`
 		});
-		const [removedValue] = parent.splice(index, 1);
+	} else if (!resolveElementName(survey, element.node.id, [locale]) && !warnings.some((warning) => warning.ownerId === element.node.id && warning.code === "missing-accessible-name")) warnings.push({
+		ownerId: element.node.id,
+		code: "missing-accessible-name",
+		message: "Add a label, or an unambiguous enclosing title, in the selected language"
+	});
+	for (const element of survey.elements.values()) for (const binding of element.facts.bindings) {
+		if (!binding.selection?.multiple) continue;
+		for (const id of binding.selection.options) {
+			const condition = survey.owners.get(id)?.disabled;
+			if (condition && [...plan.storedDependencies(condition)].some((slotId) => slotId !== binding.slotId)) warnings.push({
+				ownerId: id,
+				code: "external-checkbox-lock",
+				message: "This condition depends on another answer. An already selected checkbox can become locked and will still be submitted. Use visibility if the selection should stop applying."
+			});
+		}
+	}
+	return warnings;
+}
+/** A shared shuffled ancestor only changes order between its distinct children. */
+function isStaticallyBefore(survey, earlierId, laterId) {
+	const earlier = [...survey.getItemPath(earlierId), earlierId];
+	const later = [...survey.getItemPath(laterId), laterId];
+	const branch = earlier.findIndex((id, index) => id !== later[index]);
+	if (branch < 1) return false;
+	const parent = survey.getItem(earlier[branch - 1]);
+	return parent?.itemType === "group" && !parent.config.shuffleItems && parent.config.items.indexOf(earlier[branch]) < parent.config.items.indexOf(later[branch]);
+}
+//#endregion
+//#region src/survey/composition/diagnostics.ts
+/** Observed author-only conflicts use the same validation result as the player and host. */
+function getSessionDiagnostics(session) {
+	const result = session.validate("submit");
+	return [...result.authorWarnings.map((warning) => {
+		const owner = session.document.owners.get(warning.ownerId);
 		return {
-			document,
-			removedValue
+			...warning,
+			severity: "warning",
+			path: owner?.path ?? [],
+			ownerItemId: owner?.itemId
 		};
-	}
-	if (!isRecord(parent) || !hasOwn(parent, key)) throw new JsonPatchError(`JSON pointer "${path}" does not exist.`, "path-not-found", path);
-	const removedValue = parent[key];
-	delete parent[key];
-	return {
-		document,
-		removedValue
-	};
-};
-const applyReplace = (document, path, value) => {
-	const segments = parseJsonPointer(path);
-	if (segments.length === 0) return structuredCloneMethod(value);
-	getValueAtSegments(document, segments, path);
-	applyRemove(document, path);
-	return applyAdd(document, path, value);
-};
-const assertMoveTargetIsNotDescendant = (from, path) => {
-	if (from === "" || path === from || !path.startsWith(`${from}/`)) return;
-	throw new JsonPatchError(`JSON Patch cannot move "${from}" into its own descendant "${path}".`, "move-into-descendant", path);
-};
-const applyJsonPatch = (document, operations) => {
-	let patchedDocument = structuredCloneMethod(document);
-	operations.forEach((operation, operationIndex) => {
+	}), ...result.diagnostics.map((diagnostic) => {
+		const owner = ownerAtPath(session.document, diagnostic.path);
+		return {
+			...diagnostic,
+			ownerId: owner?.id,
+			ownerItemId: owner?.itemId
+		};
+	})];
+}
+function ownerAtPath(survey, path) {
+	return [...survey.owners.values()].filter((owner) => owner.path.length <= path.length && owner.path.every((part, index) => part === path[index])).sort((a, b) => b.path.length - a.path.length)[0];
+}
+/**
+* Every dangling reference an editor draft admits: missing answers, state targets, options,
+* owners and non-flow items from the document index, plus comparisons with removed option
+* identities reported by the compiled graph. Always empty for a runnable survey.
+*/
+function getBrokenReferences(survey) {
+	return getDefinitionDiagnostics(survey).filter((diagnostic) => diagnostic.severity === "error" && diagnostic.kind === "reference");
+}
+const compiledDiagnostics = /* @__PURE__ */ new WeakMap();
+/** Use the authoritative definition/compiler diagnostics, including state reads and custom definitions. */
+function getDefinitionDiagnostics(survey, locale) {
+	let compiled = compiledDiagnostics.get(survey.elements);
+	if (!compiled) {
 		try {
-			switch (operation.op) {
-				case "add":
-					patchedDocument = applyAdd(patchedDocument, operation.path, operation.value);
-					break;
-				case "remove":
-					patchedDocument = applyRemove(patchedDocument, operation.path).document;
-					break;
-				case "replace":
-					patchedDocument = applyReplace(patchedDocument, operation.path, operation.value);
-					break;
-				case "move": {
-					assertMoveTargetIsNotDescendant(operation.from, operation.path);
-					if (operation.from === operation.path) break;
-					const { document: withoutValue, removedValue } = applyRemove(patchedDocument, operation.from);
-					patchedDocument = applyAdd(withoutValue, operation.path, removedValue);
-					break;
-				}
-				case "copy": {
-					const value = getValueAtJsonPointer(patchedDocument, operation.from);
-					patchedDocument = applyAdd(patchedDocument, operation.path, value);
-					break;
-				}
-				case "test":
-					if (!deepEqualJson(getValueAtJsonPointer(patchedDocument, operation.path), operation.value)) throw new JsonPatchError(`JSON Patch test failed at "${operation.path}".`, "test-failed", operation.path);
-					break;
-			}
+			compiled = new SurveyStateGraph(survey, { admission: "draft" }).admittedDiagnostics;
 		} catch (error) {
-			if (error instanceof JsonPatchError) throw new JsonPatchError(error.message, error.code, error.path, operationIndex);
-			throw error;
+			if (error instanceof DefinitionError) compiled = error.diagnostics;
+			else throw error;
 		}
+		compiledDiagnostics.set(survey.elements, compiled);
+	}
+	const located = [...survey.diagnostics, ...compiled].map((diagnostic) => {
+		const owner = ownerAtPath(survey, diagnostic.path) ?? (diagnostic.path[0] === "translations" && diagnostic.path[2] === "content" ? survey.owners.get(String(diagnostic.path[3])) : void 0);
+		return {
+			...diagnostic,
+			ownerItemId: owner?.itemId,
+			ownerId: owner?.id
+		};
 	});
-	return patchedDocument;
-};
-//#endregion
-//#region src/response-exporter/types.ts
-/** Meta column keys in fixed order (common attributes first). */
-const META_COLUMN_ORDER = [
-	"submittedAt",
-	"participantId",
-	"responseId",
-	"versionId"
-];
-/** Built-in transform modes for slot export. */
-const SlotTransformMode = {
-	default: "default",
-	mask: "mask",
-	dateFormat: "dateFormat"
-};
-/** Separator between item key path and slot coding path in default export headers. */
-const EXPORT_COLUMN_SLOT_SEPARATOR = "__";
-/** Source of an export column. */
-const ExportColumnSource = {
-	meta: "meta",
-	context: "context",
-	response: "response"
-};
+	if (locale) try {
+		for (const warning of getAuthoringWarnings(survey, locale)) {
+			const owner = survey.owners.get(warning.ownerId);
+			located.push({
+				...warning,
+				severity: "warning",
+				path: owner?.path ?? [],
+				ownerItemId: owner?.itemId
+			});
+		}
+	} catch (error) {
+		if (!(error instanceof DefinitionError)) throw error;
+	}
+	return [...new Map(located.map((issue) => [JSON.stringify([
+		issue.code,
+		issue.path,
+		issue.message
+	]), issue])).values()];
+}
 //#endregion
-//#region src/response-exporter/slot-formatter.ts
-/** Default transform config when no profile override. */
-const DEFAULT_TRANSFORM = { mode: SlotTransformMode.default };
-/**
-* Export a single response slot to a string. Pure function for unit testing.
-* Uses default formatting by ValueType unless overridden by transformConfig.
-*/
-function exportSingleResponseSlot(params) {
-	const { value, valueType, transformConfig } = params;
-	if (value === void 0 || value === null) return "";
-	const mode = transformConfig.mode;
-	if (mode === SlotTransformMode.mask) return maskValue(value, transformConfig.maskChar ?? "***");
-	if (mode === SlotTransformMode.dateFormat && (valueType === ValueType.date || valueType === ValueType.dateArray)) return formatDateValue(value, transformConfig.dateFormat?.pattern ?? "yyyy-MM-dd");
-	return formatDefault(value);
+//#region src/engine/session.ts
+const sessionSnapshotSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	binding: z.strictObject({
+		sessionId: z.string().min(1),
+		definitionId: z.string().min(1)
+	}),
+	answers: stringRecord(z.string().min(1), responseValueSchema),
+	initialization: z.literal("complete"),
+	navigation: z.strictObject({
+		pageIndex: z.number().int().nonnegative(),
+		viewport: z.enum(["small", "large"])
+	}),
+	randomization: z.strictObject({ seed: z.string().min(1) }),
+	context: z.strictObject({
+		locale: z.string().min(1),
+		/** Defaults to the participant-local day when a new session starts; kept on resume. */
+		currentDate: calendarDaySchema.optional(),
+		participantFlags: stringRecord(z.string(), z.string()).optional(),
+		customValues: stringRecord(z.string(), responseValueSchema).optional()
+	}),
+	events: z.array(surveyEventSchema)
+});
+const eventTimestamp = () => Math.floor(Date.now() / 1e3);
+const comparableAnswer = (value) => JSON.stringify(value, Object.keys(value).sort());
+function freezeAnswer(value) {
+	if (Array.isArray(value.value)) Object.freeze(value.value);
+	return Object.freeze(value);
+}
+function sameRecord(left, right, equal) {
+	const entries = Object.entries(left ?? {});
+	return entries.length === Object.keys(right ?? {}).length && entries.every(([key, value]) => {
+		const other = ownValue(right, key);
+		return other !== void 0 && equal(value, other);
+	});
 }
-const BooleanExportValues = {
-	TRUE: "TRUE",
-	FALSE: "FALSE"
-};
-function formatDefault(value) {
-	switch (value.type) {
-		case ValueType.string: return String(value.value);
-		case ValueType.reference: return String(value.value);
-		case ValueType.boolean: return value.value ? BooleanExportValues.TRUE : BooleanExportValues.FALSE;
-		case ValueType.number: return value.precision === NumberPrecision.int ? String(Math.floor(value.value)) : String(value.value);
-		case ValueType.date: return (/* @__PURE__ */ new Date(value.value * 1e3)).toISOString();
-		case ValueType.duration: {
-			const d = value;
-			return `${d.precision === NumberPrecision.int ? Math.floor(d.value) : d.value} ${d.unit}`;
+/** Owns retained answers; participant adapters receive no privileged initialization write path. */
+var SurveySession = class SurveySession {
+	currentDocument;
+	state;
+	stateGraph;
+	revision = 0;
+	presentationRevision = 0;
+	itemPresentationRevisions = /* @__PURE__ */ new Map();
+	initializationDiagnostics = [];
+	listeners = /* @__PURE__ */ new Set();
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	getRevision = () => this.revision;
+	/** State/context changes notify every item; wording changes only notify their owning item. */
+	getItemRevision = (itemId) => this.revision - this.presentationRevision + (this.itemPresentationRevisions.get(itemId) ?? 0);
+	/** Prefer the current page, then the next surviving item, then the previous one. */
+	pageAnchors(writtenItems = /* @__PURE__ */ new Set()) {
+		const pages = this.pages();
+		return [
+			...(pages[this.pageIndex] ?? []).filter((id) => writtenItems.has(id)),
+			...pages.slice(this.pageIndex).flat(),
+			...pages.slice(0, this.pageIndex).flat().reverse()
+		];
+	}
+	reconcilePageAndNotify(anchors) {
+		const pages = this.pages();
+		const pageByItem = new Map(pages.flatMap((items, index) => items.map((id) => [id, index])));
+		const anchoredPage = anchors?.map((id) => pageByItem.get(id)).find((index) => index !== void 0);
+		this.state.navigation.pageIndex = anchoredPage ?? Math.min(this.pageIndex, Math.max(0, pages.length - 1));
+		this.revision++;
+		this.listeners.forEach((listener) => listener());
+	}
+	constructor(currentDocument, state, admission = "strict") {
+		this.currentDocument = currentDocument;
+		this.state = state;
+		this.stateGraph = new SurveyStateGraph(currentDocument, { admission });
+		this.validateAnswers(state.answers);
+		for (const value of Object.values(state.answers)) freezeAnswer(value);
+		for (const value of Object.values(state.context.customValues ?? {})) freezeAnswer(value);
+	}
+	get document() {
+		return this.currentDocument;
+	}
+	/** Wording-only authoring revisions share the compiler indexes and cannot change execution.
+	* Keep the compiled graph, answers, navigation and initialization when updating a live preview.
+	* A structural/configuration revision must create a new session instead.
+	*/
+	updatePresentation(document) {
+		if (document === this.currentDocument) return;
+		if (document.elements !== this.currentDocument.elements) throw new Error("Only wording revisions can update a session presentation");
+		const affected = /* @__PURE__ */ new Set();
+		let sharedContentChanged = false;
+		for (const locale of /* @__PURE__ */ new Set([...document.locales, ...this.currentDocument.locales])) {
+			const before = this.currentDocument.data.translations?.[locale];
+			const after = document.data.translations?.[locale];
+			if (before === after) continue;
+			sharedContentChanged ||= before?.navigationContent !== after?.navigationContent || before?.validationMessages !== after?.validationMessages;
+			for (const owner of document.owners.values()) if (before?.content[owner.id] !== after?.content[owner.id]) affected.add(owner.itemId);
 		}
-		case ValueType.stringArray: return value.value.join("; ");
-		case ValueType.referenceArray: return value.value.join("; ");
-		case ValueType.numberArray: {
-			const arr = value.value;
-			const prec = value.precision;
-			const fmt = (n) => prec === NumberPrecision.int ? Math.floor(n) : n;
-			return arr.map(fmt).join("; ");
+		if (!sharedContentChanged) {
+			this.presentationRevision++;
+			for (const id of affected) this.itemPresentationRevisions.set(id, (this.itemPresentationRevisions.get(id) ?? 0) + 1);
 		}
-		case ValueType.dateArray: return value.value.map((ts) => (/* @__PURE__ */ new Date(ts * 1e3)).toISOString()).join("; ");
-		case ValueType.durationArray: {
-			const d = value;
-			const prec = d.precision === NumberPrecision.int;
-			const fmt = (n) => prec ? Math.floor(n) : n;
-			return d.value.map((v) => `${fmt(v)} ${d.unit}`).join("; ");
+		this.currentDocument = document;
+		this.reconcilePageAndNotify();
+	}
+	static async create(document, input, sources = {}) {
+		if (input.mode === "resumed") {
+			const snapshot = sessionSnapshotSchema.parse(input.snapshot);
+			if (snapshot.binding.sessionId !== input.binding.sessionId || snapshot.binding.definitionId !== input.binding.definitionId) throw new Error("Resume snapshot does not match the session and exact survey definition");
+			const session = new SurveySession(document, snapshot);
+			if (session.pageIndex >= Math.max(1, session.pages().length)) throw new Error("Resume page index is outside the survey");
+			return session;
 		}
-		default: return String(value.value ?? "");
+		const session = new SurveySession(document, sessionSnapshotSchema.parse({
+			schemaVersion: 1,
+			binding: input.binding,
+			answers: input.answers ?? {},
+			initialization: "complete",
+			navigation: {
+				pageIndex: 0,
+				viewport: "large"
+			},
+			randomization: { seed: input.seed ?? crypto.randomUUID() },
+			context: {
+				...input.context,
+				currentDate: input.context.currentDate ?? calendarDateFromLocalDate(/* @__PURE__ */ new Date())
+			},
+			events: [{
+				type: "openSurvey",
+				timestamp: eventTimestamp(),
+				value: input.context.locale
+			}]
+		}), input.admission);
+		await session.initialize(sources);
+		return session;
+	}
+	snapshot() {
+		return structuredClone(this.state);
+	}
+	itemMetadata() {
+		return Object.fromEntries(this.pages().flat().map((itemId, position) => [itemId, { position }]));
+	}
+	active() {
+		return this.stateGraph.evaluate({
+			answers: this.state.answers,
+			context: this.state.context
+		});
 	}
-}
-function formatDateValue(value, pattern) {
-	if (value.type === ValueType.date) return format(/* @__PURE__ */ new Date(value.value * 1e3), pattern);
-	if (value.type === ValueType.dateArray) return value.value.map((ts) => format(/* @__PURE__ */ new Date(ts * 1e3), pattern)).join("; ");
-	return formatDefault(value);
-}
-function maskValue(value, maskChar) {
-	return valueToString(value) ? maskChar : "";
-}
-function valueToString(value) {
-	switch (value.type) {
-		case ValueType.string:
-		case ValueType.reference: return String(value.value);
-		case ValueType.stringArray:
-		case ValueType.referenceArray: return value.value.join(" ");
-		default: return String(value.value ?? "");
+	get locale() {
+		return this.state.context.locale;
 	}
-}
+	get pageIndex() {
+		return this.state.navigation.pageIndex;
+	}
+	setLocale(locale) {
+		this.setContext({
+			...this.state.context,
+			locale
+		});
+	}
+	/** Replace host context without restarting initialization or losing retained answers. */
+	setContext(context) {
+		const parsed = sessionSnapshotSchema.shape.context.parse(context);
+		const previous = this.state.context;
+		const next = {
+			...parsed,
+			currentDate: parsed.currentDate ?? previous.currentDate
+		};
+		if (!next.locale.trim()) throw new Error("A locale is required");
+		const localeChanged = next.locale !== previous.locale;
+		if (!localeChanged && next.currentDate === previous.currentDate && sameRecord(previous.participantFlags, next.participantFlags, (a, b) => a === b) && sameRecord(previous.customValues, next.customValues, (a, b) => JSON.stringify(a) === JSON.stringify(b))) return;
+		for (const value of Object.values(next.customValues ?? {})) freezeAnswer(value);
+		const anchors = this.pageAnchors();
+		this.state = {
+			...this.state,
+			context: next,
+			events: localeChanged ? [...this.state.events, {
+				type: "languageChanged",
+				timestamp: eventTimestamp(),
+				value: next.locale
+			}] : this.state.events
+		};
+		this.reconcilePageAndNotify(anchors);
+	}
+	orderedIds(ids, ownerId) {
+		return shuffleArray(ids, createSeededRandom(`${this.state.randomization.seed}:${ownerId}`));
+	}
+	setViewport(viewport) {
+		if (viewport === this.state.navigation.viewport) return;
+		const anchors = this.pageAnchors();
+		this.state.navigation.viewport = viewport;
+		this.reconcilePageAndNotify(anchors);
+	}
+	pages(viewport = this.state.navigation.viewport) {
+		const active = this.active(), byId = new Map(this.document.data.surveyItems.map((item) => [item.id, item]));
+		const pages = [[]];
+		const limit = this.document.data.maxItemsPerPage?.[viewport] ?? Infinity;
+		const next = () => {
+			if (pages.at(-1).length) pages.push([]);
+		};
+		const visit = (id) => {
+			const item = byId.get(id);
+			if (!item || !active.visible(id)) return;
+			if (item.itemType === "group") (item.config.shuffleItems ? this.orderedIds(item.config.items, item.id) : item.config.items).forEach(visit);
+			else if (item.itemType === "page-break") next();
+			else {
+				if (pages.at(-1).length >= limit) next();
+				pages.at(-1).push(id);
+			}
+		};
+		visit(this.document.rootId);
+		return pages.filter((page) => page.length);
+	}
+	validate(phase, itemIds) {
+		const result = validateSurveyAnswers(this.stateGraph, this.state.answers, this.state.context, {
+			phase,
+			itemIds
+		});
+		return {
+			...result,
+			diagnostics: [...this.initializationDiagnostics, ...result.diagnostics]
+		};
+	}
+	goToPage(index, viewport = this.state.navigation.viewport) {
+		const pages = this.pages(viewport);
+		if (!Number.isInteger(index) || index < 0 || index >= pages.length) throw new Error("Invalid page index");
+		if (index > this.pageIndex) {
+			if (this.validate("page", pages[this.pageIndex]).issues.length) throw new Error("Current page has blocking validation errors");
+		}
+		this.state = {
+			...this.state,
+			navigation: {
+				pageIndex: index,
+				viewport
+			},
+			events: [...this.state.events, {
+				type: "pageChanged",
+				timestamp: eventTimestamp(),
+				value: index
+			}]
+		};
+		this.reconcilePageAndNotify();
+	}
+	submission(responseId) {
+		if (this.validate("submit").issues.length) throw new Error("Survey has blocking validation errors");
+		return structuredClone({
+			schemaVersion: 2,
+			responseId,
+			definitionId: this.state.binding.definitionId,
+			answers: this.active().activeAnswers(),
+			events: this.state.events,
+			itemMetadata: this.itemMetadata(),
+			customValues: this.state.context.customValues,
+			evaluationContext: {
+				locale: this.state.context.locale,
+				currentDate: this.state.context.currentDate,
+				participantFlags: this.state.context.participantFlags
+			},
+			randomization: this.state.randomization
+		});
+	}
+	validateAnswers(answers) {
+		for (const [slotId, value] of Object.entries(answers)) {
+			const slot = this.document.slots.get(slotId);
+			if (!slot || slot.computed) throw new Error(`Unknown or computed answer target '${slotId}'`);
+			const errors = validateResponseSlotValue(slot, value);
+			if (errors.length) throw new Error(errors.join("; "));
+			if (value.type === "reference[]" && new Set(value.value).size !== value.value.length) throw new Error(`Duplicate selected options in '${slotId}'`);
+		}
+	}
+	write(writes) {
+		if (new Set(writes.map((write) => write.slotId)).size !== writes.length) throw new Error("One action cannot write a slot twice");
+		const before = this.active();
+		const changed = writes.filter(({ slotId, value }) => {
+			const previous = ownValue(this.state.answers, slotId);
+			return previous === void 0 || value === void 0 ? previous !== value : comparableAnswer(previous) !== comparableAnswer(value);
+		});
+		for (const { slotId, value } of writes) {
+			const slot = this.document.slots.get(slotId);
+			const binding = this.stateGraph.bindings.get(slotId);
+			if (!slot || slot.computed || !binding) throw new Error(`Slot '${slotId}' is not a writable input`);
+			if (value !== void 0) this.validateAnswers({ [slotId]: value });
+		}
+		for (const { slotId, value } of changed) {
+			const binding = this.stateGraph.bindings.get(slotId);
+			if (!canWriteSelection(binding, ownValue(this.state.answers, slotId), value, before)) throw new Error(`Participant write to '${slotId}' is not permitted in the current state`);
+		}
+		if (!changed.length) return;
+		const anchors = this.pageAnchors(new Set(changed.map(({ slotId }) => this.document.slots.get(slotId).itemId)));
+		const answers = { ...this.state.answers };
+		const timestamp = eventTimestamp();
+		for (const { slotId, value } of changed) if (value === void 0) delete answers[slotId];
+		else setOwnValue(answers, slotId, freezeAnswer(structuredClone(value)));
+		const events = [...this.state.events];
+		for (const { slotId, value } of changed) {
+			const event = {
+				type: "responseChanged",
+				slotId,
+				operation: value === void 0 ? "clear" : "set",
+				timestamp
+			};
+			const previous = events.at(-1);
+			if (previous?.type === event.type && previous.slotId === slotId && previous.operation === event.operation) events[events.length - 1] = event;
+			else events.push(event);
+		}
+		this.state = {
+			...this.state,
+			answers,
+			events
+		};
+		this.reconcilePageAndNotify(anchors);
+	}
+	evaluate(expression) {
+		const active = this.active();
+		return evaluateExpression(expression, {
+			...this.state.context,
+			answer: active.answer,
+			disabled: active.disabled
+		});
+	}
+	async initialize(sources) {
+		const prefills = new Map([...this.document.elements.values()].flatMap((element) => Object.entries(element.node.prefills ?? {})));
+		for (const slotId of this.stateGraph.initializationOrder) {
+			if (Object.hasOwn(this.state.answers, slotId)) continue;
+			for (const [index, candidate] of (prefills.get(slotId) ?? []).entries()) {
+				const path = [
+					...this.document.elements.get(this.document.slots.get(slotId).elementId).path,
+					"prefills",
+					slotId,
+					index
+				];
+				const warn = (message) => this.initializationDiagnostics.push({
+					code: "prefill-value",
+					severity: "warning",
+					path,
+					message
+				});
+				const evaluate = (expression) => {
+					try {
+						return this.evaluate(expression);
+					} catch (error) {
+						if (!(error instanceof ExpressionEvaluationError)) throw error;
+						warn(`Prefill '${candidate.id}' was skipped: ${error.message}`);
+						return;
+					}
+				};
+				if (candidate.when) {
+					const result = evaluate(candidate.when);
+					if (result?.type !== "boolean" || !result.value) continue;
+				}
+				let value;
+				switch (candidate.source.type) {
+					case "static":
+						value = candidate.source.value;
+						break;
+					case "expression":
+						value = evaluate(candidate.source.expression);
+						break;
+					case "templateValue": {
+						const template = ownValue(this.document.data.templateValues, candidate.source.key);
+						if (template?.expression) {
+							value = evaluate(template.expression);
+							if (template.type === "formatDate" && value?.type === "date") value = {
+								type: "string",
+								value: formatCalendarDate(value.value, template.dateFormat)
+							};
+						}
+						break;
+					}
+					case "previousResponse":
+						if (!sources.previousResponse && candidate.source.ifUnsupported !== "skip") throw new Error("This host does not supply previous responses for prefills");
+						value = await sources.previousResponse?.(candidate.source.ref);
+				}
+				if (value === void 0) continue;
+				if (candidate.source.type === "previousResponse") {
+					const parsed = responseValueSchema.safeParse(value);
+					const slot = this.document.slots.get(slotId);
+					if (parsed.success && parsed.data.type === "reference[]" && slot.valueType === "reference[]" && slot.allowedValues) {
+						const allowed = new Set(slot.allowedValues.flatMap(responseValueElements).flatMap((option) => option.type === "reference" ? [option.value] : []));
+						const retained = parsed.data.value.filter((id) => allowed.has(id));
+						if (retained.length !== parsed.data.value.length) {
+							warn(`Prefill '${candidate.id}' discarded options outside the current response domain`);
+							if (!retained.length) continue;
+							value = {
+								type: "reference[]",
+								value: retained
+							};
+						}
+					}
+				}
+				const issues = this.document.slots.validateAnswers({ [slotId]: value });
+				if (issues.length) {
+					warn(`Prefill '${candidate.id}' was skipped: ${issues.map((issue) => issue.message).join("; ")}`);
+					continue;
+				}
+				setOwnValue(this.state.answers, slotId, freezeAnswer(structuredClone(value)));
+				break;
+			}
+		}
+	}
+};
 //#endregion
 //#region src/response-exporter/csv-serializer.ts
 const DEFAULT_OPTIONS = {
@@ -2296,182 +1767,229 @@ function serializeToCsv(columns, rows, options) {
 	return lines.join(opts.lineEnding);
 }
 //#endregion
-//#region src/response-exporter/exporter.ts
-function slotOverrideKey(itemId, slotId) {
-	return `${itemId}::${slotId}`;
-}
-function responseColumnId(itemId, slotId) {
-	return `${itemId}::${slotId}`;
-}
-function metaColumnId(metaField) {
-	return `meta:${metaField}`;
-}
-function contextColumnId(contextKey) {
-	return `context:${contextKey}`;
-}
-function formatMetaValue(response, metaField) {
-	switch (metaField) {
-		case "submittedAt":
-			if (response.submittedAt == null || response.submittedAt === 0) return "";
-			return format(/* @__PURE__ */ new Date(response.submittedAt * 1e3), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx");
-		case "participantId": return response.participantId ?? "";
-		case "responseId": return response.key;
-		case "versionId": return response.versionId;
-		default: return "";
-	}
+//#region src/response-exporter/validate-configuration.ts
+/** Export requires an executable definition, including complete expression operands. */
+function validateExportConfiguration(survey, registry = survey.slots) {
+	registry.assertValid();
+	new SurveyStateGraph(survey);
 }
-var SurveyResponseExporter = class {
-	versions = /* @__PURE__ */ new Map();
-	constructor(versionBindings, profiles = []) {
-		this.profiles = profiles;
-		for (const vb of versionBindings) this.versions.set(vb.versionId, vb);
-	}
-	getSurveyForVersion(versionId) {
-		return this.versions.get(versionId);
-	}
-	/**
-	* Compute response-only columns from survey definition.
-	*/
-	computeResponseColumns(versionId) {
-		const binding = this.versions.get(versionId);
-		if (!binding) return [];
-		const survey = binding.survey;
-		const keyIndex = survey.keyIndex;
-		const keyByItemId = new Map(keyIndex.map((r) => [r.itemId, r]));
-		const profile = this.resolveProfileForVersion(versionId);
-		const columns = [];
-		for (const { itemId, slots } of survey.getResponseSlotDefinitions()) {
-			const keyInfo = keyByItemId.get(itemId);
-			const itemBaseKey = keyInfo ? [...keyInfo.keyPath, keyInfo.key].join(".") : itemId;
-			for (const slot of slots) {
-				const columnId = responseColumnId(itemId, slot.slotId);
-				const codingPath = [...slot.keyPath, slot.key].filter((part) => part.trim().length > 0);
-				const defaultHeader = codingPath.length > 0 ? `${itemBaseKey}__${codingPath.join(".")}` : `${itemBaseKey}__${slot.slotId}`;
-				const header = this.resolveColumnHeader(profile, columnId, defaultHeader);
-				columns.push({
-					id: columnId,
-					header,
-					source: ExportColumnSource.response,
-					itemId,
-					slotId: slot.slotId,
-					valueType: slot.valueType
-				});
+//#endregion
+//#region src/response-exporter/exporter.ts
+const canonical = (value) => JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b))) : entry);
+/** Export only against schemas selected by the host, never against response version tags. */
+var SurveyResponseExporter = class SurveyResponseExporter {
+	batches;
+	options;
+	constructor(batches, options = {}) {
+		this.batches = batches;
+		this.options = options;
+		if (!batches.length) throw new Error("Supply at least one schema-bound export batch");
+		if (batches.some((batch) => !batch.schema || !Array.isArray(batch.responses))) throw new Error("Each export batch requires a schema and responses array");
+		if (batches.length > 1 && !options.codingPolicy) throw new Error("Combined export requires an explicit original or harmonized coding policy");
+	}
+	batch(index) {
+		const batch = this.batches[index];
+		if (!batch) throw new Error(`Unknown export batch: ${index}`);
+		return batch;
+	}
+	profile(batch) {
+		if (!this.options.profile) return batch.profile;
+		return {
+			...batch.profile,
+			...this.options.profile,
+			slotOverrides: {
+				...batch.profile?.slotOverrides,
+				...this.options.profile.slotOverrides
+			},
+			columnHeaders: {
+				...batch.profile?.columnHeaders,
+				...this.options.profile.columnHeaders
+			},
+			contextOverrides: {
+				...batch.profile?.contextOverrides,
+				...this.options.profile.contextOverrides
 			}
-		}
-		return columns;
+		};
 	}
-	/**
-	* Compute full export columns: meta first, then context (from responses), then response columns.
-	* Column order: meta (fixed) -> context (profile order or alphabetical) -> response (profile order + alphabetical).
-	*/
-	computeColumns(versionId, responses, versionIds) {
-		const vids = versionIds ?? [versionId];
-		const responseCols = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const vid of vids) for (const c of this.computeResponseColumns(vid)) if (!seen.has(c.id)) {
-			seen.add(c.id);
-			responseCols.push(c);
-		}
-		const profile = this.resolveProfileForVersion(versionId);
-		const metaColumns = META_COLUMN_ORDER.map((metaField) => ({
-			id: metaColumnId(metaField),
-			header: this.resolveColumnHeader(profile, metaColumnId(metaField), metaField),
-			source: ExportColumnSource.meta,
-			metaField
-		}));
-		const contextKeys = /* @__PURE__ */ new Set();
-		for (const r of responses ?? []) if (r.context) for (const k of Object.keys(r.context)) contextKeys.add(k);
-		const contextOrder = profile?.contextColumnOrder;
-		const contextCols = Array.from(contextKeys).sort(contextOrder ? (a, b) => {
-			const ia = contextOrder.indexOf(a);
-			const ib = contextOrder.indexOf(b);
-			if (ia >= 0 && ib >= 0) return ia - ib;
-			if (ia >= 0) return -1;
-			if (ib >= 0) return 1;
-			return a.localeCompare(b);
-		} : void 0).map((contextKey) => ({
-			id: contextColumnId(contextKey),
-			header: this.resolveColumnHeader(profile, contextColumnId(contextKey), `context.${contextKey}`),
-			source: ExportColumnSource.context,
-			contextKey
+	compileContexts() {
+		return new Map(this.batches.map((batch) => {
+			const registry = batch.schema.slots;
+			validateExportConfiguration(batch.schema, registry);
+			const slots = new Map(localizedExportSlots(batch.schema).map((slot) => [slot.slotId, slot]));
+			const profile = this.profile(batch);
+			const transforms = new Map([...slots.values()].map((slot) => [slot.slotId, {
+				...DEFAULT_TRANSFORM,
+				...slot.exportSettings,
+				...ownValue(profile?.slotOverrides, slot.slotId)
+			}]));
+			const columns = [...slots.values()].flatMap((slot) => projectSlot(slot, transforms.get(slot.slotId)).map((column) => ({
+				...column,
+				header: ownValue(profile?.columnHeaders, column.id)?.trim() ?? column.header
+			})));
+			const encodings = /* @__PURE__ */ new Map();
+			for (const slotId of new Set(columns.map((column) => column.slotId))) {
+				const { include: _include, ...encoding } = resolvedSlotEncoding(slots.get(slotId), transforms.get(slotId));
+				encodings.set(slotId, canonical(encoding));
+			}
+			return [batch, {
+				registry,
+				slots,
+				profile,
+				transforms,
+				encodings,
+				columns,
+				included: new Set(columns.map((column) => column.id)),
+				stateGraph: new SurveyStateGraph(batch.schema)
+			}];
 		}));
-		const respOrder = profile?.responseColumnOrder ?? [];
-		const byOrder = respOrder.filter((id) => responseCols.some((c) => c.id === id)).map((id) => responseCols.find((c) => c.id === id));
-		const remaining = responseCols.filter((c) => !respOrder.includes(c.id)).sort((a, b) => a.header.localeCompare(b.header));
-		const respCols = [...byOrder, ...remaining];
-		const columns = [
-			...metaColumns,
-			...contextCols,
-			...respCols
-		];
-		this.assertUniqueHeaders(columns);
-		return columns;
-	}
-	resolveProfileForVersion(versionId) {
-		return this.profiles.find((p) => !p.versionId || p.versionId === versionId);
-	}
-	resolveColumnHeader(profile, columnId, defaultHeader) {
-		const override = profile?.columnHeaders?.[columnId]?.trim();
-		return override && override.length > 0 ? override : defaultHeader;
-	}
-	assertUniqueHeaders(columns) {
-		const seen = /* @__PURE__ */ new Map();
-		for (const column of columns) {
-			const existingId = seen.get(column.header);
-			if (existingId && existingId !== column.id) throw new Error(`Duplicate export column header '${column.header}' for columns '${existingId}' and '${column.id}'`);
-			seen.set(column.header, column.id);
-		}
 	}
-	getTransformConfig(versionId, itemId, slotId) {
-		return this.resolveProfileForVersion(versionId)?.slotOverrides?.[slotOverrideKey(itemId, slotId)] ?? DEFAULT_TRANSFORM;
-	}
-	getContextTransformConfig(versionId, contextKey) {
-		return this.resolveProfileForVersion(versionId)?.contextOverrides?.[contextKey] ?? DEFAULT_TRANSFORM;
-	}
-	exportResponse(response) {
-		if (!this.versions.get(response.versionId)) return null;
-		const columns = this.computeColumns(response.versionId, [response]);
-		const row = {};
-		for (const col of columns) {
-			if (col.source === ExportColumnSource.meta && col.metaField) {
-				row[col.header] = formatMetaValue(response, col.metaField);
-				continue;
-			}
-			if (col.source === ExportColumnSource.context && col.contextKey) {
-				const value = response.context?.[col.contextKey];
-				const transformConfig = this.getContextTransformConfig(response.versionId, col.contextKey);
-				const valueType = value?.type ?? ValueType.string;
-				row[col.header] = exportSingleResponseSlot({
-					value,
-					valueType,
-					transformConfig
+	validateProfile(profile, batches, contexts, extraResponses = []) {
+		if (!profile) return;
+		if (profile.schemaVersion !== 1) throw new Error(`Unsupported exporter profile schema version: ${String(profile.schemaVersion)}`);
+		const slots = new Map(batches.flatMap((batch) => [...contexts.get(batch).slots]));
+		const contextKeys = new Set([...batches.flatMap((batch) => batch.responses), ...extraResponses].flatMap((response) => Object.keys(response.customValues ?? {})));
+		const columns = /* @__PURE__ */ new Set([
+			...[...slots.values()].flatMap((slot) => projectSlot(slot, { mode: "default" }, true).map((column) => column.id)),
+			...META_COLUMN_ORDER.map((field) => encodeExportColumnId(["meta", field])),
+			...[...contextKeys].map((key) => encodeExportColumnId(["context", key]))
+		]);
+		for (const id of Object.keys(profile.slotOverrides ?? {})) if (!slots.has(id)) throw new Error(`Profile references unknown response slot "${id}"`);
+		for (const id of [...Object.keys(profile.columnHeaders ?? {}), ...profile.responseColumnOrder ?? []]) if (!columns.has(id)) throw new Error(`Profile references unknown export column "${id}"`);
+		for (const id of profile.responseColumnOrder ?? []) if (![...slots.values()].some((slot) => projectSlot(slot, { mode: "default" }, true).some((column) => column.id === id))) throw new Error(`Response column order contains a non-response column: ${id}`);
+		for (const key of [...Object.keys(profile.contextOverrides ?? {}), ...profile.contextColumnOrder ?? []]) if (!contextKeys.has(key)) throw new Error(`Profile references unknown context key "${key}"`);
+		for (const slot of slots.values()) if ((slot.naming?.kind === "matrix" || slot.rowId || slot.columnId) && projectSlot(slot, { mode: "default" }, true).some((column) => Object.hasOwn(profile.columnHeaders ?? {}, column.id))) throw new Error(`Matrix variable "${slot.slotId}" cannot have an individual header override; edit its matrix coding components`);
+		for (const [id, header] of Object.entries(profile.columnHeaders ?? {})) if (typeof header !== "string" || !header.trim()) throw new Error(`Export header for "${id}" cannot be empty`);
+		if (new Set(profile.responseColumnOrder).size !== (profile.responseColumnOrder?.length ?? 0)) throw new Error("Response column order contains duplicate identities");
+	}
+	computeResponseColumns(batchIndex = 0, extraResponses = []) {
+		const batch = this.batch(batchIndex);
+		const contexts = this.compileContexts();
+		this.validateProfile(batch.profile, [batch], contexts, extraResponses);
+		this.validateProfile(this.options.profile, this.batches, contexts, extraResponses);
+		return contexts.get(batch).columns;
+	}
+	computeColumns(extraResponses = []) {
+		return this.columns(this.compileContexts(), extraResponses);
+	}
+	columns(contexts, extraResponses = []) {
+		this.validateProfile(this.options.profile, this.batches, contexts, extraResponses);
+		const columns = /* @__PURE__ */ new Map();
+		const signatures = /* @__PURE__ */ new Map();
+		const encodings = /* @__PURE__ */ new Map();
+		this.batches.forEach((batch) => {
+			const context = contexts.get(batch);
+			this.validateProfile(batch.profile, [batch], contexts, extraResponses);
+			for (const slot of context.slots.values()) {
+				const signature = canonical({
+					type: slot.valueType,
+					allowedValues: slot.allowedValues?.map((value) => canonical(value)).sort(),
+					codes: this.options.codingPolicy === "harmonized" ? ownValue(context.profile?.slotOverrides, slot.slotId)?.optionCodes ?? slot.referenceValueKeys : slot.referenceValueKeys,
+					computed: slot.computed,
+					scores: slot.referenceValueScores
 				});
-				continue;
+				const previous = signatures.get(slot.slotId);
+				if (previous && previous !== signature) throw new Error(`Incompatible schema definitions for slot "${slot.slotId}"; supply a compatible explicit harmonization mapping`);
+				signatures.set(slot.slotId, signature);
 			}
-			if (col.source === ExportColumnSource.response && col.itemId != null && col.slotId != null && col.valueType != null) {
-				const value = response.responses.get(col.itemId)?.response?.get(col.slotId);
-				const transformConfig = this.getTransformConfig(response.versionId, col.itemId, col.slotId);
-				row[col.header] = exportSingleResponseSlot({
-					value,
-					valueType: col.valueType,
-					transformConfig
-				});
+			for (const column of context.columns) {
+				const signature = context.encodings.get(column.slotId);
+				if (encodings.has(column.id) && encodings.get(column.id) !== signature) throw new Error(`Incompatible export encodings for column "${column.id}"; supply one harmonized profile`);
+				encodings.set(column.id, signature);
+				const existing = columns.get(column.id);
+				if (existing && existing.header !== column.header) throw new Error(`Conflicting names for column "${column.id}"; select an explicit harmonized output header`);
+				columns.set(column.id, column);
+			}
+		});
+		const profile = this.options.profile ?? (this.batches.length === 1 ? this.batches[0].profile : void 0);
+		const allResponses = [...this.batches.flatMap((batch) => batch.responses), ...extraResponses];
+		const contextKeys = [...new Set(allResponses.flatMap((response) => Object.keys(response.customValues ?? {})))];
+		const ordered = (values, order, id, name) => values.sort((a, b) => {
+			const left = order.indexOf(id(a)), right = order.indexOf(id(b));
+			if (left >= 0 || right >= 0) return (left < 0 ? Infinity : left) - (right < 0 ? Infinity : right);
+			return name(a).localeCompare(name(b));
+		});
+		const result = [
+			...META_COLUMN_ORDER.map((field) => ({
+				id: encodeExportColumnId(["meta", field]),
+				header: profile?.columnHeaders?.[encodeExportColumnId(["meta", field])]?.trim() ?? field,
+				source: ExportColumnSource.meta,
+				metaField: field
+			})),
+			...ordered(contextKeys, profile?.contextColumnOrder ?? [], (value) => value, (value) => value).map((key) => ({
+				id: encodeExportColumnId(["context", key]),
+				header: profile?.columnHeaders?.[encodeExportColumnId(["context", key])]?.trim() ?? `context.${key}`,
+				source: ExportColumnSource.context,
+				contextKey: key
+			})),
+			...ordered([...columns.values()], profile?.responseColumnOrder ?? [], (value) => value.id, (value) => value.header)
+		];
+		const headers = /* @__PURE__ */ new Set();
+		for (const column of result) {
+			if (headers.has(column.header)) throw new Error(`Duplicate export column header '${column.header}'`);
+			headers.add(column.header);
+		}
+		return result;
+	}
+	row(response, batch, columns, context) {
+		const { registry, slots, profile, included, transforms } = context;
+		const diagnostics = registry.validateAnswers(response.answers);
+		if (diagnostics.length) throw new Error(diagnostics.map((issue) => issue.message).join("\n"));
+		const row = Object.create(null);
+		const active = context.stateGraph.evaluate({
+			answers: response.answers,
+			context: {
+				locale: response.evaluationContext?.locale ?? batch.schema.locales[0] ?? "en",
+				currentDate: response.evaluationContext?.currentDate,
+				participantFlags: response.evaluationContext?.participantFlags,
+				customValues: response.customValues
 			}
+		});
+		for (const column of columns) if (column.source === ExportColumnSource.meta) switch (column.metaField) {
+			case "responseId":
+				row[column.header] = response.responseId;
+				break;
+			case "participantId":
+				row[column.header] = response.participantId ?? "";
+				break;
+			case "sourceId":
+				row[column.header] = batch.sourceId ?? "";
+				break;
+			case "submittedAt": row[column.header] = response.submittedAt ? format(/* @__PURE__ */ new Date(response.submittedAt * 1e3), "yyyy-MM-dd'T'HH:mm:ss.SSSxxx") : "";
+		}
+		else if (column.source === ExportColumnSource.context) {
+			const value = ownValue(response.customValues, column.contextKey);
+			row[column.header] = exportSingleResponseSlot({
+				value,
+				valueType: value?.type ?? ValueType.string,
+				transformConfig: ownValue(profile?.contextOverrides, column.contextKey) ?? {
+					...DEFAULT_TRANSFORM,
+					categorical: "ids"
+				}
+			});
+		} else {
+			const slot = slots.get(column.slotId);
+			row[column.header] = slot && included.has(column.id) ? formatProjectedValue(slot, column, active.answer(slot.slotId), transforms.get(slot.slotId)) : "";
 		}
 		return row;
 	}
-	/**
-	* Compute columns for a batch of responses (union of response columns across versions).
-	*/
-	computeColumnsForBatch(responses) {
-		if (responses.length === 0) return [];
-		const versionIds = [...new Set(responses.map((r) => r.versionId))];
-		const primaryVersionId = versionIds[0];
-		return this.computeColumns(primaryVersionId, responses, versionIds);
+	/** Explicitly associate one response with a supplied batch schema. */
+	exportResponse(response, batchIndex = 0) {
+		return new SurveyResponseExporter([{
+			...this.batch(batchIndex),
+			responses: [response]
+		}], { profile: this.options.profile }).exportRows()[0];
+	}
+	exportRows() {
+		const contexts = this.compileContexts();
+		return this.rows(this.columns(contexts), contexts);
+	}
+	rows(columns, contexts) {
+		return this.batches.flatMap((batch) => batch.responses.map((response) => this.row(response, batch, columns, contexts.get(batch))));
 	}
-	exportResponsesToCsv(responses, options) {
-		if (responses.length === 0) return "";
-		return serializeToCsv(this.computeColumnsForBatch(responses), responses.map((r) => this.exportResponse(r)).filter((r) => r !== null), options);
+	exportResponsesToCsv(options) {
+		const contexts = this.compileContexts();
+		const columns = this.columns(contexts);
+		return serializeToCsv(columns, this.rows(columns, contexts), options);
 	}
 };
 //#endregion
@@ -2480,51 +1998,123 @@ var SurveyResponseExporter = class {
 * Generate a structured codebook from a survey definition.
 */
 function generateCodebook(survey, options) {
+	const registry = survey.slots;
+	validateExportConfiguration(survey, registry);
+	const slots = localizedExportSlots(survey);
 	const locales = options?.locales ?? survey.locales;
-	const keyIndex = survey.keyIndex;
-	const keyByItemId = new Map(keyIndex.map((r) => [r.itemId, r]));
-	const slotDefsByItemId = new Map(survey.getResponseSlotDefinitions().map(({ itemId, slots }) => [itemId, slots.map((slot) => ({
-		slotId: slot.slotId,
-		key: slot.key,
-		keyPath: [...slot.keyPath],
-		valueType: slot.valueType
-	}))]));
+	const slotDefsByItemId = /* @__PURE__ */ new Map();
+	for (const slot of slots) {
+		const entries = slotDefsByItemId.get(slot.itemId) ?? [];
+		entries.push({
+			slotId: slot.slotId,
+			elementId: slot.elementId,
+			...slot.rowId ? { rowId: slot.rowId } : {},
+			...slot.columnId ? { columnId: slot.columnId } : {},
+			variableName: slot.variableName,
+			valueType: slot.valueType,
+			encoding: resolvedSlotEncoding(slot, {
+				mode: "default",
+				...slot.exportSettings,
+				...ownValue(options?.profile?.slotOverrides, slot.slotId)
+			}),
+			optionLabels: slot.referenceValueLabels,
+			...slot.allowedValues ? { allowedValues: slot.allowedValues.map((value) => structuredClone(value)) } : {},
+			...slot.computed ? { computed: {
+				...slot.computed,
+				sourceSlotIds: [...slot.computed.sourceSlotIds]
+			} } : {},
+			...slot.referenceValueKeys ? { referenceValueKeys: { ...slot.referenceValueKeys } } : {},
+			...slot.referenceValueScores ? { referenceValueScores: { ...slot.referenceValueScores } } : {}
+		});
+		slotDefsByItemId.set(slot.itemId, entries);
+	}
 	const items = [];
-	for (const item of survey.surveyItems.values()) {
-		const keyInfo = keyByItemId.get(item.id);
-		const key = keyInfo?.key ?? item.id;
-		const keyPath = keyInfo?.keyPath ?? [];
+	for (const item of survey.data.surveyItems) {
 		const slotList = slotDefsByItemId.get(item.id) ?? [];
 		slotList.sort((a, b) => a.slotId.localeCompare(b.slotId));
 		let contentByLocale;
 		if (locales.length > 0) {
 			contentByLocale = {};
-			const itemTranslations = survey.getItemTranslations(item.id);
-			if (itemTranslations) for (const locale of locales) {
-				const all = itemTranslations.getAllForLocale(locale);
-				if (all) {
-					const flat = {};
-					for (const [contentKey, content] of Object.entries(all)) flat[contentKey] = getContentPlainText(content);
-					contentByLocale[locale] = flat;
+			for (const locale of locales) {
+				const values = {};
+				for (const owner of survey.owners.values()) if (owner.itemId === item.id) {
+					const roles = ownValue(ownValue(survey.data.translations, locale)?.content, owner.id);
+					if (roles) setOwnValue(values, owner.id, Object.fromEntries(Object.entries(roles).map(([role, content]) => [role, getContentPlainText(content)])));
 				}
+				setOwnValue(contentByLocale, locale, values);
 			}
 		}
 		items.push({
 			id: item.id,
-			key,
-			keyPath,
-			type: item.type,
-			interactive: item.isInteractive(),
+			editorName: survey.resolveItemEditorName(item.id, locales[0]),
+			breadcrumb: survey.getItemDisplayPath(item.id, locales[0]).breadcrumb,
+			type: item.itemType,
+			interactive: slotList.some((slot) => !slot.computed),
 			slots: slotList,
 			contentByLocale
 		});
 	}
 	return {
-		surveyKey: survey.surveyKey,
-		items: items.sort((a, b) => a.key.localeCompare(b.key))
+		surveyKey: survey.data.metadata?.surveyKey,
+		items,
+		projection: new SurveyResponseExporter([{
+			schema: survey,
+			responses: [],
+			profile: options?.profile
+		}]).computeColumns(),
+		profile: options?.profile && structuredClone(options.profile),
+		missingValue: ""
+	};
+}
+/** Describe precisely the combined projection and each host-selected source definition. */
+function generateExportCodebook(batches, options = {}) {
+	const exporter = new SurveyResponseExporter(batches, options);
+	return {
+		schemaVersion: 1,
+		codingPolicy: options.codingPolicy ?? "original",
+		columns: exporter.computeColumns(),
+		missingValue: "",
+		profile: options.profile && structuredClone(options.profile),
+		sources: batches.map((batch) => ({
+			sourceId: batch.sourceId,
+			surveySchemaVersion: batch.schema.serialize().schemaVersion,
+			profile: batch.profile && structuredClone(batch.profile),
+			variables: localizedExportSlots(batch.schema).map((slot) => ({
+				...slot,
+				encoding: resolvedSlotEncoding(slot, {
+					mode: "default",
+					...slot.exportSettings,
+					...ownValue(options.profile?.slotOverrides, slot.slotId) ?? ownValue(batch.profile?.slotOverrides, slot.slotId)
+				})
+			}))
+		}))
+	};
+}
+//#endregion
+//#region src/engine/submission.ts
+/** The host chooses the exact definition and trusted context before calling this boundary. */
+function validateSurveySubmission(survey, input, context, binding) {
+	const response = SurveyResponse.deserialize(input);
+	if (response.definitionId !== binding.definitionId) throw new Error(`Response was given against definition '${response.definitionId}', not '${binding.definitionId}'`);
+	const issues = survey.slots.validateAnswers(response.answers);
+	if (issues.length) throw new Error(issues.map((issue) => issue.message).join("\n"));
+	const plan = new SurveyStateGraph(survey);
+	const applicable = plan.evaluate({
+		answers: response.answers,
+		context
+	}).activeAnswers();
+	const validation = validateSurveyAnswers(plan, applicable, context, { phase: "submit" });
+	if (validation.issues.length) throw new Error(validation.issues.map((issue) => `${issue.slotId}: ${issue.code}`).join("\n"));
+	response.answers = structuredClone(applicable);
+	response.evaluationContext = {
+		locale: context.locale,
+		currentDate: context.currentDate,
+		participantFlags: context.participantFlags && { ...context.participantFlags }
 	};
+	response.customValues = context.customValues && structuredClone(context.customValues);
+	return response;
 }
 //#endregion
-export { AndExpressionEditor, CURRENT_SURVEY_SCHEMA, ConstBooleanEditor, ConstDateArrayEditor, ConstDateEditor, ConstExpression, ConstNumberArrayEditor, ConstNumberEditor, ConstStringArrayEditor, ConstStringEditor, ContentType, ContextVariableExpression, ContextVariableType, CtxCustomExpressionEditor, CtxCustomValueEditor, CtxLocaleEditor, CtxPFlagDateEditor, CtxPFlagIsDefinedEditor, CtxPFlagNumEditor, CtxPFlagStringEditor, DEFAULT_TRANSFORM, DurationUnits, EXPORT_COLUMN_SLOT_SEPARATOR, EqExpressionEditor, Expression, ExpressionEditor, ExpressionEvaluator, ExpressionType, FunctionExpression, FunctionExpressionNames, GroupItemCore, GtExpressionEditor, GteExpressionEditor, InRangeExpressionEditor, JsonPatchError, LtExpressionEditor, LteExpressionEditor, META_COLUMN_ORDER, MaxExpressionEditor, MinExpressionEditor, NumberPrecision, OrExpressionEditor, PageBreakItemCore, ReferenceUsageType, ReservedSurveyItemTypes, ResponseItem, ResponseVariableEditor, ResponseVariableExpression, SURVEY_EDITOR_ITEM_COLORS, SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY, SURVEY_RESPONSE_SCHEMA_VERSION, SlotTransformMode, StrEqExpressionEditor, StrListContainsExpressionEditor, SumExpressionEditor, Survey, SurveyEngineCore, SurveyEventTypes, SurveyItemCore, SurveyItemKey, SurveyItemPrefillApplyMode, SurveyItemPrefillTargetType, SurveyItemResponse, SurveyItemTranslations, SurveyResponse, SurveyResponseExporter, SurveyTranslations, TemplateDefTypes, ValueReference, ValueReferenceMethod, ValueType, analyzeSurveyExpressionReferences, and, applyJsonPatch, assertResponseValue, buildItemExpression, builtInItemCoreRegistry, collectSurveyExpressionLocations, const_boolean, const_date, const_date_array, const_number, const_number_array, const_string, const_string_array, createFullRegistry, createItemCore, createItemTypeDefinitionRegistry, createRichTextContent, createSeededRandom, ctx_custom_expression, ctx_custom_value, ctx_locale, ctx_pflag_date, ctx_pflag_is_defined, ctx_pflag_num, ctx_pflag_string, decodeJsonPointerSegment, deserializeSurveyItemPrefill, deserializeTemplateValue, deserializeTemplateValues, encodeJsonPointerSegment, eq, escapeCsvCell, exportSingleResponseSlot, expressionReferenceDiagnosticKey, findIntroducedBlockingExpressionReferenceDiagnostics, findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories, flattenTree, generateCodebook, generateCodingKey, generateId, getAssetUsagesFromContent, getContentPlainText, getItemExpressionDefinition, getPlainTextFromRichTextContent, getValueAtJsonPointer, gt, gte, hasRenderableRichTextBlock, hasRenderableRichTextContent, in_range, initValueForType, isBlockingSurveyExpressionReferenceDiagnostic, isBuiltInItemType, isContentEmpty, isLegacyItemGroupComponent, isLegacySurveyGroupItem, isResponseValue, lt, lte, max, min, or, parseJsonPointer, prefillTargetsEqual, replaceResponseVariableReferences, responseValueReferenceIds, response_boolean, response_date, response_date_array, response_number, response_number_array, response_string, response_string_array, serializeSurveyItemPrefill, serializeTemplateValue, serializeTemplateValues, serializeToCsv, shuffleArray, shuffleIndices, str_eq, str_list_contains, structuredCloneMethod, sum, toItemTypeDefinitionRegistry, validateLocale };
+export { AndExpressionEditor, BooleanExportValues, CALENDAR_DATE_UNITS, CURRENT_SURVEY_SCHEMA, CURRENT_SURVEY_SCHEMA_VERSION, ConstBooleanEditor, ConstDateArrayEditor, ConstDateEditor, ConstNumberArrayEditor, ConstNumberEditor, ConstStringArrayEditor, ConstStringEditor, ContentType, CtxCurrentDateEditor, CtxCustomValueEditor, CtxLocaleEditor, CtxPFlagDateEditor, CtxPFlagIsDefinedEditor, CtxPFlagNumEditor, CtxPFlagStringEditor, DEFAULT_TRANSFORM, DefinitionError, DisabledStateEditor, DurationUnits, EXPORTER_PROFILE_SCHEMA_VERSION, EqExpressionEditor, ExportColumnSource, ExpressionEditor, ExpressionEvaluationError, FUNCTION_SIGNATURES, GtExpressionEditor, GteExpressionEditor, InRangeExpressionEditor, JsonPatchError, LtExpressionEditor, LteExpressionEditor, META_COLUMN_ORDER, MaxExpressionEditor, MinExpressionEditor, NumberPrecision, OrExpressionEditor, RESPONSE_VARIABLE_NAME_MAX_LENGTH, ResponseSlotRegistry, ResponseVariableEditor, SURVEY_LOCALIZATION_SURFACES, SURVEY_RESPONSE_SCHEMA_VERSION, SlotTransformMode, StrEqExpressionEditor, StrListContainsExpressionEditor, SumExpressionEditor, Survey, SurveyEventTypes, SurveyResponse, SurveyResponseExporter, SurveySession, SurveyStateGraph, ValueType, addCalendarDate, allocateResponseVariableName, and, annotated, annotatedReferences, applyJsonPatch, assertResponseValue, boundField, calendarDateBounds, calendarDateFromLocalDate, calendarDatePrecision, calendarDateToLocalDate, calendarDaySchema, canWriteSelection, checkDocumentBudget, collectExpressionDependencies, compareCalendarDates, conditionsShape, const_boolean, const_date, const_date_array, const_number, const_number_array, const_string, const_string_array, contentOwner, contentOwnerIds, createCompositionSchema, createElementRegistry, createFlowItemSchema, createFunctionExpression, createRichTextContent, createSeededRandom, createSurveySchema, ctx_current_date, ctx_custom_value, ctx_locale, ctx_pflag_date, ctx_pflag_is_defined, ctx_pflag_num, ctx_pflag_string, date_add_days, date_add_months, date_add_years, date_diff, date_eq, date_gt, date_gte, date_lt, date_lte, date_max, date_min, decodeExportColumnId, decodeJsonPointerSegment, defineElement, differenceCalendarDates, elementShape, encodeExportColumnId, encodeJsonPointerSegment, eq, escapeCsvCell, evaluateExpression, exportSingleResponseSlot, expressionArguments, expressionEditorConfigSchema, expressionField, expressionIssues, expressionSchema, expressionTypeIssues, extendObject, followUpBody, formatCalendarDate, formatProjectedValue, functionNameSchema, functionTypeIssues, generateCodebook, generateCodingKey, generateExportCodebook, generateId, getAssetUsagesFromContent, getAuthoringWarnings, getBrokenReferences, getCompositionLabel, getContentPlainText, getDefaultProjectionDiagnostics, getDefaultProjectionIssues, getDefinitionDiagnostics, getElementSemanticContext, getLocalizationCellKey, getLocalizationCoverage, getLocalizationEntryKey, getLocalizationItems, getPlainTextFromRichTextContent, getSessionDiagnostics, getValueAtJsonPointer, gt, gte, hasLocalizationText, hasPermittedChange, hasRenderableRichTextBlock, hasRenderableRichTextContent, if_else, in_range, inferExpressionReturnType, inspectAnnotated, invalidResponseDomainValues, isAdmissibleInDraft, isCalendarDate, isCalendarDateUnit, isContentEmpty, isEmptySurveyLocalizationEntry, isResponseValue, isValidResponseVariableName, is_disabled, itemEditorMetadataSchema, itemResponseMetadataSchema, jsonValueSchema, layoutPolicySchema, listLocalizationEntries, list_count, localizedExportSlots, lt, lte, max, min, moveArrayElement, operand, optionIds, optionMapping, or, ownValue, ownedId, ownerAtPath, parseJsonPointer, projectSlot, readLocalizationContent, referenceId, remapAnnotated, remapExpression, resolveElementName, resolveParticipantContent, resolveUniqueItemKey, resolvedSlotEncoding, responseValueElements, responseValueSchema, responseValuesEqual, response_boolean, response_date, response_date_array, response_number, response_number_array, response_string, response_string_array, richTextImageDimensionSchema, richTextImageSourceSchema, schemaAnnotation, selectedAndEnabled, serializeToCsv, sessionSnapshotSchema, setOwnValue, shuffleArray, shuffleIndices, slotPrefillSchema, slotTransformSchema, str_eq, str_list_contains, strictKeyedObject, stringRecord, structuredCloneMethod, suggestResponseVariableName, sum, surveyContentSchema, surveyEventSchema, surveyLocales, surveyResponseSchema, swapArrayElements, templateValueSchema, transformAnnotated, transformExpression, unreachable, validateLocalizationRef, validateResponseSlotValue, validateSurveyAnswers, validateSurveySubmission, validationRuleSchema, valueTypeSchema, visitExpression };
 
 //# sourceMappingURL=index.mjs.map