@case-framework/survey-core 0.8.0 → 0.9.0

package/build/index.mjs

@@ -1,776 +1,8 @@
-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 { $ as inspectAnnotated, A as slotPrefillSchema, B as ValueType, C as createCompositionSchema, Ct as calendarDaySchema, D as followUpBody, Dt as isCalendarDate, E as elementShape, Et as formatCalendarDate, F as richTextImageDimensionSchema, G as stringRecord, H as isResponseValue, I as richTextImageSourceSchema, J as boundField, K as annotated, L as surveyContentSchema, M as templateValueSchema, N as validationRuleSchema, O as itemEditorMetadataSchema, Ot as isCalendarDateUnit, P as jsonValueSchema, Q as extendObject, R as DurationUnits, S as conditionsShape, St as calendarDateToLocalDate, T as createSurveySchema, Tt as differenceCalendarDates, U as ownValue, V as assertResponseValue, W as setOwnValue, X as contentOwnerIds, Y as contentOwner, Z as expressionField, _ as hasRenderableRichTextBlock, _t as CALENDAR_DATE_UNITS, a as getLocalizationItems, at as expressionEditorConfigSchema, b as CURRENT_SURVEY_SCHEMA, bt as calendarDateFromLocalDate, c as listLocalizationEntries, ct as responseValueSchema, d as validateLocalizationRef, dt as remapExpression, et as ownedId, f as ContentType, ft as expressionArguments, g as getPlainTextFromRichTextContent, gt as visitExpression, h as getContentPlainText, ht as unreachable, i as getLocalizationEntryKey, it as transformAnnotated, j as slotTransformSchema, k as layoutPolicySchema, l as readLocalizationContent, lt as valueTypeSchema, m as getAssetUsagesFromContent, mt as transformExpression, n as getLocalizationCellKey, nt as remapAnnotated, o as hasLocalizationText, ot as expressionSchema, p as createRichTextContent, pt as operand, q as annotatedReferences, r as getLocalizationCoverage, rt as schemaAnnotation, s as isEmptySurveyLocalizationEntry, st as functionNameSchema, t as SURVEY_LOCALIZATION_SURFACES, tt as referenceId, u as resolveParticipantContent, ut as collectExpressionDependencies, v as hasRenderableRichTextContent, vt as addCalendarDate, w as createFlowItemSchema, wt as compareCalendarDates, x as CURRENT_SURVEY_SCHEMA_VERSION, xt as calendarDatePrecision, y as isContentEmpty, yt as calendarDateBounds, z as NumberPrecision } from "./localization-1lzNpyFX.mjs";
+import { $ as shuffleArray, A as isAdmissibleInDraft, B as expressionIssues, C as surveyEventSchema, D as DefinitionError, E as hasPermittedChange, F as allocateResponseVariableName, G as responseValueElements, H as functionTypeIssues, I as isValidResponseVariableName, J as FUNCTION_SIGNATURES, K as responseValuesEqual, L as suggestResponseVariableName, M as getCompositionLabel, N as ResponseSlotRegistry, O as Survey, P as RESPONSE_VARIABLE_NAME_MAX_LENGTH, Q as resolveUniqueItemKey, R as ExpressionEvaluationError, S as itemResponseMetadataSchema, T as canWriteSelection, U as inferExpressionReturnType, V as expressionTypeIssues, W as invalidResponseDomainValues, X as generateCodingKey, Y as createSeededRandom, Z as generateId, _ as SlotTransformMode, a as optionIds, b as surveyResponseSchema, c as resolvedSlotEncoding, d as exportSingleResponseSlot, et as shuffleIndices, f as decodeExportColumnId, g as META_COLUMN_ORDER, h as ExportColumnSource, i as localizedExportSlots, j as surveyLocales, k as checkDocumentBudget, l as BooleanExportValues, m as EXPORTER_PROFILE_SCHEMA_VERSION, n as getDefaultProjectionDiagnostics, o as optionMapping, p as encodeExportColumnId, q as validateResponseSlotValue, r as getDefaultProjectionIssues, s as projectSlot, t as formatProjectedValue, tt as structuredCloneMethod, u as DEFAULT_TRANSFORM, v as SURVEY_RESPONSE_SCHEMA_VERSION, w as SurveyStateGraph, x as SurveyEventTypes, y as SurveyResponse, z as evaluateExpression } from "./projection-DrLPFroE.mjs";
+import { t as strictKeyedObject } from "./keyed-object-D1yh_W5v.mjs";
 import { format } from "date-fns/format";
-import { enUS } from "date-fns/locale/en-US";
-//#region src/to_mirgrate/data_types/legacy-types.ts
-const isLegacyItemGroupComponent = (item) => {
-	const items = item.items;
-	return items !== void 0 && items.length > 0;
-};
-const isLegacySurveyGroupItem = (item) => {
-	const items = item.items;
-	return items !== void 0 && items.length > 0;
-};
-//#endregion
-//#region src/survey/responses/response-meta.ts
-const SurveyEventTypes = {
-	openSurvey: "openSurvey",
-	pageChanged: "pageChanged",
-	responseChanged: "responseChanged",
-	languageChanged: "languageChanged"
-};
-//#endregion
-//#region src/expressions/item-expression-registry.ts
-function getItemExpressionDefinition(definitions, expressionId) {
-	return definitions?.find((definition) => definition.id === expressionId);
-}
-function buildItemExpression(item, definitions, expressionId, params) {
-	const definition = getItemExpressionDefinition(definitions, expressionId);
-	if (!definition) throw new Error(`Unknown item expression: ${expressionId}`);
-	return definition.buildExpression(item, params);
-}
-//#endregion
-//#region src/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]);
-		}
-		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})`);
-			}
-		}
-		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
-			});
-			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);
-		});
-		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/engine/engine.ts
-var SurveyEngineCore = class SurveyEngineCore {
-	activeResponsePlan;
-	activeState;
-	responseDiagnostics = /* @__PURE__ */ new Map();
-	surveyDef;
-	renderedSurveyTree;
-	renderedItemsCache;
-	context;
-	locale;
-	sessionSeedValue;
-	responses;
-	prefills;
-	_events;
-	_openedAt;
-	dateLocales;
-	prefillEnvironment;
-	cache;
-	constructor(survey, context, prefills, dateLocales, options) {
-		this._openedAt = this._getTimestamp();
-		this.sessionSeedValue = generateId();
-		this.surveyDef = survey;
-		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;
-		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",
-			locale: enUS
-		}];
-		this.responses = this.initResponseObject(this.surveyDef.surveyItems);
-		this.initCache();
-		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);
-		this._events = [{
-			type: SurveyEventTypes.openSurvey,
-			timestamp: this._getTimestamp(),
-			value: this.context.locale
-		}];
-	}
-	setContext(context) {
-		this.updateContext(context);
-	}
-	getDateLocales() {
-		return this.dateLocales.slice();
-	}
-	getCurrentDateLocale() {
-		const found = this.dateLocales.find((dl) => dl.code === this.locale);
-		if (!found) {
-			console.warn(`Locale '${this.locale}' is not available. Using default locale.`);
-			if (this.dateLocales.length > 0) return this.dateLocales[0].locale;
-			return enUS;
-		}
-		return found?.locale;
-	}
-	updateContext(context) {
-		const localeChanged = this.locale !== context.locale;
-		this.context = context;
-		this.locale = context.locale;
-		if (localeChanged) this._registerSurveyEvent({
-			type: SurveyEventTypes.languageChanged,
-			timestamp: this._getTimestamp(),
-			value: context.locale
-		});
-		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);
-		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;
-	}
-	get survey() {
-		return this.surveyDef;
-	}
-	getSurveyPages(size) {
-		const renderedSurvey = flattenTree(this.renderedSurveyTree);
-		const pages = new Array();
-		if (!size) size = "large";
-		let currentPage = [];
-		renderedSurvey.forEach((item) => {
-			if (item.type === "page-break") {
-				if (currentPage.length > 0) {
-					pages.push([...currentPage]);
-					currentPage = [];
-				}
-				return;
-			}
-			currentPage.push(item);
-			if (!this.surveyDef.maxItemsPerPage) return;
-			let max = 0;
-			switch (size) {
-				case "large":
-					max = this.surveyDef.maxItemsPerPage.large;
-					break;
-				case "small": max = this.surveyDef.maxItemsPerPage.small;
-			}
-			if (currentPage.length >= max) {
-				pages.push([...currentPage]);
-				currentPage = [];
-			}
-		});
-		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) {
-		const item = this.getRenderedSurveyItems().find((item) => item.id === itemId);
-		return item ? { ...item } : void 0;
-	}
-	onPageChanged(pageIndex) {
-		this._registerSurveyEvent({
-			type: SurveyEventTypes.pageChanged,
-			timestamp: this._getTimestamp(),
-			value: pageIndex
-		});
-	}
-	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;
-			const response = this.getResponseItem(itemId);
-			if (!response) return;
-			const position = renderedPositions.get(itemId);
-			response.meta = position === void 0 ? void 0 : { position };
-			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;
-	}
-	getDisabledConditionValue(itemKey, componentKey) {
-		return this.cache.disabledConditions[itemKey]?.components?.[componentKey]?.result;
-	}
-	getTemplateValue(templateValueKey) {
-		return this.cache.templateValues[templateValueKey]?.value;
-	}
-	getValidationValues(itemKey) {
-		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 = {
-			validations: {},
-			displayConditions: {},
-			templateValues: {},
-			disabledConditions: {}
-		};
-		this.surveyDef.getTemplateValueKeys().forEach((templateKey) => {
-			this.cache.templateValues[templateKey] = {
-				value: void 0,
-				templateDef: this.surveyDef.getTemplateValue(templateKey)
-			};
-		});
-		this.surveyDef.surveyItems.forEach((item, itemId) => {
-			if (item.validations && Object.keys(item.validations).length > 0) {
-				this.cache.validations[itemId] = {};
-				Object.keys(item.validations).forEach((validationKey) => {
-					const valExp = item.validations[validationKey];
-					if (!valExp) {
-						console.warn("initCache: validation expression not found: " + itemId + " " + validationKey);
-						return;
-					}
-					this.cache.validations[itemId][validationKey] = {
-						expression: valExp,
-						result: false
-					};
-				});
-			}
-			if (item.displayConditions !== void 0 && (item.displayConditions.root || item.displayConditions.components)) {
-				this.cache.displayConditions[itemId] = {};
-				if (item.displayConditions.root) this.cache.displayConditions[itemId].root = {
-					expression: item.displayConditions.root,
-					result: false
-				};
-				if (item.displayConditions.components) {
-					this.cache.displayConditions[itemId].components = {};
-					Object.keys(item.displayConditions.components).forEach((componentKey) => {
-						const compExp = item.displayConditions?.components?.[componentKey];
-						if (!compExp) {
-							console.warn("initCache: display condition component expression not found: " + itemId + " " + componentKey);
-							return;
-						}
-						this.cache.displayConditions[itemId].components[componentKey] = {
-							expression: compExp,
-							result: false
-						};
-					});
-				}
-			}
-			if (item.disabledConditions !== void 0 && item.disabledConditions.components !== void 0) {
-				this.cache.disabledConditions[itemId] = { components: {} };
-				Object.keys(item.disabledConditions.components).forEach((componentKey) => {
-					const compExp = item.disabledConditions?.components?.[componentKey];
-					if (!compExp) {
-						console.warn("initCache: disabled condition component expression not found: " + itemId + " " + componentKey);
-						return;
-					}
-					this.cache.disabledConditions[itemId].components[componentKey] = {
-						expression: compExp,
-						result: false
-					};
-				});
-			}
-		});
-	}
-	initResponseObject(items) {
-		const respGroup = {};
-		items.forEach((item, itemId) => {
-			if (!item.isInteractive()) return;
-			else {
-				const prefill = this.prefills?.[itemId];
-				const applyPrefill = prefill && prefill.itemType === item.type;
-				const normalized = item.normalizeResponse(applyPrefill ? prefill.response : void 0);
-				this.responseDiagnostics.set(itemId, normalized.diagnostics ?? []);
-				respGroup[itemId] = new SurveyItemResponse({
-					itemId,
-					itemType: item.type
-				}, normalized.response);
-			}
-		});
-		return respGroup;
-	}
-	applyConfiguredPrefills() {
-		const maxPasses = Math.max(this.surveyDef.surveyItems.size, 1);
-		for (let pass = 0; pass < maxPasses; pass++) {
-			this.evalTemplateValues(this.createEvaluator());
-			let changedInPass = false;
-			this.surveyDef.surveyItems.forEach((item) => {
-				if (!item.isInteractive()) return;
-				changedInPass = this.applyConfiguredPrefillsForItem(item) || changedInPass;
-			});
-			if (!changedInPass) break;
-		}
-		this.evalTemplateValues(this.createEvaluator());
-	}
-	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;
-			if (!this.shouldApplyConfiguredPrefill(prefill, evalEngine)) continue;
-			const resolvedValue = this.resolveConfiguredPrefillValue(prefill, targetSlot, evalEngine);
-			if (!resolvedValue) continue;
-			const normalizedValue = item.normalizePrefillValue(prefill, targetSlot, resolvedValue);
-			if (!normalizedValue) continue;
-			const nextResponse = responseItem.response?.clone() ?? new ResponseItem();
-			nextResponse.setSlotValue(targetSlot.slotId, normalizedValue);
-			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;
-	}
-	shouldApplyConfiguredPrefill(prefill, evalEngine) {
-		if (!prefill.when) return true;
-		const resolved = evalEngine.eval(prefill.when);
-		return resolved?.type === ValueType.boolean && resolved.value === true;
-	}
-	resolveConfiguredPrefillValue(prefill, _target, evalEngine) {
-		switch (prefill.source.type) {
-			case "static": return prefill.source.value;
-			case "expression": return evalEngine.eval(prefill.source.expression);
-			case "templateValue": return this.getTemplateValue(prefill.source.key);
-			case "previousResponse": {
-				if (!this.prefillEnvironment?.getPreviousResponse) return;
-				const resolved = this.prefillEnvironment.getPreviousResponse({
-					surveyKey: prefill.source.ref.surveyKey,
-					slotId: prefill.source.ref.slotId
-				});
-				if (!resolved) return;
-				return resolved;
-			}
-			default: return;
-		}
-	}
-	shouldRender(itemId, componentId) {
-		const displayConditionResult = this.getDisplayConditionValue(itemId, componentId);
-		if (displayConditionResult !== void 0) return displayConditionResult;
-		return true;
-	}
-	sequentialRender(groupDef) {
-		const newItems = [];
-		for (const itemId of groupDef.items || []) {
-			if (!this.shouldRender(itemId)) continue;
-			const itemDef = this.surveyDef.surveyItems.get(itemId);
-			if (!itemDef) {
-				console.warn("sequentialRender: item not found: " + itemId);
-				continue;
-			}
-			if (itemDef.type === "group") {
-				newItems.push(this.renderGroup(itemDef));
-				continue;
-			}
-			newItems.push({
-				id: itemId,
-				type: itemDef.type
-			});
-		}
-		return {
-			id: groupDef.id,
-			type: "group",
-			items: newItems
-		};
-	}
-	randomizedItemRender(groupDef, parent) {
-		const newItems = parent.items?.filter((rItem) => this.shouldRender(rItem.id)) || [];
-		const itemIds = groupDef.items || [];
-		const shuffledIndices = shuffleIndices(itemIds.length);
-		for (const index of shuffledIndices) {
-			const itemId = itemIds[index];
-			if (parent.items?.find((rItem) => rItem.id === itemId)) continue;
-			if (!this.shouldRender(itemId)) continue;
-			const itemDef = this.surveyDef.surveyItems.get(itemId);
-			if (!itemDef) {
-				console.warn("randomizedItemRender: item not found: " + itemId);
-				continue;
-			}
-			if (itemDef.type === "group") {
-				newItems.push(this.renderGroup(itemDef, parent));
-				continue;
-			}
-			newItems.push({
-				id: itemId,
-				type: itemDef.type
-			});
-		}
-		return {
-			id: groupDef.id,
-			type: "group",
-			items: newItems
-		};
-	}
-	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",
-			items: []
-		};
-		if (groupDef.config.shuffleItems) return this.randomizedItemRender(groupDef, parent);
-		return this.sequentialRender(groupDef);
-	}
-	reRenderSurveyTree() {
-		if (!this.surveyDef.rootItem) throw new Error("reRenderSurveyTree: root item not found");
-		this.renderedSurveyTree = this.renderGroup(this.surveyDef.rootItem);
-	}
-	_registerSurveyEvent(event) {
-		this._events.push(event);
-	}
-	_getTimestamp() {
-		return Math.floor(Date.now() / 1e3);
-	}
-	getResponseItem(itemId) {
-		return this.responses[itemId];
-	}
-	/** 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() {
-		this.activeState = this.activeResponsePlan.evaluate(this.responses, this.context);
-		const evalEngine = this.activeState.evaluator;
-		this.evalTemplateValues(evalEngine);
-		this.evalDisplayConditions();
-		this.evalDisableConditions(evalEngine);
-		this.evalValidations(evalEngine);
-	}
-	evalTemplateValues(evalEngine) {
-		Object.keys(this.cache.templateValues).forEach((templateValueKey) => {
-			const templateValue = this.cache.templateValues[templateValueKey];
-			this.cache.templateValues[templateValueKey].value = void 0;
-			if (!templateValue.templateDef?.expression) {
-				console.warn("evalTemplateValues: template value expression not found: " + templateValueKey);
-				return;
-			}
-			let evaluatedValue = evalEngine.eval(templateValue.templateDef.expression);
-			if (evaluatedValue === void 0) {
-				console.warn("evalTemplateValues: template value expression returned undefined: " + templateValueKey);
-				return;
-			}
-			switch (templateValue.templateDef.type) {
-				case "date2string":
-					if (evaluatedValue.type !== ValueType.date) {
-						console.warn("evalTemplateValues: template value expression returned non-date value: " + templateValueKey);
-						return;
-					}
-					evaluatedValue = {
-						type: ValueType.string,
-						value: formatCalendarDate(evaluatedValue.value, templateValue.templateDef.dateFormat)
-					};
-			}
-			this.cache.templateValues[templateValueKey].value = evaluatedValue;
-		});
-	}
-	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) => {
-			const disableCondition = this.cache.disabledConditions[itemKey];
-			if (disableCondition.components) Object.keys(disableCondition.components).forEach((componentKey) => {
-				const resolvedValue = evalEngine.eval(disableCondition.components[componentKey].expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalDisableConditions: disable condition component expression returned undefined: " + itemKey + "." + componentKey);
-					return;
-				}
-				this.cache.disabledConditions[itemKey].components[componentKey].result = resolvedValue.value;
-			});
-		});
-	}
-	evalValidations(evalEngine) {
-		Object.keys(this.cache.validations).forEach((itemId) => {
-			const validation = this.cache.validations[itemId];
-			Object.keys(validation).forEach((validationKey) => {
-				const resolvedValue = evalEngine.eval(validation[validationKey].expression);
-				if (resolvedValue === void 0 || resolvedValue.type !== ValueType.boolean) {
-					console.warn("evalValidations: validation expression returned undefined: " + itemId + "." + validationKey);
-					this.cache.validations[itemId][validationKey].result = false;
-					return;
-				}
-				this.cache.validations[itemId][validationKey].result = resolvedValue.value;
-			});
-		});
-	}
-};
-const flattenTree = (itemTree) => {
-	const flatTree = new Array();
-	itemTree.items?.forEach((item) => {
-		if (item.type === "group") flatTree.push(...flattenTree(item));
-		else flatTree.push({ ...item });
-	});
-	return flatTree;
-};
-//#endregion
+import { z } from "zod";
 //#region src/json-patch.ts
 var JsonPatchError = class extends Error {
 	code;
@@ -956,15 +188,1551 @@ const applyJsonPatch = (document, operations) => {
 	return patchedDocument;
 };
 //#endregion
-//#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"));
+//#region src/expressions/shortcuts/selection.ts
+/**
+* Build a selected-option test joined with `not(ownerState.disabled)` for that option.
+* `multiple` chooses membership instead of equality. The result is an ordinary expression tree;
+* no shortcut node is persisted or handled specially by the evaluator.
+*/
+function selectedAndEnabled(selection, optionId, multiple) {
+	return {
+		type: "function",
+		functionName: "and",
+		arguments: [{
+			type: "function",
+			functionName: multiple ? "list_contains" : "eq",
+			arguments: [selection, {
+				type: "const",
+				value: {
+					type: "reference",
+					value: optionId
+				}
+			}]
+		}, {
+			type: "function",
+			functionName: "not",
+			arguments: [{
+				type: "ownerState",
+				state: "disabled",
+				targetRef: { ownerId: optionId }
+			}]
+		}]
+	};
 }
 //#endregion
+//#region src/survey/utils/group-utils.ts
+/**
+* Shared utilities for array operations.
+*/
+/**
+* Swap two elements in an array by index.
+* @returns A new array with the elements swapped
+*/
+function swapArrayElements(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	[result[fromIndex], result[toIndex]] = [result[toIndex], result[fromIndex]];
+	return result;
+}
+/**
+* Move an element from one index to another.
+* @returns A new array with the element moved
+*/
+function moveArrayElement(arr, fromIndex, toIndex) {
+	const result = [...arr];
+	const [moved] = result.splice(fromIndex, 1);
+	result.splice(toIndex, 0, moved);
+	return result;
+}
+//#endregion
+//#region src/expressions/editors/expression-editor.ts
+const constantNode = (value, editorConfig) => {
+	const node = expressionSchema.parse({
+		type: "const",
+		value,
+		editorConfig
+	});
+	if (node.type !== "const") throw new Error("Expected constant node");
+	return node;
+};
+/** Editor-state builders produce the canonical JSON tree, never runtime wrappers. */
+const createFunctionExpression = (functionName, args, editorConfig) => ({
+	type: "function",
+	functionName,
+	arguments: expressionArguments(args),
+	editorConfig
+});
+const contextNode = (contextType, key, args, asType, editorConfig) => ({
+	type: "contextVariable",
+	contextType,
+	...key ? { key } : {},
+	...args ? { arguments: expressionArguments(args) } : {},
+	asType,
+	editorConfig
+});
+var ExpressionEditor = class {
+	returnType;
+	_editorConfig;
+	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 constantNode({
+			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 constantNode({
+			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 constantNode({
+			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 constantNode({
+			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 = this._value;
+		return constantNode({
+			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 constantNode({
+			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;
+		return constantNode({
+			type: ValueType.dateArray,
+			value
+		}, this._editorConfig);
+	}
+};
+var ResponseVariableEditor = class extends ExpressionEditor {
+	variableRef;
+	constructor(variableRef, variableType, editorConfig) {
+		super();
+		this.variableRef = variableRef;
+		this._editorConfig = editorConfig;
+		this.returnType = variableRef.method === "isDefined" ? ValueType.boolean : variableType;
+	}
+	getExpression() {
+		return {
+			type: "responseVariable",
+			variableRef: { ...this.variableRef },
+			editorConfig: this._editorConfig
+		};
+	}
+};
+var DisabledStateEditor = class extends ExpressionEditor {
+	ownerId;
+	returnType = ValueType.boolean;
+	constructor(ownerId, editorConfig) {
+		super();
+		this.ownerId = ownerId;
+		this._editorConfig = editorConfig;
+	}
+	getExpression() {
+		return {
+			type: "ownerState",
+			state: "disabled",
+			targetRef: { ownerId: this.ownerId },
+			editorConfig: 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 contextNode(this._contextType, this._key?.getExpression(), this._args?.map((arg) => arg.getExpression()), this._asType, this._editorConfig);
+	}
+};
+var CtxLocaleEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(editorConfig) {
+		super("locale", void 0, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxCurrentDateEditor = class extends ContextVariableEditor {
+	returnType = ValueType.date;
+	constructor(editorConfig) {
+		super("currentDate", void 0, void 0, ValueType.date, editorConfig);
+	}
+};
+var CtxPFlagIsDefinedEditor = class extends ContextVariableEditor {
+	returnType = ValueType.boolean;
+	constructor(key, editorConfig) {
+		super("participantFlag", key, void 0, ValueType.boolean, editorConfig);
+	}
+};
+var CtxPFlagStringEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(key, editorConfig) {
+		super("participantFlag", key, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxPFlagNumEditor = class extends ContextVariableEditor {
+	returnType = ValueType.number;
+	constructor(key, editorConfig) {
+		super("participantFlag", key, void 0, ValueType.number, editorConfig);
+	}
+};
+var CtxPFlagDateEditor = class extends ContextVariableEditor {
+	returnType = ValueType.date;
+	constructor(key, editorConfig) {
+		super("participantFlag", key, void 0, ValueType.date, editorConfig);
+	}
+};
+var CtxCustomValueEditor = class extends ContextVariableEditor {
+	constructor(key, asType, editorConfig) {
+		super("customValue", key, void 0, 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) {
+		this._args = moveArrayElement(this._args, activeIndex, overIndex);
+	}
+};
+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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("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 createFunctionExpression("max", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+//#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_current_date = () => {
+	return new CtxCurrentDateEditor();
+};
+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 and = (...args) => {
+	return new AndExpressionEditor(args);
+};
+const or = (...args) => {
+	return new OrExpressionEditor(args);
+};
+const str_list_contains = (list, item) => {
+	return new StrListContainsExpressionEditor(list, item);
+};
+/** Number of list entries, or of entries that also appear in `filter` (e.g. listed options). */
+const list_count = (list, filter) => new FunctionCallEditor("list_count", filter ? [list, filter] : [list], ValueType.number);
+/** `then` when the condition is true, otherwise `otherwise` (missing when omitted). */
+const if_else = (condition, then, otherwise) => new FunctionCallEditor("if", otherwise ? [
+	condition,
+	then,
+	otherwise
+] : [condition, then], then.returnType ?? otherwise?.returnType);
+const str_eq = (a, b) => {
+	return new StrEqExpressionEditor(a, b);
+};
+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);
+};
+var FunctionCallEditor = class extends ExpressionEditor {
+	name;
+	args;
+	returnType;
+	constructor(name, args, returnType) {
+		super();
+		this.name = name;
+		this.args = args;
+		this.returnType = returnType;
+	}
+	getExpression() {
+		return createFunctionExpression(this.name, this.args.map((arg) => arg.getExpression()), this.editorConfig);
+	}
+};
+const date_eq = (a, b) => new FunctionCallEditor("date_eq", [a, b], ValueType.boolean);
+const date_gt = (a, b) => new FunctionCallEditor("date_gt", [a, b], ValueType.boolean);
+const date_gte = (a, b) => new FunctionCallEditor("date_gte", [a, b], ValueType.boolean);
+const date_lt = (a, b) => new FunctionCallEditor("date_lt", [a, b], ValueType.boolean);
+const date_lte = (a, b) => new FunctionCallEditor("date_lte", [a, b], ValueType.boolean);
+const date_add_days = (a, b) => new FunctionCallEditor("date_add_days", [a, b], ValueType.date);
+const date_add_months = (a, b) => new FunctionCallEditor("date_add_months", [a, b], ValueType.date);
+const date_add_years = (a, b) => new FunctionCallEditor("date_add_years", [a, b], ValueType.date);
+/** Signed completed units in a - b, e.g. age as `date_diff(ctx_current_date(), birth, "years")`. */
+const date_diff = (a, b, unit) => new FunctionCallEditor("date_diff", [
+	a,
+	b,
+	const_string(unit)
+], ValueType.number);
+const date_min = (...args) => new FunctionCallEditor("date_min", args, ValueType.date);
+const date_max = (...args) => new FunctionCallEditor("date_max", args, ValueType.date);
+const is_disabled = (ownerId) => new DisabledStateEditor(ownerId);
+//#endregion
+//#region src/survey/composition/registry.ts
+function defineElement(definition) {
+	const schema = contentOwner(z.strictObject({
+		...elementShape,
+		elementType: z.literal(definition.elementType),
+		config: definition.config.nonoptional()
+	}), definition.roles ?? []);
+	return {
+		elementType: definition.elementType,
+		labelByLocale: definition.labelByLocale,
+		schema,
+		inspect(input) {
+			const node = schema.parse(input);
+			return {
+				slots: [],
+				bindings: [],
+				followUps: [],
+				fullWidth: false,
+				minWidthRem: 12,
+				componentParents: {},
+				...definition.facts?.(node.config, node.id)
+			};
+		},
+		compute(input, slotId, read) {
+			return definition.compute?.(schema.parse(input).config, slotId, read);
+		},
+		validate(input, read, evaluate) {
+			const node = schema.parse(input);
+			return definition.validate?.(node.config, node.id, read, evaluate) ?? [];
+		}
+	};
+}
+/** A registry is finalized once. Its one recursive schema is shared by built-in and custom bodies. */
+function createElementRegistry(create) {
+	const definitions = create(z.lazy(() => composition));
+	const byType = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		if (byType.has(definition.elementType)) throw new Error(`Duplicate element registration: ${definition.elementType}`);
+		byType.set(definition.elementType, definition);
+	}
+	const variants = definitions.map((definition) => definition.schema);
+	const element = variants.length ? z.union(variants) : z.never();
+	const composition = createCompositionSchema(element);
+	return {
+		definitions,
+		labels: new Map(definitions.map((definition) => [definition.elementType, definition.labelByLocale ?? {}])),
+		elementSchema: element,
+		bodySchema: composition,
+		surveySchema: createSurveySchema(composition),
+		get(elementType) {
+			const definition = byType.get(elementType);
+			if (!definition) throw new Error(`Unknown element type: ${elementType}`);
+			return definition;
+		}
+	};
+}
+//#endregion
+//#region src/survey/composition/semantics.ts
+/** Structural context is independent of an element's explicit accessible label. */
+function getElementSemanticContext(survey, elementId) {
+	const owner = survey.owners.get(elementId);
+	if (!owner) throw new Error(`Unknown element '${elementId}'`);
+	let ancestor = owner.parentId ? survey.owners.get(owner.parentId) : void 0;
+	while (ancestor && ancestor.followUpTriggerId === owner.followUpTriggerId) {
+		if (ancestor.kind === "section" || ancestor.kind === "item") return ancestor;
+		ancestor = ancestor.parentId ? survey.owners.get(ancestor.parentId) : void 0;
+	}
+}
+function resolveElementName(survey, elementId, locales) {
+	const owner = survey.owners.get(elementId);
+	if (!owner) throw new Error(`Unknown element '${elementId}'`);
+	const name = (ownerId, role) => {
+		if (!survey.owners.get(ownerId)?.roles.some((entry) => entry.role === role)) return void 0;
+		const resolved = resolveParticipantContent(survey, ownerId, role, locales);
+		const text = getContentPlainText(resolved?.content).trim();
+		return text && resolved ? {
+			ownerId,
+			role,
+			text,
+			content: resolved.content,
+			locale: resolved.locale
+		} : void 0;
+	};
+	const own = name(elementId, "label");
+	if (own) return own;
+	let ancestor = owner.parentId ? survey.owners.get(owner.parentId) : void 0;
+	while (ancestor) {
+		const current = ancestor;
+		if ([...survey.elements.values()].filter((element) => {
+			const candidate = survey.owners.get(element.node.id);
+			return element.facts.bindings.length > 0 && candidate.followUpTriggerId === owner.followUpTriggerId && current.path.every((part, index) => candidate.path[index] === part);
+		}).length === 1) {
+			const inherited = name(ancestor.id, "title") ?? name(ancestor.id, "label");
+			if (inherited) return inherited;
+		}
+		if (ancestor.kind === "section" || ancestor.id === owner.followUpTriggerId) return void 0;
+		ancestor = ancestor.parentId ? survey.owners.get(ancestor.parentId) : void 0;
+	}
+}
+//#endregion
+//#region src/engine/validation.ts
+function validateSurveyAnswers(plan, answers, context, options) {
+	const snapshot = plan.evaluate({
+		answers,
+		context
+	});
+	const evaluationDiagnostics = [];
+	const eligible = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		return !!binding && hasPermittedChange(binding, snapshot);
+	};
+	const evaluate = (expression, path) => {
+		try {
+			return evaluateExpression(expression, {
+				...context,
+				answer: snapshot.answer,
+				disabled: snapshot.disabled
+			});
+		} catch (error) {
+			if (!(error instanceof ExpressionEvaluationError)) throw error;
+			evaluationDiagnostics.push({
+				code: "validation-evaluation",
+				severity: "warning",
+				path,
+				message: error.message
+			});
+			return;
+		}
+	};
+	const issues = [];
+	const authorWarnings = [];
+	const active = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		return !!binding && [binding.controlId, ...binding.visibilityIds ?? []].every(snapshot.visible);
+	};
+	const included = (itemId) => !options.itemIds || options.itemIds.includes(itemId);
+	for (const element of plan.document.elements.values()) {
+		if (!included(element.itemId)) continue;
+		for (const binding of element.facts.bindings) {
+			if (!binding.selection || !active(binding.slotId) || [binding.controlId, ...binding.visibilityIds ?? []].some(snapshot.disabled)) continue;
+			if (!hasPermittedChange(binding, snapshot)) authorWarnings.push({
+				ownerId: binding.controlId,
+				code: "non-interactive-choice",
+				message: "Option locks, visibility, or the selection limit leave this choice with no permitted participant change. Its constraints will not block progress; its active answer is still submitted."
+			});
+			if (binding.selection.multiple) {
+				const answer = snapshot.answer(binding.slotId);
+				if (answer?.type === "reference[]") for (const optionId of answer.value.filter(snapshot.disabled)) authorWarnings.push({
+					ownerId: optionId,
+					code: "locked-checkbox-selection",
+					message: "This selected checkbox is now locked and cannot be unticked. It remains an active, submitted answer. Use visibility if the answer should stop applying."
+				});
+			}
+		}
+		for (const issue of plan.document.registry.get(element.node.elementType).validate(element.node, snapshot.answer, (expression) => evaluate(expression, element.path))) if (eligible(issue.slotId)) issues.push(issue);
+		else if (active(issue.slotId)) authorWarnings.push({
+			ownerId: issue.messageOwnerId ?? plan.bindings.get(issue.slotId).controlId,
+			code: "locked-input-constraint",
+			message: `The ${issue.code} constraint is not satisfied, but this input currently permits no participant change. It will not block progress; its active answer is still submitted.`
+		});
+	}
+	for (const item of plan.document.data.surveyItems) {
+		if (item.itemType !== "content" || !included(item.id)) continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (rule.phase === "submit" && options.phase !== "submit") continue;
+			const targets = rule.targets.filter(eligible);
+			if (!rule.targets.filter(active).length) continue;
+			if (rule.when) {
+				const result = evaluate(rule.when, [...plan.document.owners.get(rule.id).path, "when"]);
+				if (result?.type !== "boolean" || !result.value) continue;
+			}
+			const result = evaluate(rule.expression, [...plan.document.owners.get(rule.id).path, "expression"]);
+			if (result?.type !== "boolean" || !result.value) {
+				issues.push(...targets.map((slotId) => ({
+					slotId,
+					code: "rule",
+					messageOwnerId: rule.id
+				})));
+				if (!targets.length) authorWarnings.push({
+					ownerId: rule.id,
+					code: "locked-rule-targets",
+					message: "This applicable rule fails, but none of its active targets permits a participant change. It will not block progress. Check the rule and disabling conditions."
+				});
+			}
+		}
+	}
+	return {
+		issues,
+		diagnostics: [...snapshot.diagnostics, ...evaluationDiagnostics],
+		authorWarnings
+	};
+}
+const authoringDependencyPlans = /* @__PURE__ */ new WeakMap();
+const staticWarnings = /* @__PURE__ */ new WeakMap();
+/** Conservative proofs only: dynamic conditions and prefills are checked in a real preview. */
+function staticConstraintWarnings(survey, plan) {
+	const literal = (expression, value) => expression?.type === "const" && expression.value?.type === "boolean" && expression.value.value === value;
+	const parents = (id) => {
+		const owner = survey.owners.get(id);
+		return [...owner.parentId ? [owner.parentId] : [], ...owner.elementId ? ownValue(survey.elements.get(owner.elementId)?.facts.componentParents, id) ?? [] : []];
+	};
+	const visible = (id) => {
+		const owner = survey.owners.get(id);
+		return !owner.followUpTriggerId && (!owner.visibility || literal(owner.visibility, true)) && parents(id).every(visible);
+	};
+	const hidden = (id) => literal(survey.owners.get(id).visibility, false) || parents(id).some(hidden);
+	const disabled = (id) => literal(survey.owners.get(id).disabled, true) || parents(id).some(disabled);
+	const locked = (slotId) => {
+		const binding = plan.bindings.get(slotId);
+		if (!binding) return false;
+		const controls = [binding.controlId, ...binding.visibilityIds ?? []];
+		return controls.every(visible) && (controls.some(disabled) || !!binding.selection?.options.every((id) => hidden(id) || disabled(id)));
+	};
+	const warnings = [];
+	for (const element of survey.elements.values()) {
+		if (!element.facts.bindings.some((binding) => locked(binding.slotId))) continue;
+		for (const issue of survey.registry.get(element.node.elementType).validate(element.node, () => void 0, () => void 0)) if ((issue.code === "required" || issue.code === "mustBeTrue") && locked(issue.slotId) && !ownValue(element.node.prefills, issue.slotId)?.length) warnings.push({
+			ownerId: issue.messageOwnerId ?? plan.bindings.get(issue.slotId).controlId,
+			code: "locked-input-constraint",
+			message: `The ${issue.code} constraint starts unsatisfied on an input with no permitted participant change and no prefill. It will not block progress. Check the requirement and disabling conditions.`
+		});
+	}
+	for (const item of survey.data.surveyItems) {
+		if (item.itemType !== "content") continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (!literal(rule.expression, false) || rule.when && !literal(rule.when, true)) continue;
+			if (rule.targets.length && rule.targets.every(locked)) warnings.push({
+				ownerId: rule.id,
+				code: "locked-rule-targets",
+				message: "This rule always fails, but all its targets are locked. It will not block progress. Check the rule and disabling conditions."
+			});
+		}
+	}
+	return warnings;
+}
+function getAuthoringWarnings(survey, locale) {
+	const warnings = [];
+	const itemsWithElements = new Set([...survey.elements.values()].map((element) => element.itemId));
+	for (const item of survey.data.surveyItems) if (item.itemType === "content" && !itemsWithElements.has(item.id)) warnings.push({
+		ownerId: item.id,
+		code: "empty-content-item",
+		message: "Add an element to this empty item, or remove the item."
+	});
+	for (const owner of survey.owners.values()) for (const role of owner.roles.filter((role) => role.recommended)) if (!hasLocalizationText(readLocalizationContent(survey, {
+		scope: "content",
+		ownerId: owner.id,
+		role: role.role
+	}, locale))) warnings.push({
+		ownerId: owner.id,
+		code: "missing-content",
+		message: `Add ${role.role} to make this structure understandable`
+	});
+	let plan = authoringDependencyPlans.get(survey.elements);
+	if (!plan) {
+		plan = new SurveyStateGraph(survey, { admission: "draft" });
+		authoringDependencyPlans.set(survey.elements, plan);
+	}
+	let conflicts = staticWarnings.get(survey.elements);
+	if (!conflicts) {
+		conflicts = staticConstraintWarnings(survey, plan);
+		staticWarnings.set(survey.elements, conflicts);
+	}
+	warnings.push(...conflicts);
+	for (const item of survey.data.surveyItems) {
+		if (item.itemType !== "content") continue;
+		for (const rule of item.config.validationRules ?? []) {
+			if (rule.phase === "submit") continue;
+			if ([rule.expression, ...rule.when ? [rule.when] : []].flatMap((expression) => [...plan.storedDependencies(expression)]).some((id) => {
+				const dependencyItem = survey.slots.get(id)?.itemId;
+				return dependencyItem && dependencyItem !== item.id && !isStaticallyBefore(survey, dependencyItem, item.id);
+			})) warnings.push({
+				ownerId: rule.id,
+				code: "cross-item-page-rule",
+				message: "This rule runs before leaving the page and reads answers from another item. If those answers are on a later page, the participant may be unable to continue. Consider submit-only validation or an explicit condition for unanswered dependencies."
+			});
+		}
+	}
+	for (const element of survey.elements.values()) for (const binding of element.facts.bindings) if (binding.labelRefs) {
+		for (const ref of binding.labelRefs) if (!hasLocalizationText(readLocalizationContent(survey, {
+			scope: "content",
+			...ref
+		}, locale)) && !warnings.some((warning) => warning.ownerId === ref.ownerId && warning.code === "missing-content")) warnings.push({
+			ownerId: ref.ownerId,
+			code: "missing-accessible-name",
+			message: `Add ${ref.role} to name this input in the selected language`
+		});
+	} else if (!resolveElementName(survey, element.node.id, [locale]) && !warnings.some((warning) => warning.ownerId === element.node.id && warning.code === "missing-accessible-name")) warnings.push({
+		ownerId: element.node.id,
+		code: "missing-accessible-name",
+		message: "Add a label, or an unambiguous enclosing title, in the selected language"
+	});
+	for (const element of survey.elements.values()) for (const binding of element.facts.bindings) {
+		if (!binding.selection?.multiple) continue;
+		for (const id of binding.selection.options) {
+			const condition = survey.owners.get(id)?.disabled;
+			if (condition && [...plan.storedDependencies(condition)].some((slotId) => slotId !== binding.slotId)) warnings.push({
+				ownerId: id,
+				code: "external-checkbox-lock",
+				message: "This condition depends on another answer. An already selected checkbox can become locked and will still be submitted. Use visibility if the selection should stop applying."
+			});
+		}
+	}
+	return warnings;
+}
+/** A shared shuffled ancestor only changes order between its distinct children. */
+function isStaticallyBefore(survey, earlierId, laterId) {
+	const earlier = [...survey.getItemPath(earlierId), earlierId];
+	const later = [...survey.getItemPath(laterId), laterId];
+	const branch = earlier.findIndex((id, index) => id !== later[index]);
+	if (branch < 1) return false;
+	const parent = survey.getItem(earlier[branch - 1]);
+	return parent?.itemType === "group" && !parent.config.shuffleItems && parent.config.items.indexOf(earlier[branch]) < parent.config.items.indexOf(later[branch]);
+}
+//#endregion
+//#region src/survey/composition/diagnostics.ts
+/** Observed author-only conflicts use the same validation result as the player and host. */
+function getSessionDiagnostics(session) {
+	const result = session.validate("submit");
+	return [...result.authorWarnings.map((warning) => {
+		const owner = session.document.owners.get(warning.ownerId);
+		return {
+			...warning,
+			severity: "warning",
+			path: owner?.path ?? [],
+			ownerItemId: owner?.itemId
+		};
+	}), ...result.diagnostics.map((diagnostic) => {
+		const owner = ownerAtPath(session.document, diagnostic.path);
+		return {
+			...diagnostic,
+			ownerId: owner?.id,
+			ownerItemId: owner?.itemId
+		};
+	})];
+}
+function ownerAtPath(survey, path) {
+	return [...survey.owners.values()].filter((owner) => owner.path.length <= path.length && owner.path.every((part, index) => part === path[index])).sort((a, b) => b.path.length - a.path.length)[0];
+}
+/**
+* Every dangling reference an editor draft admits: missing answers, state targets, options,
+* owners and non-flow items from the document index, plus comparisons with removed option
+* identities reported by the compiled graph. Always empty for a runnable survey.
+*/
+function getBrokenReferences(survey) {
+	return getDefinitionDiagnostics(survey).filter((diagnostic) => diagnostic.severity === "error" && diagnostic.kind === "reference");
+}
+const compiledDiagnostics = /* @__PURE__ */ new WeakMap();
+/** Use the authoritative definition/compiler diagnostics, including state reads and custom definitions. */
+function getDefinitionDiagnostics(survey, locale) {
+	let compiled = compiledDiagnostics.get(survey.elements);
+	if (!compiled) {
+		try {
+			compiled = new SurveyStateGraph(survey, { admission: "draft" }).admittedDiagnostics;
+		} catch (error) {
+			if (error instanceof DefinitionError) compiled = error.diagnostics;
+			else throw error;
+		}
+		compiledDiagnostics.set(survey.elements, compiled);
+	}
+	const located = [...survey.diagnostics, ...compiled].map((diagnostic) => {
+		const owner = ownerAtPath(survey, diagnostic.path) ?? (diagnostic.path[0] === "translations" && diagnostic.path[2] === "content" ? survey.owners.get(String(diagnostic.path[3])) : void 0);
+		return {
+			...diagnostic,
+			ownerItemId: owner?.itemId,
+			ownerId: owner?.id
+		};
+	});
+	if (locale) try {
+		for (const warning of getAuthoringWarnings(survey, locale)) {
+			const owner = survey.owners.get(warning.ownerId);
+			located.push({
+				...warning,
+				severity: "warning",
+				path: owner?.path ?? [],
+				ownerItemId: owner?.itemId
+			});
+		}
+	} catch (error) {
+		if (!(error instanceof DefinitionError)) throw error;
+	}
+	return [...new Map(located.map((issue) => [JSON.stringify([
+		issue.code,
+		issue.path,
+		issue.message
+	]), issue])).values()];
+}
+//#endregion
+//#region src/engine/session.ts
+const sessionSnapshotSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	binding: z.strictObject({
+		sessionId: z.string().min(1),
+		definitionId: z.string().min(1)
+	}),
+	answers: stringRecord(z.string().min(1), responseValueSchema),
+	initialization: z.literal("complete"),
+	navigation: z.strictObject({
+		pageIndex: z.number().int().nonnegative(),
+		viewport: z.enum(["small", "large"])
+	}),
+	randomization: z.strictObject({ seed: z.string().min(1) }),
+	context: z.strictObject({
+		locale: z.string().min(1),
+		/** Defaults to the participant-local day when a new session starts; kept on resume. */
+		currentDate: calendarDaySchema.optional(),
+		participantFlags: stringRecord(z.string(), z.string()).optional(),
+		customValues: stringRecord(z.string(), responseValueSchema).optional()
+	}),
+	events: z.array(surveyEventSchema)
+});
+const eventTimestamp = () => Math.floor(Date.now() / 1e3);
+const comparableAnswer = (value) => JSON.stringify(value, Object.keys(value).sort());
+function freezeAnswer(value) {
+	if (Array.isArray(value.value)) Object.freeze(value.value);
+	return Object.freeze(value);
+}
+function sameRecord(left, right, equal) {
+	const entries = Object.entries(left ?? {});
+	return entries.length === Object.keys(right ?? {}).length && entries.every(([key, value]) => {
+		const other = ownValue(right, key);
+		return other !== void 0 && equal(value, other);
+	});
+}
+/** Owns retained answers; participant adapters receive no privileged initialization write path. */
+var SurveySession = class SurveySession {
+	currentDocument;
+	state;
+	stateGraph;
+	revision = 0;
+	presentationRevision = 0;
+	itemPresentationRevisions = /* @__PURE__ */ new Map();
+	initializationDiagnostics = [];
+	listeners = /* @__PURE__ */ new Set();
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	getRevision = () => this.revision;
+	/** State/context changes notify every item; wording changes only notify their owning item. */
+	getItemRevision = (itemId) => this.revision - this.presentationRevision + (this.itemPresentationRevisions.get(itemId) ?? 0);
+	/** Prefer the current page, then the next surviving item, then the previous one. */
+	pageAnchors(writtenItems = /* @__PURE__ */ new Set()) {
+		const pages = this.pages();
+		return [
+			...(pages[this.pageIndex] ?? []).filter((id) => writtenItems.has(id)),
+			...pages.slice(this.pageIndex).flat(),
+			...pages.slice(0, this.pageIndex).flat().reverse()
+		];
+	}
+	reconcilePageAndNotify(anchors) {
+		const pages = this.pages();
+		const pageByItem = new Map(pages.flatMap((items, index) => items.map((id) => [id, index])));
+		const anchoredPage = anchors?.map((id) => pageByItem.get(id)).find((index) => index !== void 0);
+		this.state.navigation.pageIndex = anchoredPage ?? Math.min(this.pageIndex, Math.max(0, pages.length - 1));
+		this.revision++;
+		this.listeners.forEach((listener) => listener());
+	}
+	constructor(currentDocument, state, admission = "strict") {
+		this.currentDocument = currentDocument;
+		this.state = state;
+		this.stateGraph = new SurveyStateGraph(currentDocument, { admission });
+		this.validateAnswers(state.answers);
+		for (const value of Object.values(state.answers)) freezeAnswer(value);
+		for (const value of Object.values(state.context.customValues ?? {})) freezeAnswer(value);
+	}
+	get document() {
+		return this.currentDocument;
+	}
+	/** Wording-only authoring revisions share the compiler indexes and cannot change execution.
+	* Keep the compiled graph, answers, navigation and initialization when updating a live preview.
+	* A structural/configuration revision must create a new session instead.
+	*/
+	updatePresentation(document) {
+		if (document === this.currentDocument) return;
+		if (document.elements !== this.currentDocument.elements) throw new Error("Only wording revisions can update a session presentation");
+		const affected = /* @__PURE__ */ new Set();
+		let sharedContentChanged = false;
+		for (const locale of /* @__PURE__ */ new Set([...document.locales, ...this.currentDocument.locales])) {
+			const before = this.currentDocument.data.translations?.[locale];
+			const after = document.data.translations?.[locale];
+			if (before === after) continue;
+			sharedContentChanged ||= before?.navigationContent !== after?.navigationContent || before?.validationMessages !== after?.validationMessages;
+			for (const owner of document.owners.values()) if (before?.content[owner.id] !== after?.content[owner.id]) affected.add(owner.itemId);
+		}
+		if (!sharedContentChanged) {
+			this.presentationRevision++;
+			for (const id of affected) this.itemPresentationRevisions.set(id, (this.itemPresentationRevisions.get(id) ?? 0) + 1);
+		}
+		this.currentDocument = document;
+		this.reconcilePageAndNotify();
+	}
+	static async create(document, input, sources = {}) {
+		if (input.mode === "resumed") {
+			const snapshot = sessionSnapshotSchema.parse(input.snapshot);
+			if (snapshot.binding.sessionId !== input.binding.sessionId || snapshot.binding.definitionId !== input.binding.definitionId) throw new Error("Resume snapshot does not match the session and exact survey definition");
+			const session = new SurveySession(document, snapshot);
+			if (session.pageIndex >= Math.max(1, session.pages().length)) throw new Error("Resume page index is outside the survey");
+			return session;
+		}
+		const session = new SurveySession(document, sessionSnapshotSchema.parse({
+			schemaVersion: 1,
+			binding: input.binding,
+			answers: input.answers ?? {},
+			initialization: "complete",
+			navigation: {
+				pageIndex: 0,
+				viewport: "large"
+			},
+			randomization: { seed: input.seed ?? crypto.randomUUID() },
+			context: {
+				...input.context,
+				currentDate: input.context.currentDate ?? calendarDateFromLocalDate(/* @__PURE__ */ new Date())
+			},
+			events: [{
+				type: "openSurvey",
+				timestamp: eventTimestamp(),
+				value: input.context.locale
+			}]
+		}), input.admission);
+		await session.initialize(sources);
+		return session;
+	}
+	snapshot() {
+		return structuredClone(this.state);
+	}
+	itemMetadata() {
+		return Object.fromEntries(this.pages().flat().map((itemId, position) => [itemId, { position }]));
+	}
+	active() {
+		return this.stateGraph.evaluate({
+			answers: this.state.answers,
+			context: this.state.context
+		});
+	}
+	get locale() {
+		return this.state.context.locale;
+	}
+	get pageIndex() {
+		return this.state.navigation.pageIndex;
+	}
+	setLocale(locale) {
+		this.setContext({
+			...this.state.context,
+			locale
+		});
+	}
+	/** Replace host context without restarting initialization or losing retained answers. */
+	setContext(context) {
+		const parsed = sessionSnapshotSchema.shape.context.parse(context);
+		const previous = this.state.context;
+		const next = {
+			...parsed,
+			currentDate: parsed.currentDate ?? previous.currentDate
+		};
+		if (!next.locale.trim()) throw new Error("A locale is required");
+		const localeChanged = next.locale !== previous.locale;
+		if (!localeChanged && next.currentDate === previous.currentDate && sameRecord(previous.participantFlags, next.participantFlags, (a, b) => a === b) && sameRecord(previous.customValues, next.customValues, (a, b) => JSON.stringify(a) === JSON.stringify(b))) return;
+		for (const value of Object.values(next.customValues ?? {})) freezeAnswer(value);
+		const anchors = this.pageAnchors();
+		this.state = {
+			...this.state,
+			context: next,
+			events: localeChanged ? [...this.state.events, {
+				type: "languageChanged",
+				timestamp: eventTimestamp(),
+				value: next.locale
+			}] : this.state.events
+		};
+		this.reconcilePageAndNotify(anchors);
+	}
+	orderedIds(ids, ownerId) {
+		return shuffleArray(ids, createSeededRandom(`${this.state.randomization.seed}:${ownerId}`));
+	}
+	setViewport(viewport) {
+		if (viewport === this.state.navigation.viewport) return;
+		const anchors = this.pageAnchors();
+		this.state.navigation.viewport = viewport;
+		this.reconcilePageAndNotify(anchors);
+	}
+	pages(viewport = this.state.navigation.viewport) {
+		const active = this.active(), byId = new Map(this.document.data.surveyItems.map((item) => [item.id, item]));
+		const pages = [[]];
+		const limit = this.document.data.maxItemsPerPage?.[viewport] ?? Infinity;
+		const next = () => {
+			if (pages.at(-1).length) pages.push([]);
+		};
+		const visit = (id) => {
+			const item = byId.get(id);
+			if (!item || !active.visible(id)) return;
+			if (item.itemType === "group") (item.config.shuffleItems ? this.orderedIds(item.config.items, item.id) : item.config.items).forEach(visit);
+			else if (item.itemType === "page-break") next();
+			else {
+				if (pages.at(-1).length >= limit) next();
+				pages.at(-1).push(id);
+			}
+		};
+		visit(this.document.rootId);
+		return pages.filter((page) => page.length);
+	}
+	validate(phase, itemIds) {
+		const result = validateSurveyAnswers(this.stateGraph, this.state.answers, this.state.context, {
+			phase,
+			itemIds
+		});
+		return {
+			...result,
+			diagnostics: [...this.initializationDiagnostics, ...result.diagnostics]
+		};
+	}
+	goToPage(index, viewport = this.state.navigation.viewport) {
+		const pages = this.pages(viewport);
+		if (!Number.isInteger(index) || index < 0 || index >= pages.length) throw new Error("Invalid page index");
+		if (index > this.pageIndex) {
+			if (this.validate("page", pages[this.pageIndex]).issues.length) throw new Error("Current page has blocking validation errors");
+		}
+		this.state = {
+			...this.state,
+			navigation: {
+				pageIndex: index,
+				viewport
+			},
+			events: [...this.state.events, {
+				type: "pageChanged",
+				timestamp: eventTimestamp(),
+				value: index
+			}]
+		};
+		this.reconcilePageAndNotify();
+	}
+	submission(responseId) {
+		if (this.validate("submit").issues.length) throw new Error("Survey has blocking validation errors");
+		return structuredClone({
+			schemaVersion: 2,
+			responseId,
+			definitionId: this.state.binding.definitionId,
+			answers: this.active().activeAnswers(),
+			events: this.state.events,
+			itemMetadata: this.itemMetadata(),
+			customValues: this.state.context.customValues,
+			evaluationContext: {
+				locale: this.state.context.locale,
+				currentDate: this.state.context.currentDate,
+				participantFlags: this.state.context.participantFlags
+			},
+			randomization: this.state.randomization
+		});
+	}
+	validateAnswers(answers) {
+		for (const [slotId, value] of Object.entries(answers)) {
+			const slot = this.document.slots.get(slotId);
+			if (!slot || slot.computed) throw new Error(`Unknown or computed answer target '${slotId}'`);
+			const errors = validateResponseSlotValue(slot, value);
+			if (errors.length) throw new Error(errors.join("; "));
+			if (value.type === "reference[]" && new Set(value.value).size !== value.value.length) throw new Error(`Duplicate selected options in '${slotId}'`);
+		}
+	}
+	write(writes) {
+		if (new Set(writes.map((write) => write.slotId)).size !== writes.length) throw new Error("One action cannot write a slot twice");
+		const before = this.active();
+		const changed = writes.filter(({ slotId, value }) => {
+			const previous = ownValue(this.state.answers, slotId);
+			return previous === void 0 || value === void 0 ? previous !== value : comparableAnswer(previous) !== comparableAnswer(value);
+		});
+		for (const { slotId, value } of writes) {
+			const slot = this.document.slots.get(slotId);
+			const binding = this.stateGraph.bindings.get(slotId);
+			if (!slot || slot.computed || !binding) throw new Error(`Slot '${slotId}' is not a writable input`);
+			if (value !== void 0) this.validateAnswers({ [slotId]: value });
+		}
+		for (const { slotId, value } of changed) {
+			const binding = this.stateGraph.bindings.get(slotId);
+			if (!canWriteSelection(binding, ownValue(this.state.answers, slotId), value, before)) throw new Error(`Participant write to '${slotId}' is not permitted in the current state`);
+		}
+		if (!changed.length) return;
+		const anchors = this.pageAnchors(new Set(changed.map(({ slotId }) => this.document.slots.get(slotId).itemId)));
+		const answers = { ...this.state.answers };
+		const timestamp = eventTimestamp();
+		for (const { slotId, value } of changed) if (value === void 0) delete answers[slotId];
+		else setOwnValue(answers, slotId, freezeAnswer(structuredClone(value)));
+		const events = [...this.state.events];
+		for (const { slotId, value } of changed) {
+			const event = {
+				type: "responseChanged",
+				slotId,
+				operation: value === void 0 ? "clear" : "set",
+				timestamp
+			};
+			const previous = events.at(-1);
+			if (previous?.type === event.type && previous.slotId === slotId && previous.operation === event.operation) events[events.length - 1] = event;
+			else events.push(event);
+		}
+		this.state = {
+			...this.state,
+			answers,
+			events
+		};
+		this.reconcilePageAndNotify(anchors);
+	}
+	evaluate(expression) {
+		const active = this.active();
+		return evaluateExpression(expression, {
+			...this.state.context,
+			answer: active.answer,
+			disabled: active.disabled
+		});
+	}
+	async initialize(sources) {
+		const prefills = new Map([...this.document.elements.values()].flatMap((element) => Object.entries(element.node.prefills ?? {})));
+		for (const slotId of this.stateGraph.initializationOrder) {
+			if (Object.hasOwn(this.state.answers, slotId)) continue;
+			for (const [index, candidate] of (prefills.get(slotId) ?? []).entries()) {
+				const path = [
+					...this.document.elements.get(this.document.slots.get(slotId).elementId).path,
+					"prefills",
+					slotId,
+					index
+				];
+				const warn = (message) => this.initializationDiagnostics.push({
+					code: "prefill-value",
+					severity: "warning",
+					path,
+					message
+				});
+				const evaluate = (expression) => {
+					try {
+						return this.evaluate(expression);
+					} catch (error) {
+						if (!(error instanceof ExpressionEvaluationError)) throw error;
+						warn(`Prefill '${candidate.id}' was skipped: ${error.message}`);
+						return;
+					}
+				};
+				if (candidate.when) {
+					const result = evaluate(candidate.when);
+					if (result?.type !== "boolean" || !result.value) continue;
+				}
+				let value;
+				switch (candidate.source.type) {
+					case "static":
+						value = candidate.source.value;
+						break;
+					case "expression":
+						value = evaluate(candidate.source.expression);
+						break;
+					case "templateValue": {
+						const template = ownValue(this.document.data.templateValues, candidate.source.key);
+						if (template?.expression) {
+							value = evaluate(template.expression);
+							if (template.type === "formatDate" && value?.type === "date") value = {
+								type: "string",
+								value: formatCalendarDate(value.value, template.dateFormat)
+							};
+						}
+						break;
+					}
+					case "previousResponse":
+						if (!sources.previousResponse && candidate.source.ifUnsupported !== "skip") throw new Error("This host does not supply previous responses for prefills");
+						value = await sources.previousResponse?.(candidate.source.ref);
+				}
+				if (value === void 0) continue;
+				if (candidate.source.type === "previousResponse") {
+					const parsed = responseValueSchema.safeParse(value);
+					const slot = this.document.slots.get(slotId);
+					if (parsed.success && parsed.data.type === "reference[]" && slot.valueType === "reference[]" && slot.allowedValues) {
+						const allowed = new Set(slot.allowedValues.flatMap(responseValueElements).flatMap((option) => option.type === "reference" ? [option.value] : []));
+						const retained = parsed.data.value.filter((id) => allowed.has(id));
+						if (retained.length !== parsed.data.value.length) {
+							warn(`Prefill '${candidate.id}' discarded options outside the current response domain`);
+							if (!retained.length) continue;
+							value = {
+								type: "reference[]",
+								value: retained
+							};
+						}
+					}
+				}
+				const issues = this.document.slots.validateAnswers({ [slotId]: value });
+				if (issues.length) {
+					warn(`Prefill '${candidate.id}' was skipped: ${issues.map((issue) => issue.message).join("; ")}`);
+					continue;
+				}
+				setOwnValue(this.state.answers, slotId, freezeAnswer(structuredClone(value)));
+				break;
+			}
+		}
+	}
+};
+//#endregion
 //#region src/response-exporter/csv-serializer.ts
 const DEFAULT_OPTIONS = {
 	separator: ",",
@@ -999,6 +1767,13 @@ function serializeToCsv(columns, rows, options) {
 	return lines.join(opts.lineEnding);
 }
 //#endregion
+//#region src/response-exporter/validate-configuration.ts
+/** Export requires an executable definition, including complete expression operands. */
+function validateExportConfiguration(survey, registry = survey.slots) {
+	registry.assertValid();
+	new SurveyStateGraph(survey);
+}
+//#endregion
 //#region src/response-exporter/exporter.ts
 const canonical = (value) => JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b))) : entry);
 /** Export only against schemas selected by the host, never against response version tags. */
@@ -1038,18 +1813,18 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 	}
 	compileContexts() {
 		return new Map(this.batches.map((batch) => {
-			const registry = batch.schema.getResponseSlotRegistry();
+			const registry = batch.schema.slots;
 			validateExportConfiguration(batch.schema, registry);
-			const slots = new Map(registry.definitions.map((slot) => [slot.slotId, slot]));
+			const slots = new Map(localizedExportSlots(batch.schema).map((slot) => [slot.slotId, slot]));
 			const profile = this.profile(batch);
 			const transforms = new Map([...slots.values()].map((slot) => [slot.slotId, {
 				...DEFAULT_TRANSFORM,
 				...slot.exportSettings,
-				...profile?.slotOverrides?.[slot.slotId]
+				...ownValue(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
+				header: ownValue(profile?.columnHeaders, column.id)?.trim() ?? column.header
 			})));
 			const encodings = /* @__PURE__ */ new Map();
 			for (const slotId of new Set(columns.map((column) => column.slotId))) {
@@ -1064,7 +1839,7 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 				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
+				stateGraph: new SurveyStateGraph(batch.schema)
 			}];
 		}));
 	}
@@ -1072,7 +1847,7 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 		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 contextKeys = new Set([...batches.flatMap((batch) => batch.responses), ...extraResponses].flatMap((response) => Object.keys(response.customValues ?? {})));
 		const columns = /* @__PURE__ */ new Set([
 			...[...slots.values()].flatMap((slot) => projectSlot(slot, { mode: "default" }, true).map((column) => column.id)),
 			...META_COLUMN_ORDER.map((field) => encodeExportColumnId(["meta", field])),
@@ -1108,7 +1883,7 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 				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,
+					codes: this.options.codingPolicy === "harmonized" ? ownValue(context.profile?.slotOverrides, slot.slotId)?.optionCodes ?? slot.referenceValueKeys : slot.referenceValueKeys,
 					computed: slot.computed,
 					scores: slot.referenceValueScores
 				});
@@ -1127,7 +1902,7 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 		});
 		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 contextKeys = [...new Set(allResponses.flatMap((response) => Object.keys(response.customValues ?? {})))];
 		const ordered = (values, order, id, name) => values.sort((a, b) => {
 			const left = order.indexOf(id(a)), right = order.indexOf(id(b));
 			if (left >= 0 || right >= 0) return (left < 0 ? Infinity : left) - (right < 0 ? Infinity : right);
@@ -1160,23 +1935,18 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 		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
+		const active = context.stateGraph.evaluate({
+			answers: response.answers,
+			context: {
+				locale: response.evaluationContext?.locale ?? batch.schema.locales[0] ?? "en",
+				currentDate: response.evaluationContext?.currentDate,
+				participantFlags: response.evaluationContext?.participantFlags,
+				customValues: response.customValues
+			}
 		});
 		for (const column of columns) if (column.source === ExportColumnSource.meta) switch (column.metaField) {
 			case "responseId":
-				row[column.header] = response.key;
+				row[column.header] = response.responseId;
 				break;
 			case "participantId":
 				row[column.header] = response.participantId ?? "";
@@ -1187,18 +1957,18 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 			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];
+			const value = ownValue(response.customValues, column.contextKey);
 			row[column.header] = exportSingleResponseSlot({
 				value,
 				valueType: value?.type ?? ValueType.string,
-				transformConfig: profile?.contextOverrides?.[column.contextKey] ?? {
+				transformConfig: ownValue(profile?.contextOverrides, column.contextKey) ?? {
 					...DEFAULT_TRANSFORM,
 					categorical: "ids"
 				}
 			});
 		} else {
 			const slot = slots.get(column.slotId);
-			row[column.header] = slot && included.has(column.id) ? formatProjectedValue(slot, column, slot.computed ? active?.getAnswer(slot.slotId) : response.answers[slot.slotId], transforms.get(slot.slotId)) : "";
+			row[column.header] = slot && included.has(column.id) ? formatProjectedValue(slot, column, active.answer(slot.slotId), transforms.get(slot.slotId)) : "";
 		}
 		return row;
 	}
@@ -1228,16 +1998,16 @@ var SurveyResponseExporter = class SurveyResponseExporter {
 * Generate a structured codebook from a survey definition.
 */
 function generateCodebook(survey, options) {
-	const registry = survey.getResponseSlotRegistry();
+	const registry = survey.slots;
 	validateExportConfiguration(survey, registry);
-	const slots = registry.definitions;
+	const slots = localizedExportSlots(survey);
 	const locales = options?.locales ?? survey.locales;
 	const slotDefsByItemId = /* @__PURE__ */ new Map();
 	for (const slot of slots) {
 		const entries = slotDefsByItemId.get(slot.itemId) ?? [];
 		entries.push({
 			slotId: slot.slotId,
-			primitiveId: slot.primitiveId,
+			elementId: slot.elementId,
 			...slot.rowId ? { rowId: slot.rowId } : {},
 			...slot.columnId ? { columnId: slot.columnId } : {},
 			variableName: slot.variableName,
@@ -1245,45 +2015,47 @@ function generateCodebook(survey, options) {
 			encoding: resolvedSlotEncoding(slot, {
 				mode: "default",
 				...slot.exportSettings,
-				...options?.profile?.slotOverrides?.[slot.slotId]
+				...ownValue(options?.profile?.slotOverrides, slot.slotId)
 			}),
 			optionLabels: slot.referenceValueLabels,
-			allowedValues: slot.allowedValues,
-			...slot.computed ? { computed: structuredClone(slot.computed) } : {},
+			...slot.allowedValues ? { allowedValues: slot.allowedValues.map((value) => structuredClone(value)) } : {},
+			...slot.computed ? { computed: {
+				...slot.computed,
+				sourceSlotIds: [...slot.computed.sourceSlotIds]
+			} } : {},
 			...slot.referenceValueKeys ? { referenceValueKeys: { ...slot.referenceValueKeys } } : {},
 			...slot.referenceValueScores ? { referenceValueScores: { ...slot.referenceValueScores } } : {}
 		});
 		slotDefsByItemId.set(slot.itemId, entries);
 	}
 	const items = [];
-	for (const item of survey.surveyItems.values()) {
+	for (const item of survey.data.surveyItems) {
 		const slotList = slotDefsByItemId.get(item.id) ?? [];
 		slotList.sort((a, b) => a.slotId.localeCompare(b.slotId));
 		let contentByLocale;
 		if (locales.length > 0) {
 			contentByLocale = {};
-			const itemTranslations = survey.getItemTranslations(item.id);
-			if (itemTranslations) for (const locale of locales) {
-				const all = itemTranslations.getAllForLocale(locale);
-				if (all) {
-					const flat = {};
-					for (const [contentKey, content] of Object.entries(all)) flat[contentKey] = getContentPlainText(content);
-					contentByLocale[locale] = flat;
+			for (const locale of locales) {
+				const values = {};
+				for (const owner of survey.owners.values()) if (owner.itemId === item.id) {
+					const roles = ownValue(ownValue(survey.data.translations, locale)?.content, owner.id);
+					if (roles) setOwnValue(values, owner.id, Object.fromEntries(Object.entries(roles).map(([role, content]) => [role, getContentPlainText(content)])));
 				}
+				setOwnValue(contentByLocale, locale, values);
 			}
 		}
 		items.push({
 			id: item.id,
 			editorName: survey.resolveItemEditorName(item.id, locales[0]),
 			breadcrumb: survey.getItemDisplayPath(item.id, locales[0]).breadcrumb,
-			type: item.type,
-			interactive: item.isInteractive(),
+			type: item.itemType,
+			interactive: slotList.some((slot) => !slot.computed),
 			slots: slotList,
 			contentByLocale
 		});
 	}
 	return {
-		surveyKey: survey.surveyKey,
+		surveyKey: survey.data.metadata?.surveyKey,
 		items,
 		projection: new SurveyResponseExporter([{
 			schema: survey,
@@ -1307,18 +2079,42 @@ function generateExportCodebook(batches, options = {}) {
 			sourceId: batch.sourceId,
 			surveySchemaVersion: batch.schema.serialize().schemaVersion,
 			profile: batch.profile && structuredClone(batch.profile),
-			variables: batch.schema.getResponseSlotRegistry().definitions.map((slot) => ({
+			variables: localizedExportSlots(batch.schema).map((slot) => ({
 				...slot,
 				encoding: resolvedSlotEncoding(slot, {
 					mode: "default",
 					...slot.exportSettings,
-					...options.profile?.slotOverrides?.[slot.slotId] ?? batch.profile?.slotOverrides?.[slot.slotId]
+					...ownValue(options.profile?.slotOverrides, slot.slotId) ?? ownValue(batch.profile?.slotOverrides, slot.slotId)
 				})
 			}))
 		}))
 	};
 }
 //#endregion
-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 };
+//#region src/engine/submission.ts
+/** The host chooses the exact definition and trusted context before calling this boundary. */
+function validateSurveySubmission(survey, input, context, binding) {
+	const response = SurveyResponse.deserialize(input);
+	if (response.definitionId !== binding.definitionId) throw new Error(`Response was given against definition '${response.definitionId}', not '${binding.definitionId}'`);
+	const issues = survey.slots.validateAnswers(response.answers);
+	if (issues.length) throw new Error(issues.map((issue) => issue.message).join("\n"));
+	const plan = new SurveyStateGraph(survey);
+	const applicable = plan.evaluate({
+		answers: response.answers,
+		context
+	}).activeAnswers();
+	const validation = validateSurveyAnswers(plan, applicable, context, { phase: "submit" });
+	if (validation.issues.length) throw new Error(validation.issues.map((issue) => `${issue.slotId}: ${issue.code}`).join("\n"));
+	response.answers = structuredClone(applicable);
+	response.evaluationContext = {
+		locale: context.locale,
+		currentDate: context.currentDate,
+		participantFlags: context.participantFlags && { ...context.participantFlags }
+	};
+	response.customValues = context.customValues && structuredClone(context.customValues);
+	return response;
+}
+//#endregion
+export { AndExpressionEditor, BooleanExportValues, CALENDAR_DATE_UNITS, CURRENT_SURVEY_SCHEMA, CURRENT_SURVEY_SCHEMA_VERSION, ConstBooleanEditor, ConstDateArrayEditor, ConstDateEditor, ConstNumberArrayEditor, ConstNumberEditor, ConstStringArrayEditor, ConstStringEditor, ContentType, CtxCurrentDateEditor, CtxCustomValueEditor, CtxLocaleEditor, CtxPFlagDateEditor, CtxPFlagIsDefinedEditor, CtxPFlagNumEditor, CtxPFlagStringEditor, DEFAULT_TRANSFORM, DefinitionError, DisabledStateEditor, DurationUnits, EXPORTER_PROFILE_SCHEMA_VERSION, EqExpressionEditor, ExportColumnSource, ExpressionEditor, ExpressionEvaluationError, FUNCTION_SIGNATURES, GtExpressionEditor, GteExpressionEditor, InRangeExpressionEditor, JsonPatchError, LtExpressionEditor, LteExpressionEditor, META_COLUMN_ORDER, MaxExpressionEditor, MinExpressionEditor, NumberPrecision, OrExpressionEditor, RESPONSE_VARIABLE_NAME_MAX_LENGTH, ResponseSlotRegistry, ResponseVariableEditor, SURVEY_LOCALIZATION_SURFACES, SURVEY_RESPONSE_SCHEMA_VERSION, SlotTransformMode, StrEqExpressionEditor, StrListContainsExpressionEditor, SumExpressionEditor, Survey, SurveyEventTypes, SurveyResponse, SurveyResponseExporter, SurveySession, SurveyStateGraph, ValueType, addCalendarDate, allocateResponseVariableName, and, annotated, annotatedReferences, applyJsonPatch, assertResponseValue, boundField, calendarDateBounds, calendarDateFromLocalDate, calendarDatePrecision, calendarDateToLocalDate, calendarDaySchema, canWriteSelection, checkDocumentBudget, collectExpressionDependencies, compareCalendarDates, conditionsShape, const_boolean, const_date, const_date_array, const_number, const_number_array, const_string, const_string_array, contentOwner, contentOwnerIds, createCompositionSchema, createElementRegistry, createFlowItemSchema, createFunctionExpression, createRichTextContent, createSeededRandom, createSurveySchema, ctx_current_date, ctx_custom_value, ctx_locale, ctx_pflag_date, ctx_pflag_is_defined, ctx_pflag_num, ctx_pflag_string, date_add_days, date_add_months, date_add_years, date_diff, date_eq, date_gt, date_gte, date_lt, date_lte, date_max, date_min, decodeExportColumnId, decodeJsonPointerSegment, defineElement, differenceCalendarDates, elementShape, encodeExportColumnId, encodeJsonPointerSegment, eq, escapeCsvCell, evaluateExpression, exportSingleResponseSlot, expressionArguments, expressionEditorConfigSchema, expressionField, expressionIssues, expressionSchema, expressionTypeIssues, extendObject, followUpBody, formatCalendarDate, formatProjectedValue, functionNameSchema, functionTypeIssues, generateCodebook, generateCodingKey, generateExportCodebook, generateId, getAssetUsagesFromContent, getAuthoringWarnings, getBrokenReferences, getCompositionLabel, getContentPlainText, getDefaultProjectionDiagnostics, getDefaultProjectionIssues, getDefinitionDiagnostics, getElementSemanticContext, getLocalizationCellKey, getLocalizationCoverage, getLocalizationEntryKey, getLocalizationItems, getPlainTextFromRichTextContent, getSessionDiagnostics, getValueAtJsonPointer, gt, gte, hasLocalizationText, hasPermittedChange, hasRenderableRichTextBlock, hasRenderableRichTextContent, if_else, in_range, inferExpressionReturnType, inspectAnnotated, invalidResponseDomainValues, isAdmissibleInDraft, isCalendarDate, isCalendarDateUnit, isContentEmpty, isEmptySurveyLocalizationEntry, isResponseValue, isValidResponseVariableName, is_disabled, itemEditorMetadataSchema, itemResponseMetadataSchema, jsonValueSchema, layoutPolicySchema, listLocalizationEntries, list_count, localizedExportSlots, lt, lte, max, min, moveArrayElement, operand, optionIds, optionMapping, or, ownValue, ownedId, ownerAtPath, parseJsonPointer, projectSlot, readLocalizationContent, referenceId, remapAnnotated, remapExpression, resolveElementName, resolveParticipantContent, resolveUniqueItemKey, resolvedSlotEncoding, responseValueElements, responseValueSchema, responseValuesEqual, response_boolean, response_date, response_date_array, response_number, response_number_array, response_string, response_string_array, richTextImageDimensionSchema, richTextImageSourceSchema, schemaAnnotation, selectedAndEnabled, serializeToCsv, sessionSnapshotSchema, setOwnValue, shuffleArray, shuffleIndices, slotPrefillSchema, slotTransformSchema, str_eq, str_list_contains, strictKeyedObject, stringRecord, structuredCloneMethod, suggestResponseVariableName, sum, surveyContentSchema, surveyEventSchema, surveyLocales, surveyResponseSchema, swapArrayElements, templateValueSchema, transformAnnotated, transformExpression, unreachable, validateLocalizationRef, validateResponseSlotValue, validateSurveyAnswers, validateSurveySubmission, validationRuleSchema, valueTypeSchema, visitExpression };
 
 //# sourceMappingURL=index.mjs.map