@case-framework/survey-core 0.6.2 → 0.8.0

package/build/index.mjs

@@ -1,7 +1,7 @@
-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 { $ as const_date, $n as responseValuesEqual, $t as CtxPFlagDateEditor, A as createItemTypeDefinitionRegistry, An as deserializeTemplateValue, At as min, B as deserializeSurveyItemPrefill, Bn as FunctionExpression, Bt as str_list_contains, C as SurveyItemTranslations, Cn as findIntroducedBlockingExpressionReferenceDiagnostics, Ct as eq, D as CURRENT_SURVEY_SCHEMA_VERSION, Dn as responseValueReferenceIds, Dt as lt, E as CURRENT_SURVEY_SCHEMA, En as replaceResponseVariableReferences, Et as in_range, F as isBuiltInItemType, Fn as ConstExpression, Ft as response_number, G as generateId, Gn as ValueReferenceMethod, Gt as ConstDateEditor, H as serializeSurveyItemPrefill, Hn as ResponseVariableExpression, Ht as AndExpressionEditor, I as getCompositionLabel, In as ContextVariableExpression, It as response_number_array, J as shuffleIndices, Jn as allocateResponseVariableName, Jt as ConstStringArrayEditor, K as resolveUniqueItemKey, Kn as ResponseSlotRegistry, Kt as ConstNumberArrayEditor, L as SurveyItemCore, Ln as ContextVariableType, Lt as response_string, M as GroupItemCore, Mn as serializeTemplateValue, Mt as response_boolean, N as PageBreakItemCore, Nn as serializeTemplateValues, Nt as response_date, O as createFullRegistry, On as DATE_FUNCTION_SIGNATURES, Ot as lte, P as builtInItemCoreRegistry, Pn as ExpressionEvaluator, Pt as response_date_array, Q as const_boolean, Qn as responseValueElements, Qt as CtxLocaleEditor, R as SurveyItemPrefillApplyMode, Rn as Expression, Rt as response_string_array, S as isContentEmpty, Sn as expressionReferenceDiagnosticKey, St as date_min, T as validateLocale, Tn as isBlockingSurveyExpressionReferenceDiagnostic, Tt as gte, U as createSeededRandom, Un as ReferenceUsageType, Ut as ConstBooleanEditor, V as prefillTargetsEqual, Vn as FunctionExpressionNames, Vt as sum, W as generateCodingKey, Wn as ValueReference, Wt as ConstDateArrayEditor, X as ReservedSurveyItemTypes, Xn as suggestResponseVariableName, Xt as CtxCustomExpressionEditor, Y as structuredCloneMethod, Yn as isValidResponseVariableName, Yt as ConstStringEditor, Z as and, Zn as invalidResponseDomainValues, Zt as CtxCustomValueEditor, _ as getAssetUsagesFromContent, _n as SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY, _r as differenceCalendarDates, _t as date_gt, a as resolvedSlotEncoding, an as GtExpressionEditor, ar as SurveyItemResponse, at as ctx_custom_expression, b as hasRenderableRichTextBlock, bn as collectExpressionResponseReferences, bt as date_lte, c as EXPORTER_PROFILE_SCHEMA_VERSION, cn as LtExpressionEditor, cr as ValueType, ct as ctx_pflag_date, d as SlotTransformMode, dn as MinExpressionEditor, dr as addCalendarDate, dt as ctx_pflag_string, en as CtxPFlagIsDefinedEditor, er as validateResponseSlotValue, et as const_date_array, f as decodeExportColumnId, fn as OrExpressionEditor, fr as calendarDateBounds, ft as date_add_days, g as createRichTextContent, gn as SumExpressionEditor, gr as compareCalendarDates, gt as date_eq, h as ContentType, hn as StrListContainsExpressionEditor, hr as calendarDateToLocalDate, ht as date_diff, i as projectSlot, in as ExpressionEditor, ir as ResponseItem, it as const_string_array, j as toItemTypeDefinitionRegistry, jn as deserializeTemplateValues, jt as or, k as createItemCore, kn as TemplateDefTypes, kt as max, l as ExportColumnSource, ln as LteExpressionEditor, lr as assertResponseValue, lt as ctx_pflag_is_defined, m as Survey, mn as StrEqExpressionEditor, mr as calendarDatePrecision, mt as date_add_years, n as getDefaultProjectionIssues, nn as CtxPFlagStringEditor, nr as SURVEY_RESPONSE_SCHEMA_VERSION, nt as const_number_array, o as DEFAULT_TRANSFORM, on as GteExpressionEditor, or as DurationUnits, ot as ctx_custom_value, p as encodeExportColumnId, pn as ResponseVariableEditor, pr as calendarDateFromLocalDate, pt as date_add_months, q as shuffleArray, qn as RESPONSE_VARIABLE_NAME_MAX_LENGTH, qt as ConstNumberEditor, r as optionMapping, rn as EqExpressionEditor, rr as SurveyResponse, rt as const_string, s as exportSingleResponseSlot, sn as InRangeExpressionEditor, sr as NumberPrecision, st as ctx_locale, t as formatProjectedValue, tn as CtxPFlagNumEditor, tr as initValueForType, tt as const_number, u as META_COLUMN_ORDER, un as MaxExpressionEditor, ur as isResponseValue, ut as ctx_pflag_num, v as getContentPlainText, vn as analyzeSurveyExpressionReferences, vr as formatCalendarDate, vt as date_gte, w as SurveyTranslations, wn as findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories, wt as gt, x as hasRenderableRichTextContent, xn as collectSurveyExpressionLocations, xt as date_max, y as getPlainTextFromRichTextContent, yn as collectConfigValueExpressions, yr as isCalendarDate, yt as date_lt, z as SurveyItemPrefillTargetType, zn as ExpressionType, zt as str_eq } from "./projection-Bl6qCinx.mjs";
 import { SURVEY_EDITOR_ITEM_COLORS } from "./editor/colors.mjs";
-import { format } from "date-fns";
-import { enUS } from "date-fns/locale";
+import { format } from "date-fns/format";
+import { enUS } from "date-fns/locale/en-US";
 //#region src/to_mirgrate/data_types/legacy-types.ts
 const isLegacyItemGroupComponent = (item) => {
 	const items = item.items;
@@ -12,530 +12,14 @@ const isLegacySurveyGroupItem = (item) => {
 	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];
-		}));
-	}
-};
-//#endregion
 //#region src/survey/responses/response-meta.ts
 const SurveyEventTypes = {
 	openSurvey: "openSurvey",
 	pageChanged: "pageChanged",
-	responeChanged: "responeChanged",
+	responseChanged: "responseChanged",
 	languageChanged: "languageChanged"
 };
 //#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;
-	}
-};
-//#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);
-	}
-};
-//#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}`);
-		}
-	}
-	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}`);
-				}
-			}
-		}
-	}
-	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
-		});
-	}
-	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
-		});
-	}
-};
-//#endregion
 //#region src/expressions/item-expression-registry.ts
 function getItemExpressionDefinition(definitions, expressionId) {
 	return definitions?.find((definition) => definition.id === expressionId);
@@ -546,824 +30,144 @@ function buildItemExpression(item, definitions, expressionId, params) {
 	return definition.buildExpression(item, params);
 }
 //#endregion
-//#region src/expressions/reference-integrity.ts
-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, surface) => {
-		if (!isJsonExpression(expression)) return;
-		locations.push({
-			expression,
-			location,
-			ownerItemId: item.id,
-			ownerItemKey: item.key,
-			surface
-		});
-	};
-	add(item.displayConditions?.root, "displayConditions.root", "display-condition");
-	for (const [componentId, expression] of Object.entries(item.displayConditions?.components ?? {})) add(expression, `displayConditions.components.${componentId}`, "display-condition");
-	for (const [componentId, expression] of Object.entries(item.disabledConditions?.components ?? {})) add(expression, `disabledConditions.components.${componentId}`, "disabled-condition");
-	for (const [validationKey, expression] of Object.entries(item.validations ?? {})) add(expression, `validations.${validationKey}`, "validation");
-	for (const [prefillIndex, prefill] of (item.prefills ?? []).entries()) {
-		const prefillId = prefill.id || String(prefillIndex);
-		add(prefill.when, `prefills.${prefillId}.when`, "prefill-condition");
-		if (prefill.source.type === "expression") add(prefill.source.expression, `prefills.${prefillId}.source.expression`, "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`,
-	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;
+//#region src/engine/active-responses.ts
+const itemNode = (id) => JSON.stringify(["item", id]);
+const componentNode = (id, component) => JSON.stringify([
+	"component",
+	id,
+	component
+]);
+const slotNode = (id) => JSON.stringify(["answer", id]);
+function assertDeclarativeVisibility(expression) {
+	if (!expression) return;
+	if (expression.type === ExpressionType.ContextVariable) {
+		if (expression.contextType === ContextVariableType.CustomExpression) throw new Error("Visibility conditions cannot use custom callback expressions; provide a serializable custom context value instead.");
+		assertDeclarativeVisibility(expression.key);
+	}
+	if ("arguments" in expression) for (const argument of expression.arguments ?? []) assertDeclarativeVisibility(argument);
+}
+/** Compile the dependencies once; each evaluation reads an immutable logical session snapshot. */
+var ActiveResponsePlan = class {
+	survey;
+	parents = /* @__PURE__ */ new Map();
+	components = /* @__PURE__ */ new Map();
+	slots;
+	constructor(survey) {
+		this.survey = survey;
+		this.slots = survey.getResponseSlotRegistry();
+		for (const item of survey.surveyItems.values()) {
+			if (item.type === "group") for (const child of item.items ?? []) this.parents.set(child, item.id);
+			for (const { slotId, componentId } of item.getConditionalResponseSlots()) this.components.set(slotId, [...this.components.get(slotId) ?? [], componentId]);
 		}
-	});
-	return (sameItemAndMethod.length > 0 ? sameItemAndMethod : availableRefs).slice(0, 5);
-};
-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 analyzeSurveyExpressionReferences = ({ responseSlots, survey }) => {
-	const slots = new Map(responseSlots.map((slot) => [slot.ref, slot]));
-	const availableRefs = responseSlots.map((slot) => slot.ref);
-	const diagnostics = [];
-	for (const location of collectSurveyExpressionLocations(survey)) {
-		let parsed;
-		try {
-			parsed = Expression.deserialize(location.expression);
-		} 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;
+		const graph = /* @__PURE__ */ new Map();
+		const labels = /* @__PURE__ */ new Map();
+		const refs = (expression) => expression?.responseVariableRefs.map((ref) => slotNode(ref.slotId)) ?? [];
+		for (const item of survey.surveyItems.values()) {
+			for (const expression of [item.displayConditions?.root, ...Object.values(item.displayConditions?.components ?? {})]) assertDeclarativeVisibility(expression?.serialize());
+			const label = item.metadata?.itemLabel?.trim() || item.id;
+			const parent = this.parents.get(item.id);
+			graph.set(itemNode(item.id), [...parent ? [itemNode(parent)] : [], ...refs(item.displayConditions?.root)]);
+			labels.set(itemNode(item.id), `${label} visibility`);
+			for (const [component, expression] of Object.entries(item.displayConditions?.components ?? {})) {
+				graph.set(componentNode(item.id, component), [itemNode(item.id), ...refs(expression)]);
+				labels.set(componentNode(item.id, component), `${label} (${component}) visibility`);
+			}
+			for (const slot of item.getResponseSlotDefinitions()) {
+				const activation = item.getActiveResponseDependencies(slot.slotId);
+				graph.set(slotNode(slot.slotId), [
+					itemNode(item.id),
+					...(this.components.get(slot.slotId) ?? []).map((id) => componentNode(item.id, id)),
+					...item.getComputedResponseDependencies(slot.slotId).map(slotNode),
+					...activation.slotIds.map(slotNode),
+					...activation.componentIds.map((id) => componentNode(item.id, id))
+				]);
+				labels.set(slotNode(slot.slotId), `${label} (${slot.variableName || slot.slotId})`);
+			}
 		}
-		for (const ref of parsed?.responseVariableRefs ?? []) {
-			const reference = ref.toString();
-			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)
+		const done = /* @__PURE__ */ new Set(), visiting = /* @__PURE__ */ new Set(), path = [];
+		const visit = (node) => {
+			if (visiting.has(node)) throw new Error(`Cyclic response/visibility dependency: ${[...path.slice(path.indexOf(node)), node].map((id) => labels.get(id) ?? id).join(" → ")}`);
+			if (done.has(node)) return;
+			visiting.add(node);
+			path.push(node);
+			for (const dependency of graph.get(node) ?? []) visit(dependency);
+			path.pop();
+			visiting.delete(node);
+			done.add(node);
+		};
+		for (const node of graph.keys()) visit(node);
+	}
+	evaluate(responses, context) {
+		const diagnostics = [];
+		const cache = /* @__PURE__ */ new Map();
+		const visiting = /* @__PURE__ */ new Set();
+		const resolve = (key, compute) => {
+			if (cache.has(key)) return cache.get(key);
+			if (visiting.has(key)) throw new Error(`Cyclic response/visibility dependency: ${key}`);
+			visiting.add(key);
+			try {
+				const value = compute();
+				cache.set(key, value);
+				return value;
+			} finally {
+				visiting.delete(key);
+			}
+		};
+		const condition = (itemId, expression, componentId) => {
+			if (!expression) return true;
+			const value = evaluator.eval(expression);
+			if (value !== void 0 && value.type !== ValueType.boolean) diagnostics.push({
+				code: "non-boolean-visibility-result",
+				itemId,
+				...componentId === void 0 ? {} : { componentId },
+				actualType: value.type
 			});
-		}
-		inspectFunctionReferenceCompatibility({
-			diagnostics,
-			expression: location.expression,
-			location,
-			slots
+			return value?.type === ValueType.boolean && value.value;
+		};
+		const isItemVisible = (id) => resolve(itemNode(id), () => {
+			const item = this.survey.surveyItems.get(id);
+			const parent = this.parents.get(id);
+			return !!item && (id === this.survey.rootItem?.id || !!parent && isItemVisible(parent)) && condition(id, item.displayConditions?.root);
 		});
-	}
-	return diagnostics;
-};
-const expressionReferenceDiagnosticKey = (diagnostic) => [
-	diagnostic.code,
-	diagnostic.ownerItemId ?? "survey",
-	diagnostic.location,
-	diagnostic.reference ?? "",
-	diagnostic.referenceValue ?? ""
-].join("\0");
-const findIntroducedExpressionReferenceDiagnostics = ({ after, before }) => {
-	const existing = new Set(before.map(expressionReferenceDiagnosticKey));
-	return after.filter((diagnostic) => !existing.has(expressionReferenceDiagnosticKey(diagnostic)));
-};
-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;
-		}
-		return next;
-	};
-	const rewritten = visit(value);
-	return {
-		changed,
-		value: rewritten
-	};
-};
-const responseValueReferenceIds = (values) => values?.flatMap((value) => value.type === ValueType.reference ? [value.value] : value.type === ValueType.referenceArray ? value.value : []);
-//#endregion
-//#region src/expressions/editors/expression-editor.ts
-var ExpressionEditor = class {
-	returnType;
-	_editorConfig;
-	get editorConfig() {
-		return this._editorConfig;
-	}
-	withEditorConfig(editorConfig) {
-		this._editorConfig = editorConfig;
-		return this;
-	}
-};
-var ConstStringArrayEditor = class extends ExpressionEditor {
-	returnType = ValueType.stringArray;
-	_values;
-	constructor(values, editorConfig) {
-		super();
-		this._values = values;
-		this._editorConfig = editorConfig;
-	}
-	get values() {
-		return this._values;
-	}
-	set values(values) {
-		this._values = values;
-	}
-	getExpression() {
-		return new ConstExpression({
-			type: ValueType.stringArray,
-			value: this._values
-		}, this._editorConfig);
-	}
-};
-var ConstStringEditor = class extends ExpressionEditor {
-	returnType = ValueType.string;
-	_value;
-	constructor(value, editorConfig) {
-		super();
-		this._value = value;
-		this._editorConfig = editorConfig;
-	}
-	get value() {
-		return this._value;
-	}
-	set value(value) {
-		this._value = value;
-	}
-	getExpression() {
-		return new ConstExpression({
-			type: ValueType.string,
-			value: this._value
-		}, this._editorConfig);
-	}
-};
-var ConstNumberEditor = class extends ExpressionEditor {
-	returnType = ValueType.number;
-	_value;
-	constructor(value, editorConfig) {
-		super();
-		this._value = value;
-		this._editorConfig = editorConfig;
-	}
-	get value() {
-		return this._value;
-	}
-	set value(value) {
-		this._value = value;
-	}
-	getExpression() {
-		return new ConstExpression({
-			type: ValueType.number,
-			value: this._value
-		}, this._editorConfig);
-	}
-};
-var ConstBooleanEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_value;
-	constructor(value, editorConfig) {
-		super();
-		this._value = value;
-		this._editorConfig = editorConfig;
-	}
-	get value() {
-		return this._value;
-	}
-	set value(value) {
-		this._value = value;
-	}
-	getExpression() {
-		return new ConstExpression({
-			type: ValueType.boolean,
-			value: this._value
-		}, this._editorConfig);
-	}
-};
-var ConstDateEditor = class extends ExpressionEditor {
-	returnType = ValueType.date;
-	_value;
-	constructor(value, editorConfig) {
-		super();
-		this._value = value;
-		this._editorConfig = editorConfig;
-	}
-	get value() {
-		return this._value;
-	}
-	set value(value) {
-		this._value = value;
-	}
-	getExpression() {
-		const value = Math.floor(this._value.getTime() / 1e3);
-		return new ConstExpression({
-			type: ValueType.date,
-			value
-		}, this._editorConfig);
-	}
-};
-var ConstNumberArrayEditor = class extends ExpressionEditor {
-	returnType = ValueType.numberArray;
-	_values;
-	constructor(values, editorConfig) {
-		super();
-		this._values = values;
-		this._editorConfig = editorConfig;
-	}
-	get values() {
-		return this._values;
-	}
-	set values(values) {
-		this._values = values;
-	}
-	getExpression() {
-		return new ConstExpression({
-			type: ValueType.numberArray,
-			value: this._values
-		}, this._editorConfig);
-	}
-};
-var ConstDateArrayEditor = class extends ExpressionEditor {
-	returnType = ValueType.dateArray;
-	_values;
-	constructor(values, editorConfig) {
-		super();
-		this._values = values;
-		this._editorConfig = editorConfig;
-	}
-	get values() {
-		return this._values;
-	}
-	set values(values) {
-		this._values = values;
-	}
-	getExpression() {
-		const value = this._values.map((date) => Math.floor(date.getTime() / 1e3));
-		return new ConstExpression({
-			type: ValueType.dateArray,
-			value
-		}, this._editorConfig);
-	}
-};
-var ResponseVariableEditor = class extends ExpressionEditor {
-	_variableName;
-	_variableRef;
-	constructor(variableName, variableType, editorConfig) {
-		super();
-		this._variableName = variableName;
-		this._variableRef = new ValueReference(variableName);
-		this._editorConfig = editorConfig;
-		this.returnType = variableType;
-	}
-	get variableName() {
-		return this._variableName;
-	}
-	get variableRef() {
-		return this._variableRef;
-	}
-	getExpression() {
-		return new ResponseVariableExpression(this._variableName, this._editorConfig);
-	}
-};
-var ContextVariableEditor = class extends ExpressionEditor {
-	_contextType;
-	_key;
-	_args;
-	_asType;
-	constructor(contextType, key, args, asType, editorConfig) {
-		super();
-		this._contextType = contextType;
-		this._key = key;
-		this._args = args;
-		this._asType = asType;
-		this._editorConfig = editorConfig;
-	}
-	getExpression() {
-		return new ContextVariableExpression(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);
-	}
-};
-var CtxPFlagIsDefinedEditor = class extends ContextVariableEditor {
-	returnType = ValueType.boolean;
-	constructor(key, editorConfig) {
-		super(ContextVariableType.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);
-	}
-};
-var CtxPFlagNumEditor = class extends ContextVariableEditor {
-	returnType = ValueType.number;
-	constructor(key, editorConfig) {
-		super(ContextVariableType.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);
-	}
-};
-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);
-		this.returnType = asType;
-	}
-};
-var GroupExpressionEditor = class extends ExpressionEditor {
-	_args;
-	constructor(args, editorConfig) {
-		super();
-		this._args = args;
-		this._editorConfig = editorConfig;
-	}
-	get args() {
-		return this._args;
-	}
-	addArg(arg, position) {
-		if (position === void 0) this._args.push(arg);
-		else this._args.splice(position, 0, arg);
-	}
-	removeArg(position) {
-		this._args.splice(position, 1);
-	}
-	replaceArg(position, arg) {
-		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;
-	}
-};
-var AndExpressionEditor = class extends GroupExpressionEditor {
-	returnType = ValueType.boolean;
-	constructor(args, editorConfig) {
-		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("And expression editor must have boolean arguments");
-		super(args, editorConfig);
-	}
-	getExpression() {
-		return new FunctionExpression("and", this.args.map((arg) => arg.getExpression()), this._editorConfig);
-	}
-};
-var OrExpressionEditor = class extends GroupExpressionEditor {
-	returnType = ValueType.boolean;
-	constructor(args, editorConfig) {
-		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("Or expression editor must have boolean arguments");
-		super(args, editorConfig);
-	}
-	getExpression() {
-		return new FunctionExpression("or", this.args.map((arg) => arg.getExpression()), this._editorConfig);
-	}
-};
-var StrListContainsExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_list;
-	_item;
-	constructor(list, item, editorConfig) {
-		super();
-		if (list.returnType !== ValueType.stringArray) throw new Error("List contains expression editor must have a string array list");
-		if (item.returnType !== ValueType.string) throw new Error("List contains expression editor must have a string item");
-		this._list = list;
-		this._item = item;
-		this._editorConfig = editorConfig;
-	}
-	get list() {
-		return this._list;
-	}
-	get item() {
-		return this._item;
-	}
-	set list(list) {
-		this._list = list;
-	}
-	set item(item) {
-		this._item = item;
-	}
-	getExpression() {
-		return new FunctionExpression("list_contains", [this._list?.getExpression(), this._item?.getExpression()], this._editorConfig);
-	}
-};
-var StrEqExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	getExpression() {
-		return new FunctionExpression("str_eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var EqExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	getExpression() {
-		return new FunctionExpression("eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var GtExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	getExpression() {
-		return new FunctionExpression("gt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var GteExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	getExpression() {
-		return new FunctionExpression("gte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var LtExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	getExpression() {
-		return new FunctionExpression("lt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var LteExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	_a;
-	_b;
-	constructor(a, b, editorConfig) {
-		super();
-		this._a = a;
-		this._b = b;
-		this._editorConfig = editorConfig;
-	}
-	get a() {
-		return this._a;
-	}
-	get b() {
-		return this._b;
-	}
-	set b(b) {
-		this._b = b;
-	}
-	set a(a) {
-		this._a = a;
-	}
-	getExpression() {
-		return new FunctionExpression("lte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
-	}
-};
-var InRangeExpressionEditor = class extends ExpressionEditor {
-	returnType = ValueType.boolean;
-	value;
-	min;
-	max;
-	inclusive;
-	constructor(value, min, max, inclusive, editorConfig) {
-		super();
-		this.value = value;
-		this.min = min;
-		this.max = max;
-		this.inclusive = inclusive;
-		this._editorConfig = editorConfig;
-	}
-	getExpression() {
-		return new FunctionExpression("in_range", [
-			this.value?.getExpression(),
-			this.min?.getExpression(),
-			this.max?.getExpression(),
-			this.inclusive?.getExpression()
-		], this._editorConfig);
-	}
-};
-var SumExpressionEditor = class extends GroupExpressionEditor {
-	returnType = ValueType.number;
-	constructor(args, editorConfig) {
-		super(args, editorConfig);
-	}
-	getExpression() {
-		return new FunctionExpression("sum", this.args.map((arg) => arg.getExpression()), this._editorConfig);
-	}
-};
-var MinExpressionEditor = class extends GroupExpressionEditor {
-	returnType = ValueType.number;
-	constructor(args, editorConfig) {
-		super(args, editorConfig);
-	}
-	getExpression() {
-		return new FunctionExpression("min", this.args.map((arg) => arg.getExpression()), this._editorConfig);
-	}
-};
-var MaxExpressionEditor = class extends GroupExpressionEditor {
-	returnType = ValueType.number;
-	constructor(args, editorConfig) {
-		super(args, editorConfig);
-	}
-	getExpression() {
-		return new FunctionExpression("max", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+		const isComponentVisible = (id, component) => resolve(componentNode(id, component), () => isItemVisible(id) && condition(id, this.survey.surveyItems.get(id)?.displayConditions?.components?.[component], component));
+		const getAnswer = (slotId) => resolve(slotNode(slotId), () => {
+			const owner = this.slots.get(slotId);
+			if (!owner || !isItemVisible(owner.itemId) || !(this.components.get(slotId) ?? []).every((id) => isComponentVisible(owner.itemId, id))) return void 0;
+			const item = this.survey.surveyItems.get(owner.itemId);
+			if (!owner.computed) return item.getActiveResponseValue(slotId, responses[owner.itemId]?.response?.get(slotId), (id) => isComponentVisible(owner.itemId, id), getAnswer);
+			const sources = new ResponseItem();
+			for (const id of item.getComputedResponseDependencies(slotId)) sources.setSlotValue(id, getAnswer(id));
+			return item.getComputedResponseValue(slotId, sources, (id) => isComponentVisible(owner.itemId, id));
+		});
+		const evaluator = new ExpressionEvaluator({
+			responses,
+			surveyContext: context,
+			resolveResponseValue: getAnswer
+		});
+		const getItemResponse = (id) => {
+			const response = new ResponseItem();
+			for (const slot of this.survey.surveyItems.get(id)?.getResponseSlotDefinitions() ?? []) if (!slot.computed) response.setSlotValue(slot.slotId, getAnswer(slot.slotId));
+			return response.isEmpty() ? void 0 : response;
+		};
+		return {
+			evaluator,
+			getAnswer,
+			getItemResponse,
+			isItemVisible,
+			isComponentVisible,
+			getDiagnostics: () => diagnostics.map((diagnostic) => ({ ...diagnostic }))
+		};
 	}
 };
 //#endregion
-//#region src/expressions/editors/expression-editor-generators.ts
-const const_string_array = (...values) => {
-	return new ConstStringArrayEditor(values);
-};
-const const_string = (value) => {
-	return new ConstStringEditor(value);
-};
-const const_number_array = (...values) => {
-	return new ConstNumberArrayEditor(values);
-};
-const const_number = (value) => {
-	return new ConstNumberEditor(value);
-};
-const const_boolean = (value) => {
-	return new ConstBooleanEditor(value);
-};
-const const_date = (value) => {
-	return new ConstDateEditor(value);
-};
-const const_date_array = (...values) => {
-	return new ConstDateArrayEditor(values);
-};
-const response_string = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.string);
-};
-const response_string_array = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.stringArray);
-};
-const response_number = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.number);
-};
-const response_boolean = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.boolean);
-};
-const response_date = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.date);
-};
-const response_number_array = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.numberArray);
-};
-const response_date_array = (valueRef) => {
-	return new ResponseVariableEditor(valueRef, ValueType.dateArray);
-};
-const ctx_locale = () => {
-	return new CtxLocaleEditor();
-};
-const ctx_pflag_is_defined = (key) => {
-	return new CtxPFlagIsDefinedEditor(key);
-};
-const ctx_pflag_string = (key) => {
-	return new CtxPFlagStringEditor(key);
-};
-const ctx_pflag_num = (key) => {
-	return new CtxPFlagNumEditor(key);
-};
-const ctx_pflag_date = (key) => {
-	return new CtxPFlagDateEditor(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);
-};
-const or = (...args) => {
-	return new OrExpressionEditor(args);
-};
-const str_list_contains = (list, item) => {
-	return new StrListContainsExpressionEditor(list, item);
-};
-const str_eq = (a, b) => {
-	return new StrEqExpressionEditor(a, b);
-};
-const eq = (a, b) => {
-	return new EqExpressionEditor(a, b);
-};
-const gt = (a, b) => {
-	return new GtExpressionEditor(a, b);
-};
-const gte = (a, b) => {
-	return new GteExpressionEditor(a, b);
-};
-const lt = (a, b) => {
-	return new LtExpressionEditor(a, b);
-};
-const lte = (a, b) => {
-	return new LteExpressionEditor(a, b);
-};
-const in_range = (value, min, max, inclusive) => {
-	return new InRangeExpressionEditor(value, min, max, inclusive);
-};
-const sum = (...args) => {
-	return new SumExpressionEditor(args);
-};
-const min = (...args) => {
-	return new MinExpressionEditor(args);
-};
-const max = (...args) => {
-	return new MaxExpressionEditor(args);
-};
-//#endregion
 //#region src/engine/engine.ts
-var SurveyEngineCore = class {
+var SurveyEngineCore = class SurveyEngineCore {
+	activeResponsePlan;
+	activeState;
+	responseDiagnostics = /* @__PURE__ */ new Map();
 	surveyDef;
 	renderedSurveyTree;
+	renderedItemsCache;
 	context;
 	locale;
 	sessionSeedValue;
@@ -1378,12 +182,24 @@ var SurveyEngineCore = class {
 		this._openedAt = this._getTimestamp();
 		this.sessionSeedValue = generateId();
 		this.surveyDef = survey;
+		const { issues: configurationIssues, plan } = SurveyEngineCore.inspectConfiguration(survey);
+		if (configurationIssues.length) throw new Error(configurationIssues.join("\n"));
+		this.activeResponsePlan = plan;
 		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;
+		if (prefills) {
+			const registry = survey.getResponseSlotRegistry();
+			this.prefills = Object.create(null);
+			for (const [slotId, value] of Object.entries(prefills)) {
+				const owner = registry.get(slotId);
+				if (!owner || owner.computed) throw new Error(`Cannot restore unknown or computed response slot "${slotId}"`);
+				const item = survey.surveyItems.get(owner.itemId);
+				(this.prefills[owner.itemId] ??= new SurveyItemResponse({
+					itemId: item.id,
+					itemType: item.type
+				}, new ResponseItem())).response.setSlotValue(slotId, value);
+			}
+		}
 		this.prefillEnvironment = options?.prefillEnvironment;
 		this.dateLocales = dateLocales || [{
 			code: "en",
@@ -1391,7 +207,7 @@ var SurveyEngineCore = class {
 		}];
 		this.responses = this.initResponseObject(this.surveyDef.surveyItems);
 		this.initCache();
-		this.applyConfiguredPrefills();
+		if (options?.applyConfiguredPrefills !== false) this.applyConfiguredPrefills();
 		this.evalExpressions();
 		if (!survey.rootItem) throw new Error("constructor: root item not found");
 		this.renderedSurveyTree = this.renderGroup(survey.rootItem);
@@ -1402,7 +218,7 @@ var SurveyEngineCore = class {
 		}];
 	}
 	setContext(context) {
-		this.context = context;
+		this.updateContext(context);
 	}
 	getDateLocales() {
 		return this.dateLocales.slice();
@@ -1417,9 +233,10 @@ var SurveyEngineCore = class {
 		return found?.locale;
 	}
 	updateContext(context) {
+		const localeChanged = this.locale !== context.locale;
 		this.context = context;
 		this.locale = context.locale;
-		this._registerSurveyEvent({
+		if (localeChanged) this._registerSurveyEvent({
 			type: SurveyEventTypes.languageChanged,
 			timestamp: this._getTimestamp(),
 			value: context.locale
@@ -1427,21 +244,49 @@ var SurveyEngineCore = class {
 		this.evalExpressions();
 		this.reRenderSurveyTree();
 	}
+	/** Change the presentation language without losing participant/custom context. */
+	updateLocale(locale) {
+		if (this.context.locale === locale) return false;
+		this.updateContext({
+			...this.context,
+			locale
+		});
+		return true;
+	}
 	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
-		});
+		const item = this.surveyDef.surveyItems.get(targetKey);
+		const previousSlots = structuredClone(target.response?.serialize()?.slots ?? {});
+		const normalized = item.normalizeResponse(response);
+		target.response = normalized.response;
+		this.responseDiagnostics.set(targetKey, normalized.diagnostics ?? []);
+		const nextSlots = target.response?.serialize()?.slots ?? {};
+		const timestamp = this._getTimestamp();
+		const comparable = (value) => value === void 0 ? void 0 : JSON.stringify(value, Object.keys(value).sort());
+		for (const slotId of /* @__PURE__ */ new Set([...Object.keys(previousSlots), ...Object.keys(nextSlots)])) {
+			if (comparable(previousSlots[slotId]) === comparable(nextSlots[slotId])) continue;
+			this._registerSurveyEvent({
+				type: SurveyEventTypes.responseChanged,
+				timestamp,
+				slotId,
+				operation: nextSlots[slotId] === void 0 ? "clear" : "set"
+			});
+		}
 		this.evalExpressions();
 		this.reRenderSurveyTree();
 	}
 	get openedAt() {
 		return this._openedAt;
 	}
+	/** Invalid visibility results in the current evaluation; unanswered conditions are omitted. */
+	getEvaluationDiagnostics() {
+		return this.activeEvaluation().getDiagnostics();
+	}
+	/** Diagnostics from the latest initialization or response update for an item. */
+	getResponseDiagnostics(itemId) {
+		return (this.responseDiagnostics.get(itemId) ?? []).map((diagnostic) => ({ ...diagnostic }));
+	}
 	get sessionSeed() {
 		return this.sessionSeedValue;
 	}
@@ -1468,9 +313,7 @@ var SurveyEngineCore = class {
 				case "large":
 					max = this.surveyDef.maxItemsPerPage.large;
 					break;
-				case "small":
-					max = this.surveyDef.maxItemsPerPage.small;
-					break;
+				case "small": max = this.surveyDef.maxItemsPerPage.small;
 			}
 			if (currentPage.length >= max) {
 				pages.push([...currentPage]);
@@ -1480,8 +323,17 @@ var SurveyEngineCore = class {
 		if (currentPage.length > 0) pages.push([...currentPage]);
 		return pages;
 	}
+	/** Read-only projection, with stable identity until the engine renders a new tree. */
+	getRenderedSurveyItems() {
+		if (this.renderedItemsCache?.tree !== this.renderedSurveyTree) this.renderedItemsCache = {
+			tree: this.renderedSurveyTree,
+			items: Object.freeze(flattenTree(this.renderedSurveyTree).map((item) => Object.freeze(item)))
+		};
+		return this.renderedItemsCache.items;
+	}
 	getRenderedSurveyItem(itemId) {
-		return flattenTree(this.renderedSurveyTree).find((item) => item.id === itemId);
+		const item = this.getRenderedSurveyItems().find((item) => item.id === itemId);
+		return item ? { ...item } : void 0;
 	}
 	onPageChanged(pageIndex) {
 		this._registerSurveyEvent({
@@ -1493,11 +345,44 @@ var SurveyEngineCore = class {
 	getEvents() {
 		return this._events.slice();
 	}
+	/** Current session answers, including retained answers to hidden items. */
 	getResponses() {
+		return this.collectResponses(true);
+	}
+	/** Answers to currently visible items and response slots on every page; does not erase hidden session answers. */
+	getSubmissionResponses() {
+		return this.collectResponses(false);
+	}
+	/** Flat submission with events and item metadata kept separate from answer identity. */
+	getSurveyResponse(key, includeHidden = false) {
+		const response = new SurveyResponse(key);
+		for (const item of this.collectResponses(includeHidden)) response.addItemResponse(item);
+		response.evaluationContext = structuredClone({
+			locale: this.context.locale,
+			participantFlags: this.context.participantFlags
+		});
+		response.events = structuredClone(this._events);
+		response.context = this.context.customValues && structuredClone(this.context.customValues);
+		return response;
+	}
+	getAnswer(slotId) {
+		const owner = this.surveyDef.getResponseSlotRegistry().get(slotId);
+		if (!owner) throw new Error(`Unknown response slot "${slotId}"`);
+		return owner.computed ? this.getComputedResponseValue(slotId) : this.responses[owner.itemId]?.response?.get(slotId);
+	}
+	setAnswer(slotId, value) {
+		const owner = this.surveyDef.getResponseSlotRegistry().get(slotId);
+		if (!owner || owner.computed) throw new Error(`Cannot write unknown or computed response slot "${slotId}"`);
+		const response = this.responses[owner.itemId]?.response?.clone() ?? new ResponseItem();
+		response.setSlotValue(slotId, value);
+		this.setResponse(owner.itemId, response);
+	}
+	collectResponses(includeHidden) {
 		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 active = includeHidden ? void 0 : this.activeEvaluation();
 		const responses = [];
 		this.surveyDef.surveyItems.forEach((item, itemId) => {
 			if (!item.isInteractive()) return;
@@ -1505,10 +390,31 @@ var SurveyEngineCore = class {
 			if (!response) return;
 			const position = renderedPositions.get(itemId);
 			response.meta = position === void 0 ? void 0 : { position };
-			responses.push(response);
+			if (!includeHidden && position === void 0) return;
+			if (includeHidden) {
+				responses.push(response);
+				return;
+			}
+			const submission = new SurveyItemResponse(response, active.getItemResponse(itemId));
+			submission.meta = response.meta && { ...response.meta };
+			responses.push(submission);
 		});
 		return responses;
 	}
+	/** Author and intrinsic validation failures, restricted to currently rendered items. */
+	getInvalidResponseItems(itemIds) {
+		const rendered = new Set(this.getRenderedSurveyItems().map((item) => item.id));
+		return [...new Set(itemIds ?? rendered)].filter((id) => rendered.has(id) && Object.values(this.getValidationValues(id) ?? {}).some((valid) => !valid));
+	}
+	getIntrinsicValidationValues(itemKey) {
+		const active = this.activeEvaluation();
+		if (!active.isItemVisible(itemKey)) return {};
+		return { ...this.surveyDef.surveyItems.get(itemKey)?.getResponseValidationValues(active.getItemResponse(itemKey), (id) => active.isComponentVisible(itemKey, id), (expression) => active.evaluator.eval(Expression.deserialize(expression))) };
+	}
+	getAuthorValidationValues(itemKey) {
+		if (!this.activeEvaluation().isItemVisible(itemKey)) return {};
+		return Object.fromEntries(Object.entries(this.cache.validations[itemKey] ?? {}).map(([key, validation]) => [key, validation.result]));
+	}
 	getDisplayConditionValue(itemKey, componentKey) {
 		if (componentKey) return this.cache.displayConditions[itemKey]?.components?.[componentKey]?.result;
 		return this.cache.displayConditions[itemKey]?.root?.result;
@@ -1520,12 +426,9 @@ var SurveyEngineCore = class {
 		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;
-		}, {});
+		const result = this.getIntrinsicValidationValues(itemKey);
+		for (const [key, valid] of Object.entries(this.getAuthorValidationValues(itemKey))) result[key] = valid && (result[key] ?? true);
+		return Object.keys(result).length ? result : void 0;
 	}
 	initCache() {
 		this.cache = {
@@ -1595,40 +498,39 @@ var SurveyEngineCore = class {
 	initResponseObject(items) {
 		const respGroup = {};
 		items.forEach((item, itemId) => {
-			if (!item.isInteractive) return;
+			if (!item.isInteractive()) return;
 			else {
 				const prefill = this.prefills?.[itemId];
 				const applyPrefill = prefill && prefill.itemType === item.type;
+				const normalized = item.normalizeResponse(applyPrefill ? prefill.response : void 0);
+				this.responseDiagnostics.set(itemId, normalized.diagnostics ?? []);
 				respGroup[itemId] = new SurveyItemResponse({
 					itemId,
 					itemType: item.type
-				}, applyPrefill ? prefill.response : void 0);
+				}, normalized.response);
 			}
 		});
 		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);
+			this.evalTemplateValues(this.createEvaluator());
 			let changedInPass = false;
 			this.surveyDef.surveyItems.forEach((item) => {
 				if (!item.isInteractive()) return;
-				changedInPass = this.applyConfiguredPrefillsForItem(item, evalEngine) || changedInPass;
+				changedInPass = this.applyConfiguredPrefillsForItem(item) || changedInPass;
 			});
 			if (!changedInPass) break;
 		}
-		this.evalTemplateValues(evalEngine);
+		this.evalTemplateValues(this.createEvaluator());
 	}
-	applyConfiguredPrefillsForItem(item, evalEngine) {
+	applyConfiguredPrefillsForItem(item) {
 		const responseItem = this.responses[item.id];
 		if (!responseItem) return false;
 		let changed = false;
 		for (const prefill of item.prefills ?? []) {
+			const evalEngine = this.createEvaluator();
 			const targetSlot = item.resolvePrefillTarget(prefill.target);
 			if (!targetSlot) continue;
 			if ((prefill.apply ?? SurveyItemPrefillApplyMode.ifEmpty) === SurveyItemPrefillApplyMode.ifEmpty && responseItem.response?.get(targetSlot.slotId) !== void 0) continue;
@@ -1639,8 +541,11 @@ var SurveyEngineCore = class {
 			if (!normalizedValue) continue;
 			const nextResponse = responseItem.response?.clone() ?? new ResponseItem();
 			nextResponse.setSlotValue(targetSlot.slotId, normalizedValue);
-			responseItem.response = nextResponse.isEmpty() ? void 0 : nextResponse;
-			changed = true;
+			const normalized = item.normalizeResponse(nextResponse);
+			this.responseDiagnostics.set(item.id, normalized.diagnostics ?? []);
+			const next = normalized.response?.isEmpty() ? void 0 : normalized.response;
+			if (JSON.stringify(responseItem.response?.serialize()) !== JSON.stringify(next?.serialize())) changed = true;
+			responseItem.response = next;
 		}
 		return changed;
 	}
@@ -1656,11 +561,9 @@ var SurveyEngineCore = class {
 			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
+					slotId: prefill.source.ref.slotId
 				});
 				if (!resolved) return;
 				return resolved;
@@ -1726,6 +629,11 @@ var SurveyEngineCore = class {
 		};
 	}
 	renderGroup(groupDef, parent) {
+		if (!this.activeEvaluation().isItemVisible(groupDef.id)) return {
+			id: groupDef.id,
+			type: groupDef.type,
+			items: []
+		};
 		if (!parent) parent = {
 			id: groupDef.id,
 			type: "group",
@@ -1747,13 +655,48 @@ var SurveyEngineCore = class {
 	getResponseItem(itemId) {
 		return this.responses[itemId];
 	}
+	/** Resolve computed references against current answers and conditions, with cycle detection. */
+	getComputedResponseValue(slotId) {
+		return this.activeEvaluation().getAnswer(slotId);
+	}
+	/** Evaluate against the same current responses/context used by conditions and prefills. */
+	evaluateExpression(expression) {
+		return this.activeEvaluation().evaluator.eval(Expression.deserialize(expression));
+	}
+	activeEvaluation() {
+		return this.activeState ??= this.activeResponsePlan.evaluate(this.responses, this.context);
+	}
+	createEvaluator() {
+		return this.activeResponsePlan.evaluate(this.responses, this.context).evaluator;
+	}
+	/** Active answer used by conditions and scoring; hidden session values remain in getAnswer(). */
+	getActiveAnswer(slotId) {
+		return this.activeEvaluation().getAnswer(slotId);
+	}
+	/** Validate static runtime contracts without constructing a response session. */
+	static getConfigurationIssues(survey) {
+		return SurveyEngineCore.inspectConfiguration(survey).issues;
+	}
+	static inspectConfiguration(survey) {
+		const issues = [...survey.surveyItems.values()].flatMap((item) => item.getExecutionConfigurationIssues().map((issue) => `${(item.metadata?.itemLabel ?? "")?.trim() || item.id}: ${issue}`));
+		let plan;
+		try {
+			plan = new ActiveResponsePlan(survey);
+		} catch (error) {
+			issues.push(error instanceof Error ? error.message : String(error));
+		}
+		issues.push(...survey.getResponseSlotRegistry().diagnostics.map((diagnostic) => diagnostic.message));
+		issues.push(...survey.getBlockingExpressionIssues());
+		return {
+			issues,
+			plan
+		};
+	}
 	evalExpressions() {
-		const evalEngine = new ExpressionEvaluator({
-			responses: this.responses,
-			surveyContext: this.context
-		});
+		this.activeState = this.activeResponsePlan.evaluate(this.responses, this.context);
+		const evalEngine = this.activeState.evaluator;
 		this.evalTemplateValues(evalEngine);
-		this.evalDisplayConditions(evalEngine);
+		this.evalDisplayConditions();
 		this.evalDisableConditions(evalEngine);
 		this.evalValidations(evalEngine);
 	}
@@ -1778,34 +721,18 @@ var SurveyEngineCore = class {
 					}
 					evaluatedValue = {
 						type: ValueType.string,
-						value: format(/* @__PURE__ */ new Date(evaluatedValue.value * 1e3), templateValue.templateDef.dateFormat)
+						value: formatCalendarDate(evaluatedValue.value, 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;
-			});
-		});
+	evalDisplayConditions() {
+		const active = this.activeEvaluation();
+		for (const [itemId, conditions] of Object.entries(this.cache.displayConditions)) {
+			if (conditions.root) conditions.root.result = active.isItemVisible(itemId);
+			for (const [id, condition] of Object.entries(conditions.components ?? {})) condition.result = active.isComponentVisible(itemId, id);
+		}
 	}
 	evalDisableConditions(evalEngine) {
 		Object.keys(this.cache.disabledConditions).forEach((itemKey) => {
@@ -1827,6 +754,7 @@ var SurveyEngineCore = class {
 				const resolvedValue = evalEngine.eval(validation[validationKey].expression);
 				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
 					console.warn("evalValidations: validation expression returned undefined: " + itemId + "." + validationKey);
+					this.cache.validations[itemId][validationKey].result = false;
 					return;
 				}
 				this.cache.validations[itemId][validationKey].result = resolvedValue.value;
@@ -1845,6 +773,9 @@ const flattenTree = (itemTree) => {
 //#endregion
 //#region src/json-patch.ts
 var JsonPatchError = class extends Error {
+	code;
+	path;
+	operationIndex;
 	constructor(message, code, path, operationIndex) {
 		super(message);
 		this.code = code;
@@ -1902,7 +833,8 @@ const getValueAtSegments = (document, segments, path) => {
 	return current;
 };
 const getValueAtJsonPointer = (document, pointer) => {
-	return getValueAtSegments(document, parseJsonPointer(pointer), pointer);
+	const segments = parseJsonPointer(pointer);
+	return getValueAtSegments(document, segments, pointer);
 };
 const deepEqualJson = (left, right) => {
 	if (left === right) return true;
@@ -1937,7 +869,12 @@ const applyAdd = (document, path, value) => {
 		return document;
 	}
 	if (!isRecord(parent)) throw new JsonPatchError(`JSON pointer "${path}" parent is not an object or array.`, "invalid-target-parent", path);
-	parent[key] = structuredCloneMethod(value);
+	Object.defineProperty(parent, key, {
+		configurable: true,
+		enumerable: true,
+		value: structuredCloneMethod(value),
+		writable: true
+	});
 	return document;
 };
 const applyRemove = (document, path) => {
@@ -2005,9 +942,11 @@ const applyJsonPatch = (document, operations) => {
 					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);
+				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) {
 			if (error instanceof JsonPatchError) throw new JsonPatchError(error.message, error.code, error.path, operationIndex);
@@ -2017,93 +956,13 @@ const applyJsonPatch = (document, operations) => {
 	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"
-};
-//#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);
-}
-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}`;
-		}
-		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("; ");
-		}
-		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("; ");
-		}
-		default: return String(value.value ?? "");
-	}
-}
-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 ?? "");
-	}
+//#region src/response-exporter/validate-configuration.ts
+/** Allow incomplete authoring drafts, but never export invalid item coding paths. */
+function validateExportConfiguration(survey, registry = survey.getResponseSlotRegistry()) {
+	const issues = [...survey.surveyItems.values()].flatMap((item) => item.getExecutionConfigurationIssues().map((issue) => `${(item.metadata?.itemLabel ?? "")?.trim() || item.id}: ${issue}`));
+	issues.push(...registry.diagnostics.map((diagnostic) => diagnostic.message));
+	issues.push(...survey.getBlockingExpressionIssues());
+	if (issues.length) throw new Error(issues.join("\n"));
 }
 //#endregion
 //#region src/response-exporter/csv-serializer.ts
@@ -2141,181 +1000,226 @@ function serializeToCsv(columns, rows, options) {
 }
 //#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 "";
+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
+			}
+		};
 	}
-}
-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
-				});
+	compileContexts() {
+		return new Map(this.batches.map((batch) => {
+			const registry = batch.schema.getResponseSlotRegistry();
+			validateExportConfiguration(batch.schema, registry);
+			const slots = new Map(registry.definitions.map((slot) => [slot.slotId, slot]));
+			const profile = this.profile(batch);
+			const transforms = new Map([...slots.values()].map((slot) => [slot.slotId, {
+				...DEFAULT_TRANSFORM,
+				...slot.exportSettings,
+				...profile?.slotOverrides?.[slot.slotId]
+			}]));
+			const columns = [...slots.values()].flatMap((slot) => projectSlot(slot, transforms.get(slot.slotId)).map((column) => ({
+				...column,
+				header: 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 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
+			return [batch, {
+				registry,
+				slots,
+				profile,
+				transforms,
+				encodings,
+				columns,
+				included: new Set(columns.map((column) => column.id)),
+				activePlan: columns.some((column) => slots.get(column.slotId)?.computed) ? new ActiveResponsePlan(batch.schema) : void 0
+			}];
 		}));
-		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.context ?? {})));
+		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" ? 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.context ?? {})))];
+		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 recorded = Object.create(null);
+		if (context.activePlan) for (const [slotId, value] of Object.entries(response.answers)) {
+			const slot = slots.get(slotId);
+			const item = batch.schema.surveyItems.get(slot.itemId);
+			(recorded[slot.itemId] ??= new SurveyItemResponse({
+				itemId: slot.itemId,
+				itemType: item.type
+			}, new ResponseItem())).response.setSlotValue(slotId, structuredClone(value));
+		}
+		const active = context.activePlan?.evaluate(recorded, {
+			locale: response.evaluationContext?.locale ?? batch.schema.locales[0] ?? "en",
+			participantFlags: response.evaluationContext?.participantFlags,
+			customValues: response.context
+		});
+		for (const column of columns) if (column.source === ExportColumnSource.meta) switch (column.metaField) {
+			case "responseId":
+				row[column.header] = response.key;
+				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 = response.context?.[column.contextKey];
+			row[column.header] = exportSingleResponseSlot({
+				value,
+				valueType: value?.type ?? ValueType.string,
+				transformConfig: 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, slot.computed ? active?.getAnswer(slot.slotId) : response.answers[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);
 	}
-	exportResponsesToCsv(responses, options) {
-		if (responses.length === 0) return "";
-		return serializeToCsv(this.computeColumnsForBatch(responses), responses.map((r) => this.exportResponse(r)).filter((r) => r !== null), options);
+	rows(columns, contexts) {
+		return this.batches.flatMap((batch) => batch.responses.map((response) => this.row(response, batch, columns, contexts.get(batch))));
+	}
+	exportResponsesToCsv(options) {
+		const contexts = this.compileContexts();
+		const columns = this.columns(contexts);
+		return serializeToCsv(columns, this.rows(columns, contexts), options);
 	}
 };
 //#endregion
@@ -2324,20 +1228,35 @@ var SurveyResponseExporter = class {
 * Generate a structured codebook from a survey definition.
 */
 function generateCodebook(survey, options) {
+	const registry = survey.getResponseSlotRegistry();
+	validateExportConfiguration(survey, registry);
+	const slots = registry.definitions;
 	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,
+			primitiveId: slot.primitiveId,
+			...slot.rowId ? { rowId: slot.rowId } : {},
+			...slot.columnId ? { columnId: slot.columnId } : {},
+			variableName: slot.variableName,
+			valueType: slot.valueType,
+			encoding: resolvedSlotEncoding(slot, {
+				mode: "default",
+				...slot.exportSettings,
+				...options?.profile?.slotOverrides?.[slot.slotId]
+			}),
+			optionLabels: slot.referenceValueLabels,
+			allowedValues: slot.allowedValues,
+			...slot.computed ? { computed: structuredClone(slot.computed) } : {},
+			...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 ?? [];
 		const slotList = slotDefsByItemId.get(item.id) ?? [];
 		slotList.sort((a, b) => a.slotId.localeCompare(b.slotId));
 		let contentByLocale;
@@ -2355,8 +1274,8 @@ function generateCodebook(survey, options) {
 		}
 		items.push({
 			id: item.id,
-			key,
-			keyPath,
+			editorName: survey.resolveItemEditorName(item.id, locales[0]),
+			breadcrumb: survey.getItemDisplayPath(item.id, locales[0]).breadcrumb,
 			type: item.type,
 			interactive: item.isInteractive(),
 			slots: slotList,
@@ -2365,10 +1284,41 @@ function generateCodebook(survey, options) {
 	}
 	return {
 		surveyKey: survey.surveyKey,
-		items: items.sort((a, b) => a.key.localeCompare(b.key))
+		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: batch.schema.getResponseSlotRegistry().definitions.map((slot) => ({
+				...slot,
+				encoding: resolvedSlotEncoding(slot, {
+					mode: "default",
+					...slot.exportSettings,
+					...options.profile?.slotOverrides?.[slot.slotId] ?? batch.profile?.slotOverrides?.[slot.slotId]
+				})
+			}))
+		}))
 	};
 }
 //#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_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, findIntroducedExpressionReferenceDiagnostics, flattenTree, generateCodebook, generateCodingKey, generateId, getAssetUsagesFromContent, getContentPlainText, getItemExpressionDefinition, getPlainTextFromRichTextContent, getValueAtJsonPointer, gt, gte, hasRenderableRichTextBlock, hasRenderableRichTextContent, in_range, initValueForType, 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 { ActiveResponsePlan, AndExpressionEditor, CURRENT_SURVEY_SCHEMA, CURRENT_SURVEY_SCHEMA_VERSION, ConstBooleanEditor, ConstDateArrayEditor, ConstDateEditor, ConstExpression, ConstNumberArrayEditor, ConstNumberEditor, ConstStringArrayEditor, ConstStringEditor, ContentType, ContextVariableExpression, ContextVariableType, CtxCustomExpressionEditor, CtxCustomValueEditor, CtxLocaleEditor, CtxPFlagDateEditor, CtxPFlagIsDefinedEditor, CtxPFlagNumEditor, CtxPFlagStringEditor, DATE_FUNCTION_SIGNATURES, DEFAULT_TRANSFORM, DurationUnits, EXPORTER_PROFILE_SCHEMA_VERSION, EqExpressionEditor, Expression, ExpressionEditor, ExpressionEvaluator, ExpressionType, FunctionExpression, FunctionExpressionNames, GroupItemCore, GtExpressionEditor, GteExpressionEditor, InRangeExpressionEditor, JsonPatchError, LtExpressionEditor, LteExpressionEditor, META_COLUMN_ORDER, MaxExpressionEditor, MinExpressionEditor, NumberPrecision, OrExpressionEditor, PageBreakItemCore, RESPONSE_VARIABLE_NAME_MAX_LENGTH, ReferenceUsageType, ReservedSurveyItemTypes, ResponseItem, ResponseSlotRegistry, ResponseVariableEditor, ResponseVariableExpression, SURVEY_EDITOR_ITEM_COLORS, SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY, SURVEY_RESPONSE_SCHEMA_VERSION, SlotTransformMode, StrEqExpressionEditor, StrListContainsExpressionEditor, SumExpressionEditor, Survey, SurveyEngineCore, SurveyEventTypes, SurveyItemCore, SurveyItemPrefillApplyMode, SurveyItemPrefillTargetType, SurveyItemResponse, SurveyItemTranslations, SurveyResponse, SurveyResponseExporter, SurveyTranslations, TemplateDefTypes, ValueReference, ValueReferenceMethod, ValueType, addCalendarDate, allocateResponseVariableName, analyzeSurveyExpressionReferences, and, applyJsonPatch, assertResponseValue, buildItemExpression, builtInItemCoreRegistry, calendarDateBounds, calendarDateFromLocalDate, calendarDatePrecision, calendarDateToLocalDate, collectConfigValueExpressions, collectExpressionResponseReferences, collectSurveyExpressionLocations, compareCalendarDates, 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, 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, deserializeSurveyItemPrefill, deserializeTemplateValue, deserializeTemplateValues, differenceCalendarDates, encodeExportColumnId, encodeJsonPointerSegment, eq, escapeCsvCell, exportSingleResponseSlot, expressionReferenceDiagnosticKey, findIntroducedBlockingExpressionReferenceDiagnostics, findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories, flattenTree, formatCalendarDate, formatProjectedValue, generateCodebook, generateCodingKey, generateExportCodebook, generateId, getAssetUsagesFromContent, getCompositionLabel, getContentPlainText, getDefaultProjectionIssues, getItemExpressionDefinition, getPlainTextFromRichTextContent, getValueAtJsonPointer, gt, gte, hasRenderableRichTextBlock, hasRenderableRichTextContent, in_range, initValueForType, invalidResponseDomainValues, isBlockingSurveyExpressionReferenceDiagnostic, isBuiltInItemType, isCalendarDate, isContentEmpty, isLegacyItemGroupComponent, isLegacySurveyGroupItem, isResponseValue, isValidResponseVariableName, lt, lte, max, min, optionMapping, or, parseJsonPointer, prefillTargetsEqual, projectSlot, replaceResponseVariableReferences, resolveUniqueItemKey, responseValueElements, responseValueReferenceIds, responseValuesEqual, 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, suggestResponseVariableName, sum, toItemTypeDefinitionRegistry, validateLocale, validateResponseSlotValue };
 
 //# sourceMappingURL=index.mjs.map