@case-framework/survey-core 0.7.0 → 0.8.0

package/build/projection-Bl6qCinx.mjs

@@ -0,0 +1,3930 @@
+import { format } from "date-fns/format";
+//#region src/calendar-date.ts
+const pad = (n, width = 2) => String(n).padStart(width, "0");
+const daysInMonth = (year, month) => month === 2 ? year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28 : [
+	4,
+	6,
+	9,
+	11
+].includes(month) ? 30 : 31;
+function isCalendarDate(value) {
+	if (typeof value !== "string" || !/^\d{4}(?:-\d{2}(?:-\d{2})?)?$/.test(value)) return false;
+	const [year, month, day] = value.split("-").map(Number);
+	return year >= 1 && year <= 9999 && (month === void 0 || month >= 1 && month <= 12 && (day === void 0 || day >= 1 && day <= daysInMonth(year, month)));
+}
+function calendarDatePrecision(value) {
+	if (!isCalendarDate(value)) throw new Error(`Invalid calendar date: ${value}`);
+	return value.length === 4 ? "year" : value.length === 7 ? "year-month" : "year-month-day";
+}
+function calendarDateFromLocalDate(date, precision = "year-month-day") {
+	const value = [
+		pad(date.getFullYear(), 4),
+		pad(date.getMonth() + 1),
+		pad(date.getDate())
+	].slice(0, precision === "year" ? 1 : precision === "year-month" ? 2 : 3).join("-");
+	if (!isCalendarDate(value)) throw new Error("Invalid calendar date");
+	return value;
+}
+/** Adapter for calendar widgets only. Never serialize this Date as an instant. */
+function calendarDateToLocalDate(value) {
+	calendarDatePrecision(value);
+	const [year, month = 1, day = 1] = value.split("-").map(Number);
+	const date = /* @__PURE__ */ new Date(0);
+	date.setFullYear(year, month - 1, day);
+	date.setHours(12, 0, 0, 0);
+	return date;
+}
+function calendarDateBounds(value) {
+	calendarDatePrecision(value);
+	const [year, month] = value.split("-").map(Number);
+	if (value.length === 4) return [`${value}-01-01`, `${value}-12-31`];
+	if (value.length === 7) return [`${value}-01`, `${value}-${pad(daysInMonth(year, month))}`];
+	return [value, value];
+}
+/** Ordering requires equal precision; callers must explicitly choose interval semantics otherwise. */
+function compareCalendarDates(a, b) {
+	if (!isCalendarDate(a) || !isCalendarDate(b) || a.length !== b.length) return void 0;
+	return a === b ? 0 : a < b ? -1 : 1;
+}
+function utcDate(value) {
+	const [year, month = 1, day = 1] = value.split("-").map(Number);
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, month - 1, day);
+	return date;
+}
+function addCalendarDate(value, amount, unit) {
+	if (!isCalendarDate(value) || !Number.isSafeInteger(amount)) return void 0;
+	if (amount === 0) return value;
+	if (unit === "days" && value.length !== 10 || unit === "months" && value.length < 7) return void 0;
+	const [year, month = 1, day = 1] = value.split("-").map(Number);
+	let result;
+	if (unit === "days") {
+		const date = utcDate(value);
+		date.setUTCDate(date.getUTCDate() + amount);
+		result = `${pad(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+	} else {
+		const index = (year - 1) * 12 + month - 1 + amount * (unit === "years" ? 12 : 1);
+		const nextYear = Math.floor(index / 12) + 1;
+		const nextMonth = (index % 12 + 12) % 12 + 1;
+		result = `${pad(nextYear, 4)}-${pad(nextMonth)}-${pad(Math.min(day, daysInMonth(nextYear, nextMonth)))}`.slice(0, value.length);
+	}
+	return isCalendarDate(result) ? result : void 0;
+}
+/** Signed difference a - b in the value's precision unit (days, months, or years). */
+function differenceCalendarDates(a, b) {
+	if (compareCalendarDates(a, b) === void 0) return void 0;
+	if (a.length === 10) return (utcDate(a).getTime() - utcDate(b).getTime()) / 864e5;
+	const [ay, am = 1] = a.split("-").map(Number);
+	const [by, bm = 1] = b.split("-").map(Number);
+	return a.length === 4 ? ay - by : (ay - by) * 12 + am - bm;
+}
+var CalendarFormattingDate = class extends Date {
+	getTimezoneOffset() {
+		return 0;
+	}
+	getFullYear() {
+		return this.getUTCFullYear();
+	}
+	getMonth() {
+		return this.getUTCMonth();
+	}
+	getDate() {
+		return this.getUTCDate();
+	}
+	getDay() {
+		return this.getUTCDay();
+	}
+	getHours() {
+		return this.getUTCHours();
+	}
+	getMinutes() {
+		return this.getUTCMinutes();
+	}
+	getSeconds() {
+		return this.getUTCSeconds();
+	}
+	getMilliseconds() {
+		return this.getUTCMilliseconds();
+	}
+	setFullYear(...args) {
+		return this.setUTCFullYear(...args);
+	}
+	setMonth(...args) {
+		return this.setUTCMonth(...args);
+	}
+	setDate(...args) {
+		return this.setUTCDate(...args);
+	}
+	setHours(...args) {
+		return this.setUTCHours(...args);
+	}
+	setMinutes(...args) {
+		return this.setUTCMinutes(...args);
+	}
+	setSeconds(...args) {
+		return this.setUTCSeconds(...args);
+	}
+	setMilliseconds(...args) {
+		return this.setUTCMilliseconds(...args);
+	}
+};
+/** Partial dates retain their precision even if a display pattern requests absent components. */
+function formatCalendarDate(value, pattern) {
+	calendarDatePrecision(value);
+	if (value.length !== 10) return value;
+	return format(new CalendarFormattingDate(utcDate(value).getTime()), pattern);
+}
+//#endregion
+//#region src/survey/responses/value-types.ts
+const ValueType = {
+	string: "string",
+	duration: "duration",
+	reference: "reference",
+	number: "number",
+	boolean: "boolean",
+	date: "date",
+	stringArray: "string[]",
+	durationArray: "duration[]",
+	referenceArray: "reference[]",
+	numberArray: "number[]",
+	dateArray: "date[]"
+};
+const DurationUnits = {
+	seconds: "seconds",
+	minutes: "minutes",
+	hours: "hours",
+	days: "days",
+	weeks: "weeks",
+	months: "months",
+	years: "years"
+};
+const NumberPrecision = {
+	int: "int",
+	float: "float"
+};
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isNumberArray(value) {
+	return Array.isArray(value) && value.every((item) => isFiniteNumber(item));
+}
+function isOptionalNumberPrecision(value) {
+	return value === void 0 || value === NumberPrecision.int || value === NumberPrecision.float;
+}
+function isDurationUnit(value) {
+	return typeof value === "string" && Object.values(DurationUnits).includes(value);
+}
+function isResponseValue(value) {
+	if (!isPlainObject(value) || typeof value.type !== "string") return false;
+	switch (value.type) {
+		case ValueType.string:
+		case ValueType.reference: return typeof value.value === "string";
+		case ValueType.number: return isFiniteNumber(value.value) && isOptionalNumberPrecision(value.precision);
+		case ValueType.boolean: return typeof value.value === "boolean";
+		case ValueType.date: return isCalendarDate(value.value);
+		case ValueType.duration: return isFiniteNumber(value.value) && isDurationUnit(value.unit) && isOptionalNumberPrecision(value.precision);
+		case ValueType.stringArray:
+		case ValueType.referenceArray: return isStringArray(value.value);
+		case ValueType.dateArray: return Array.isArray(value.value) && value.value.every(isCalendarDate);
+		case ValueType.numberArray: return isNumberArray(value.value) && (value.type !== ValueType.numberArray || isOptionalNumberPrecision(value.precision));
+		case ValueType.durationArray: return isNumberArray(value.value) && isDurationUnit(value.unit) && isOptionalNumberPrecision(value.precision);
+		default: return false;
+	}
+}
+function assertResponseValue(value, path) {
+	if (!isResponseValue(value)) throw new Error(`Invalid response value at '${path}'`);
+}
+//#endregion
+//#region src/survey/responses/item-response.ts
+/**
+* SurveyItemResponse to store the response of a survey item.
+*/
+var SurveyItemResponse = class SurveyItemResponse {
+	itemId;
+	meta;
+	response;
+	itemType;
+	constructor(itemDef, response) {
+		this.itemId = itemDef.itemId;
+		this.response = response;
+		this.itemType = itemDef.itemType;
+	}
+	serialize() {
+		return {
+			itemId: this.itemId,
+			itemType: this.itemType,
+			meta: this.meta,
+			response: this.response?.serialize()
+		};
+	}
+	static deserialize(json) {
+		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid survey item response payload");
+		if (typeof json.itemId !== "string" || json.itemId.trim().length === 0) throw new Error("Survey item response is missing a valid itemId");
+		if (typeof json.itemType !== "string" || json.itemType.trim().length === 0) throw new Error("Survey item response is missing a valid itemType");
+		const itemDef = {
+			itemId: json.itemId,
+			itemType: json.itemType
+		};
+		const response = json.response ? ResponseItem.deserialize(json.response) : void 0;
+		const newResponse = new SurveyItemResponse(itemDef, response);
+		newResponse.meta = json.meta;
+		return newResponse;
+	}
+};
+var ResponseItem = class ResponseItem {
+	_slots;
+	constructor(initialValues) {
+		this._slots = new Map(initialValues ?? []);
+	}
+	get(slotId) {
+		return this._slots.get(slotId);
+	}
+	setSlotValue(slotId, slotResponse) {
+		if (slotResponse) this._slots.set(slotId, slotResponse);
+		else this._slots.delete(slotId);
+	}
+	serialize() {
+		if (this._slots.size === 0) return;
+		return { slots: Object.fromEntries(this._slots.entries()) };
+	}
+	isEmpty() {
+		return this._slots.size === 0;
+	}
+	clone() {
+		return new ResponseItem(Array.from(this._slots.entries()));
+	}
+	static deserialize(json) {
+		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid response item payload");
+		const { slots } = json;
+		if (!slots || typeof slots !== "object" || Array.isArray(slots)) throw new Error("Invalid response slots payload");
+		const slotValues = Object.entries(slots).map(([slotId, slotResponse]) => {
+			if (slotId.trim().length === 0) throw new Error("Response slot id cannot be empty");
+			assertResponseValue(slotResponse, `response.slots.${slotId}`);
+			return [slotId, slotResponse];
+		});
+		return new ResponseItem(slotValues);
+	}
+};
+//#endregion
+//#region src/survey/responses/survey-response.ts
+const SURVEY_RESPONSE_SCHEMA_VERSION = 2;
+/** Publication and schema association belong to the host, never to an answer address. */
+var SurveyResponse = class SurveyResponse {
+	key;
+	participantId;
+	submittedAt;
+	answers = Object.create(null);
+	itemMetadata = Object.create(null);
+	events = [];
+	context;
+	evaluationContext;
+	constructor(key) {
+		this.key = key;
+	}
+	/** Collect an engine item view into a flat submission, rejecting ambiguous ownership. */
+	addItemResponse(item) {
+		const slots = item.response?.serialize()?.slots ?? {};
+		for (const slotId of Object.keys(slots)) if (Object.hasOwn(this.answers, slotId)) throw new Error(`Duplicate submission slot: ${slotId}`);
+		Object.assign(this.answers, structuredClone(slots));
+		if (item.meta) this.itemMetadata[item.itemId] = structuredClone(item.meta);
+	}
+	serialize() {
+		return structuredClone({
+			schemaVersion: 2,
+			key: this.key,
+			participantId: this.participantId,
+			submittedAt: this.submittedAt,
+			answers: this.answers,
+			itemMetadata: this.itemMetadata,
+			events: this.events,
+			context: this.context,
+			evaluationContext: this.evaluationContext
+		});
+	}
+	static deserialize(json) {
+		if (!json || typeof json !== "object" || Array.isArray(json)) throw new Error("Invalid survey response payload");
+		if (json.schemaVersion !== 2) throw new Error(`Unsupported survey response schema version: ${String(json.schemaVersion)}`);
+		if (typeof json.key !== "string" || !json.key.trim()) throw new Error("Survey response is missing a valid key");
+		const readValues = (value, name) => {
+			if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid ${name} object`);
+			const values = Object.create(null);
+			for (const [key, entry] of Object.entries(value)) {
+				if (!key.trim()) throw new Error(`Empty ${name} key`);
+				assertResponseValue(entry, `${name}.${key}`);
+				values[key] = structuredClone(entry);
+			}
+			return values;
+		};
+		const response = new SurveyResponse(json.key);
+		response.answers = readValues(json.answers, "answers");
+		response.participantId = json.participantId;
+		response.submittedAt = json.submittedAt;
+		if (json.itemMetadata !== void 0 && (!json.itemMetadata || typeof json.itemMetadata !== "object" || Array.isArray(json.itemMetadata))) throw new Error("Invalid itemMetadata object");
+		response.itemMetadata = structuredClone(json.itemMetadata ?? {});
+		if (!Array.isArray(json.events)) throw new Error("Invalid response events");
+		response.events = structuredClone(json.events);
+		if (json.context !== void 0) response.context = readValues(json.context, "context");
+		if (json.evaluationContext !== void 0) {
+			const context = json.evaluationContext;
+			if (!context || typeof context !== "object" || typeof context.locale !== "string" || !context.locale || context.participantFlags !== void 0 && (!context.participantFlags || typeof context.participantFlags !== "object" || Array.isArray(context.participantFlags) || Object.values(context.participantFlags).some((value) => typeof value !== "string"))) throw new Error("Invalid response evaluation context");
+			response.evaluationContext = structuredClone(context);
+		}
+		return response;
+	}
+};
+//#endregion
+//#region src/survey/responses/utils.ts
+const initValueForType = (returnType) => {
+	switch (returnType) {
+		case ValueType.string: return {
+			type: ValueType.string,
+			value: ""
+		};
+		case ValueType.number: return {
+			type: ValueType.number,
+			value: 0
+		};
+		case ValueType.boolean: return {
+			type: ValueType.boolean,
+			value: false
+		};
+		case ValueType.date: return {
+			type: ValueType.date,
+			value: calendarDateFromLocalDate(/* @__PURE__ */ new Date())
+		};
+		case ValueType.stringArray: return {
+			type: ValueType.stringArray,
+			value: []
+		};
+		case ValueType.numberArray: return {
+			type: ValueType.numberArray,
+			value: []
+		};
+		case ValueType.dateArray: return {
+			type: ValueType.dateArray,
+			value: []
+		};
+		case ValueType.duration: return {
+			type: ValueType.duration,
+			value: 0,
+			unit: DurationUnits.seconds
+		};
+		case ValueType.reference: return {
+			type: ValueType.reference,
+			value: ""
+		};
+		case ValueType.durationArray: return {
+			type: ValueType.durationArray,
+			value: [],
+			unit: DurationUnits.seconds
+		};
+		case ValueType.referenceArray: return {
+			type: ValueType.referenceArray,
+			value: []
+		};
+		default: throw new Error("Invalid return type: " + returnType);
+	}
+};
+//#endregion
+//#region src/survey/responses/value-domain.ts
+/** Finite domains describe individual selectable values, including for array slots. */
+function responseValueElements(value) {
+	if (!Array.isArray(value.value)) return [value];
+	const type = value.type.slice(0, -2);
+	return value.value.map((entry) => ({
+		...value,
+		type,
+		value: entry
+	}));
+}
+function responseValuesEqual(left, right) {
+	return left.type === right.type && JSON.stringify(left.value) === JSON.stringify(right.value) && (!("unit" in left) || "unit" in right && left.unit === right.unit);
+}
+/** No coercion: an export code or label is never a categorical option identity. */
+function invalidResponseDomainValues(value, allowedValues) {
+	const domain = allowedValues.flatMap(responseValueElements);
+	return responseValueElements(value).filter((entry) => !domain.some((allowed) => responseValuesEqual(entry, allowed)));
+}
+function validateResponseSlotValue(slot, value) {
+	if (!isResponseValue(value)) return [`Slot "${slot.slotId}" has an invalid typed value.`];
+	if (value.type !== slot.valueType) return [`Slot "${slot.slotId}" requires ${slot.valueType}, received ${value.type}.`];
+	if (!slot.allowedValues) return [];
+	return invalidResponseDomainValues(value, slot.allowedValues).map((entry) => `Slot "${slot.slotId}" contains invalid value ${JSON.stringify(entry)}. Allowed values: ${JSON.stringify(slot.allowedValues)}.`);
+}
+//#endregion
+//#region src/survey/responses/variable-naming.ts
+const RESPONSE_VARIABLE_NAME_MAX_LENGTH = 32;
+const isValidResponseVariableName = (name) => name.length <= 32 && /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/.test(name);
+/** Generate an initial suggestion; explicit rename operations validate instead of coercing. */
+function suggestResponseVariableName(text, fallback = "response") {
+	const normalized = text.replace(/([a-z0-9])([A-Z])/g, "$1_$2").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	return ((/^[a-z]/.test(normalized) ? normalized : `${fallback}_${normalized}`) || fallback).slice(0, 32).replace(/_+$/g, "");
+}
+function allocateResponseVariableName(base, used, maxLength = 32) {
+	if (!isValidResponseVariableName(base)) throw new Error(`Invalid response variable name "${base}"; use lowercase snake_case, starting with a letter, at most 32 characters`);
+	if (base.length <= maxLength && !used.has(base)) return base;
+	const indexed = /^(.*)_([1-9][0-9]*)$/.exec(base);
+	const stemBase = indexed ? indexed[1] : base;
+	const start = indexed ? BigInt(indexed[2]) + 1n : 2n;
+	for (let n = start;; n++) {
+		const suffix = `_${n}`;
+		const stem = stemBase.slice(0, Math.max(0, maxLength - suffix.length)).replace(/_+$/g, "");
+		if (!stem) throw new Error("The variable naming suffix leaves no room for a name");
+		const name = `${stem}${suffix}`;
+		if (!used.has(name)) return name;
+	}
+}
+//#endregion
+//#region src/survey/responses/slot-registry.ts
+/** A detached, derived index. Ambiguous identities never resolve to an arbitrary owner. */
+var ResponseSlotRegistry = class {
+	slots = /* @__PURE__ */ new Map();
+	diagnostics = [];
+	constructor(declarations) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const declaration of declarations) for (const definition of declaration.slots) {
+			const slot = structuredClone({
+				...definition,
+				itemId: declaration.itemId,
+				primitiveId: definition.primitiveId ?? declaration.itemId
+			});
+			if (!slot.slotId.trim() || !slot.primitiveId.trim() || !slot.itemId.trim() || !Object.values(ValueType).includes(slot.valueType)) {
+				this.diagnostics.push({
+					code: "invalid-slot",
+					slotId: slot.slotId,
+					itemId: slot.itemId,
+					message: "Response slots require nonempty identities and a supported value type."
+				});
+				continue;
+			}
+			if (seen.has(slot.slotId)) {
+				this.slots.delete(slot.slotId);
+				this.diagnostics.push({
+					code: "duplicate-slot-id",
+					slotId: slot.slotId,
+					itemId: slot.itemId,
+					message: `Slot "${slot.slotId}" is declared more than once. Allocate unique persistent identities before using this schema.`
+				});
+				continue;
+			}
+			seen.add(slot.slotId);
+			this.slots.set(slot.slotId, slot);
+			const elementType = slot.valueType.endsWith("[]") ? slot.valueType.slice(0, -2) : slot.valueType;
+			if (slot.allowedValues?.some((value) => !isResponseValue(value) || responseValueElements(value).some((entry) => entry.type !== elementType))) this.diagnostics.push({
+				code: "invalid-domain",
+				slotId: slot.slotId,
+				itemId: slot.itemId,
+				message: `The allowed values for slot "${slot.slotId}" must have type ${elementType}.`
+			});
+			if (slot.referenceValueScores && (slot.valueType !== ValueType.reference && slot.valueType !== ValueType.referenceArray || Object.entries(slot.referenceValueScores).some(([id, score]) => !Number.isFinite(score) || slot.allowedValues && !slot.allowedValues.some((value) => value.type === ValueType.reference && value.value === id)))) this.diagnostics.push({
+				code: "invalid-domain",
+				slotId: slot.slotId,
+				itemId: slot.itemId,
+				message: `Scores for slot "${slot.slotId}" must map allowed option IDs to finite numbers.`
+			});
+		}
+		const names = /* @__PURE__ */ new Map();
+		for (const slot of this.slots.values()) {
+			if (typeof slot.variableName !== "string" || !isValidResponseVariableName(slot.variableName)) this.diagnostics.push({
+				code: "invalid-variable-name",
+				slotId: slot.slotId,
+				itemId: slot.itemId,
+				message: `Variable "${slot.variableName}" must use lowercase snake_case, start with a letter and contain at most 32 characters.`
+			});
+			const previous = names.get(slot.variableName);
+			if (previous) this.diagnostics.push({
+				code: "duplicate-variable-name",
+				slotId: slot.slotId,
+				itemId: slot.itemId,
+				message: `Variable name "${slot.variableName}" is already used by slot "${previous}".`
+			});
+			names.set(slot.variableName, slot.slotId);
+		}
+		for (const slot of this.slots.values()) for (const dependency of slot.computed?.sourceSlotIds ?? []) if (!this.slots.has(dependency)) this.diagnostics.push({
+			code: "unknown-dependency",
+			slotId: slot.slotId,
+			itemId: slot.itemId,
+			message: `Computed slot "${slot.slotId}" depends on unknown or ambiguous slot "${dependency}".`
+		});
+		const active = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (id) => {
+			if (active.has(id)) {
+				this.diagnostics.push({
+					code: "computed-cycle",
+					slotId: id,
+					message: `Computed slot "${id}" participates in a dependency cycle.`
+				});
+				return;
+			}
+			if (visited.has(id)) return;
+			active.add(id);
+			for (const dependency of this.slots.get(id)?.computed?.sourceSlotIds ?? []) visit(dependency);
+			active.delete(id);
+			visited.add(id);
+		};
+		for (const id of this.slots.keys()) visit(id);
+	}
+	get(slotId) {
+		const slot = this.slots.get(slotId);
+		return slot && structuredClone(slot);
+	}
+	get definitions() {
+		return structuredClone([...this.slots.values()]);
+	}
+	assertValid() {
+		if (this.diagnostics.length) throw new Error(this.diagnostics.map((entry) => entry.message).join("\n"));
+	}
+	validateAnswers(answers) {
+		const diagnostics = [...this.diagnostics];
+		for (const [slotId, value] of Object.entries(answers)) {
+			const slot = this.slots.get(slotId);
+			if (!slot) {
+				diagnostics.push({
+					code: "unknown-slot",
+					slotId,
+					message: `Answer references unknown or ambiguous slot "${slotId}".`
+				});
+				continue;
+			}
+			const issues = slot.computed ? [`Computed slot "${slotId}" cannot contain a stored answer.`] : validateResponseSlotValue(slot, value);
+			for (const message of issues) diagnostics.push({
+				code: "invalid-answer",
+				slotId,
+				itemId: slot.itemId,
+				message
+			});
+		}
+		return diagnostics;
+	}
+};
+//#endregion
+//#region src/survey/utils/value-reference.ts
+let ValueReferenceMethod = /* @__PURE__ */ function(ValueReferenceMethod) {
+	ValueReferenceMethod["get"] = "get";
+	ValueReferenceMethod["isDefined"] = "isDefined";
+	return ValueReferenceMethod;
+}({});
+/** Slot identity is opaque. String keys are an internal JSON-tuple lookup codec. */
+var ValueReference = class ValueReference {
+	slotId;
+	name;
+	constructor(reference) {
+		let value = reference;
+		if (typeof reference === "string") {
+			const tuple = JSON.parse(reference);
+			if (!Array.isArray(tuple) || tuple.length !== 2) throw new Error("Invalid response-reference lookup key");
+			value = {
+				slotId: tuple[0],
+				method: tuple[1]
+			};
+		}
+		const parsed = value;
+		if (!parsed || typeof parsed.slotId !== "string" || !parsed.slotId.trim() || parsed.method !== "get" && parsed.method !== "isDefined") throw new Error("Response references require a slotId and get or isDefined method");
+		this.slotId = parsed.slotId;
+		this.name = parsed.method;
+	}
+	serialize() {
+		return {
+			slotId: this.slotId,
+			method: this.name
+		};
+	}
+	toString() {
+		return JSON.stringify([this.slotId, this.name]);
+	}
+	static fromParts(slotId, method) {
+		return new ValueReference({
+			slotId,
+			method
+		});
+	}
+};
+let ReferenceUsageType = /* @__PURE__ */ function(ReferenceUsageType) {
+	ReferenceUsageType["displayConditions"] = "displayConditions";
+	ReferenceUsageType["templateValues"] = "templateValues";
+	ReferenceUsageType["validations"] = "validations";
+	ReferenceUsageType["disabledConditions"] = "disabledConditions";
+	ReferenceUsageType["prefills"] = "prefills";
+	return ReferenceUsageType;
+}({});
+//#endregion
+//#region src/expressions/expression.ts
+const ExpressionType = {
+	Const: "const",
+	ResponseVariable: "responseVariable",
+	ContextVariable: "contextVariable",
+	Function: "function"
+};
+const ContextVariableType = {
+	Locale: "locale",
+	ParticipantFlag: "participantFlag",
+	CustomValue: "customValue",
+	CustomExpression: "customExpression"
+};
+/**
+* Base class for all expressions.
+*/
+var Expression = class Expression {
+	type;
+	editorConfig;
+	constructor(type, editorConfig) {
+		this.type = type;
+		this.editorConfig = editorConfig;
+	}
+	static deserialize(json) {
+		if (!json) return;
+		switch (json.type) {
+			case ExpressionType.Const: return ConstExpression.deserialize(json);
+			case ExpressionType.ResponseVariable: return ResponseVariableExpression.deserialize(json);
+			case ExpressionType.ContextVariable: return ContextVariableExpression.deserialize(json);
+			case ExpressionType.Function: return FunctionExpression.deserialize(json);
+		}
+	}
+	clone() {
+		return Expression.deserialize(this.serialize()) ?? (() => {
+			throw new Error("Failed to clone expression");
+		})();
+	}
+};
+var ConstExpression = class ConstExpression extends Expression {
+	value;
+	constructor(value, editorConfig) {
+		super(ExpressionType.Const, editorConfig);
+		if (value?.type === "date" || value?.type === "date[]") assertResponseValue(value, "expression.value");
+		this.value = value;
+		this.type = ExpressionType.Const;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.Const) throw new Error("Invalid expression type: " + json.type);
+		return new ConstExpression(json.value, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return [];
+	}
+	serialize() {
+		return {
+			type: this.type,
+			value: this.value,
+			editorConfig: this.editorConfig
+		};
+	}
+	updateItemKeyReferences(_oldItemKey, _newItemKey) {
+		return false;
+	}
+};
+var ResponseVariableExpression = class ResponseVariableExpression extends Expression {
+	variableRef;
+	constructor(variableRef, editorConfig) {
+		super(ExpressionType.ResponseVariable, editorConfig);
+		this.variableRef = new ValueReference(variableRef).toString();
+		this.type = ExpressionType.ResponseVariable;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.ResponseVariable) throw new Error("Invalid expression type: " + json.type);
+		if (typeof json.variableRef !== "object") throw new Error("Response expressions require a structured slot reference");
+		return new ResponseVariableExpression(json.variableRef, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return [new ValueReference(this.variableRef)];
+	}
+	get responseVariableRef() {
+		return new ValueReference(this.variableRef);
+	}
+	serialize() {
+		return {
+			type: this.type,
+			variableRef: this.responseVariableRef.serialize(),
+			editorConfig: this.editorConfig
+		};
+	}
+};
+var ContextVariableExpression = class ContextVariableExpression extends Expression {
+	contextType;
+	key;
+	arguments;
+	asType;
+	constructor(contextType, key, args, asType, editorConfig) {
+		super(ExpressionType.ContextVariable, editorConfig);
+		this.type = ExpressionType.ContextVariable;
+		this.contextType = contextType;
+		this.key = key;
+		this.arguments = args;
+		this.asType = asType;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.ContextVariable) throw new Error("Invalid expression type: " + json.type);
+		return new ContextVariableExpression(json.contextType, Expression.deserialize(json.key), json.arguments?.map((arg) => Expression.deserialize(arg)), json.asType, json.editorConfig);
+	}
+	get responseVariableRefs() {
+		return [this.key, ...this.arguments ?? []].flatMap((arg) => arg?.responseVariableRefs ?? []);
+	}
+	serialize() {
+		return {
+			type: this.type,
+			contextType: this.contextType,
+			key: this.key?.serialize(),
+			arguments: this.arguments?.map((arg) => arg?.serialize()),
+			asType: this.asType,
+			editorConfig: this.editorConfig
+		};
+	}
+};
+let FunctionExpressionNames = /* @__PURE__ */ function(FunctionExpressionNames) {
+	FunctionExpressionNames["and"] = "and";
+	FunctionExpressionNames["or"] = "or";
+	FunctionExpressionNames["not"] = "not";
+	FunctionExpressionNames["list_contains"] = "list_contains";
+	FunctionExpressionNames["eq"] = "eq";
+	FunctionExpressionNames["gt"] = "gt";
+	FunctionExpressionNames["gte"] = "gte";
+	FunctionExpressionNames["lt"] = "lt";
+	FunctionExpressionNames["lte"] = "lte";
+	FunctionExpressionNames["in_range"] = "in_range";
+	FunctionExpressionNames["sum"] = "sum";
+	FunctionExpressionNames["min"] = "min";
+	FunctionExpressionNames["max"] = "max";
+	FunctionExpressionNames["str_eq"] = "str_eq";
+	FunctionExpressionNames["date_eq"] = "date_eq";
+	FunctionExpressionNames["date_gt"] = "date_gt";
+	FunctionExpressionNames["date_gte"] = "date_gte";
+	FunctionExpressionNames["date_lt"] = "date_lt";
+	FunctionExpressionNames["date_lte"] = "date_lte";
+	FunctionExpressionNames["date_add_days"] = "date_add_days";
+	FunctionExpressionNames["date_add_months"] = "date_add_months";
+	FunctionExpressionNames["date_add_years"] = "date_add_years";
+	FunctionExpressionNames["date_diff"] = "date_diff";
+	FunctionExpressionNames["date_min"] = "date_min";
+	FunctionExpressionNames["date_max"] = "date_max";
+	return FunctionExpressionNames;
+}({});
+var FunctionExpression = class FunctionExpression extends Expression {
+	functionName;
+	arguments;
+	constructor(functionName, args, editorConfig) {
+		super(ExpressionType.Function);
+		this.type = ExpressionType.Function;
+		this.functionName = functionName;
+		this.arguments = args;
+		this.editorConfig = editorConfig;
+	}
+	static deserialize(json) {
+		if (json.type !== ExpressionType.Function) throw new Error("Invalid expression type: " + json.type);
+		const functionName = json.functionName;
+		if (!Object.values(FunctionExpressionNames).includes(functionName)) throw new Error("Invalid function name: " + functionName);
+		const expr = new FunctionExpression(functionName, json.arguments.map((arg) => Expression.deserialize(arg)));
+		expr.editorConfig = json.editorConfig;
+		return expr;
+	}
+	get responseVariableRefs() {
+		const refStrings = this.arguments.flatMap((arg) => arg?.responseVariableRefs).filter((ref) => ref !== void 0).map((ref) => ref.toString());
+		return [...new Set(refStrings)].map((ref) => new ValueReference(ref));
+	}
+	serialize() {
+		return {
+			type: this.type,
+			functionName: this.functionName,
+			arguments: this.arguments.map((arg) => arg?.serialize()),
+			editorConfig: this.editorConfig
+		};
+	}
+};
+//#endregion
+//#region src/expressions/expression-evaluator.ts
+var ExpressionEvaluator = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	eval(expression) {
+		if (expression === void 0) return;
+		switch (expression.type) {
+			case ExpressionType.Const: return this.evaluateConst(expression);
+			case ExpressionType.Function: return this.evaluateFunction(expression);
+			case ExpressionType.ResponseVariable: return this.evaluateResponseVariable(expression);
+			case ExpressionType.ContextVariable: return this.evaluateContextVariable(expression);
+			default: throw new Error(`Unsupported expression type: ${expression.type}`);
+		}
+	}
+	setContext(context) {
+		this.context = context;
+	}
+	evaluateConst(expression) {
+		return expression.value;
+	}
+	resolveStoredValue(slotId) {
+		if (this.context?.resolveResponseValue) return this.context.resolveResponseValue(slotId);
+		const values = Object.values(this.context?.responses ?? {}).map((item) => item.response?.get(slotId)).filter((value) => value !== void 0);
+		if (values.length > 1) throw new Error(`Ambiguous response slot "${slotId}"`);
+		return values[0];
+	}
+	evaluateResponseVariable(expression) {
+		const varRef = expression.responseVariableRef;
+		switch (varRef.name) {
+			case "get": return this.context?.resolveComputedValue?.(varRef.slotId) ?? this.resolveStoredValue(varRef.slotId);
+			case "isDefined": return {
+				type: ValueType.boolean,
+				value: (this.context?.resolveComputedValue?.(varRef.slotId) ?? this.resolveStoredValue(varRef.slotId)) !== void 0
+			};
+			default: throw new Error(`Unsupported value reference method: ${varRef.name}`);
+		}
+	}
+	evaluateFunction(expression) {
+		switch (expression.functionName) {
+			case "and": return this.evaluateAnd(expression);
+			case "or": return this.evaluateOr(expression);
+			case "not": return this.evaluateNot(expression);
+			case "date_eq":
+			case "date_gt":
+			case "date_gte":
+			case "date_lt":
+			case "date_lte":
+			case "date_add_days":
+			case "date_add_months":
+			case "date_add_years":
+			case "date_diff":
+			case "date_min":
+			case "date_max": return this.evaluateDateFunction(expression);
+			case "str_eq": return this.evaluateStrEq(expression);
+			case "eq": return this.evaluateEq(expression);
+			case "gt": return this.evaluateGt(expression);
+			case "gte": return this.evaluateGte(expression);
+			case "lt": return this.evaluateLt(expression);
+			case "lte": return this.evaluateLte(expression);
+			case "in_range": return this.evaluateInRange(expression);
+			case "sum": return this.evaluateSum(expression);
+			case "min": return this.evaluateMin(expression);
+			case "max": return this.evaluateMax(expression);
+			case "list_contains": return this.evaluateListContains(expression);
+			default: throw new Error(`Unsupported function: ${expression.functionName}`);
+		}
+	}
+	evaluateContextVariable(expression) {
+		if (!this.context?.surveyContext) return;
+		const surveyContext = this.context.surveyContext;
+		switch (expression.contextType) {
+			case ContextVariableType.Locale: return {
+				type: ValueType.string,
+				value: surveyContext.locale
+			};
+			case ContextVariableType.ParticipantFlag: {
+				if (!expression.key) return;
+				const flagKey = this.eval(expression.key);
+				if (flagKey?.type !== ValueType.string || flagKey.value === void 0) return;
+				const flagValue = surveyContext.participantFlags?.[flagKey.value];
+				switch (expression.asType) {
+					case ValueType.boolean: return {
+						type: ValueType.boolean,
+						value: flagValue !== void 0
+					};
+					case ValueType.string:
+						if (flagValue === void 0) return;
+						return {
+							type: ValueType.string,
+							value: flagValue
+						};
+					case ValueType.number: {
+						if (flagValue === void 0) return;
+						const numValue = parseFloat(flagValue);
+						return isNaN(numValue) ? void 0 : {
+							type: ValueType.number,
+							value: numValue
+						};
+					}
+					case ValueType.date:
+						if (flagValue === void 0) return;
+						return isCalendarDate(flagValue) ? {
+							type: ValueType.date,
+							value: flagValue
+						} : void 0;
+					default:
+						if (flagValue === void 0) return;
+						return {
+							type: ValueType.string,
+							value: flagValue
+						};
+				}
+			}
+			case ContextVariableType.CustomValue: {
+				if (!expression.key) return;
+				const customKey = this.eval(expression.key);
+				if (customKey?.type !== ValueType.string || customKey.value === void 0) return;
+				const customValue = surveyContext.customValues?.[customKey.value];
+				if (customValue === void 0) return;
+				if (expression.asType !== void 0) {
+					if (customValue?.type !== expression.asType) throw new Error(`Custom value type does not match expected type, got ${customValue?.type} and expected ${expression.asType}`);
+				}
+				return customValue;
+			}
+			case ContextVariableType.CustomExpression: {
+				if (!expression.key) return;
+				const expressionKey = this.eval(expression.key);
+				if (expressionKey?.type !== ValueType.string || expressionKey.value === void 0) return;
+				const customExpression = surveyContext.customExpressions?.[expressionKey.value];
+				if (typeof customExpression !== ExpressionType.Function || customExpression === void 0) return;
+				try {
+					const args = expression.arguments;
+					const result = customExpression(args);
+					if (expression.asType !== void 0) {
+						if (result?.type !== expression.asType) throw new Error(`Custom expression result type does not match expected type, got ${result?.type} and expected ${expression.asType}`);
+					}
+					return result;
+				} catch (error) {
+					throw new Error(`Error evaluating custom expression: ${error}`);
+				}
+			}
+		}
+	}
+	evaluateDateFunction(expression) {
+		const name = expression.functionName;
+		const aggregate = name === "date_min" || name === "date_max";
+		if (aggregate ? expression.arguments.length < 1 : expression.arguments.length !== 2) throw new Error(`${name} expects ${aggregate ? "at least 1 argument" : "2 arguments"}`);
+		const args = expression.arguments.map((arg) => this.eval(arg));
+		if (args.some((arg) => arg === void 0)) return void 0;
+		const first = args[0];
+		if (first?.type !== ValueType.date || !isCalendarDate(first.value)) return void 0;
+		if (name.startsWith("date_add_")) {
+			const amount = args[1];
+			if (amount?.type !== ValueType.number) return void 0;
+			const unit = name === "date_add_days" ? "days" : name === "date_add_months" ? "months" : "years";
+			const value = addCalendarDate(first.value, amount.value, unit);
+			return value === void 0 ? void 0 : {
+				type: ValueType.date,
+				value
+			};
+		}
+		const dates = [];
+		for (const arg of args) {
+			if (arg?.type !== ValueType.date || !isCalendarDate(arg.value)) return void 0;
+			dates.push(arg.value);
+		}
+		if (name === "date_eq") return {
+			type: ValueType.boolean,
+			value: dates[0] === dates[1]
+		};
+		if (dates.some((date) => date.length !== first.value.length)) return void 0;
+		if (aggregate) return {
+			type: ValueType.date,
+			value: dates.reduce((a, b) => name === "date_min" ? a < b ? a : b : a > b ? a : b)
+		};
+		if (name === "date_diff") return {
+			type: ValueType.number,
+			value: differenceCalendarDates(dates[0], dates[1])
+		};
+		const comparison = compareCalendarDates(dates[0], dates[1]);
+		return {
+			type: ValueType.boolean,
+			value: name === "date_gt" ? comparison > 0 : name === "date_gte" ? comparison >= 0 : name === "date_lt" ? comparison < 0 : comparison <= 0
+		};
+	}
+	evaluateAnd(expression) {
+		return {
+			type: ValueType.boolean,
+			value: expression.arguments.every((arg) => this.eval(arg)?.value === true)
+		};
+	}
+	evaluateOr(expression) {
+		return {
+			type: ValueType.boolean,
+			value: expression.arguments.some((arg) => this.eval(arg)?.value === true)
+		};
+	}
+	evaluateNot(expression) {
+		if (expression.arguments.length !== 1 || expression.arguments[0] === void 0) throw new Error(`Not function expects 1 argument, got ${expression.arguments.length}`);
+		const resolvedValue = this.eval(expression.arguments[0]);
+		if (resolvedValue?.type !== ValueType.boolean) throw new Error(`Not function expects a boolean argument, got ${resolvedValue?.type}`);
+		if (resolvedValue === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		return {
+			type: ValueType.boolean,
+			value: !resolvedValue.value
+		};
+	}
+	evaluateListContains(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`List contains function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedList = this.eval(expression.arguments[0]);
+		const resolvedItem = this.eval(expression.arguments[1]);
+		if (resolvedList === void 0 || resolvedItem === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		const allowedListTypes = [ValueType.stringArray, ValueType.referenceArray];
+		const allowedItemTypes = [ValueType.string, ValueType.reference];
+		const resolvedListType = resolvedList.type;
+		const resolvedItemType = resolvedItem.type;
+		if (!allowedListTypes.includes(resolvedListType) || !allowedItemTypes.includes(resolvedItemType)) throw new Error(`List contains function expects a string array list and a string item, got ${resolvedList?.type} and ${resolvedItem?.type}`);
+		const list = resolvedList.value;
+		const item = resolvedItem.value;
+		return {
+			type: ValueType.boolean,
+			value: list.includes(item)
+		};
+	}
+	evaluateStrEq(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`String equals function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== ValueType.string || resolvedB?.type !== ValueType.string) throw new Error(`String equals function expects strings for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value === resolvedB.value
+		};
+	}
+	evaluateEq(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Equals function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Equals function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value === resolvedB.value
+		};
+	}
+	evaluateGt(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Greater than function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value > resolvedB.value
+		};
+	}
+	evaluateGte(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Greater than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Greater than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value >= resolvedB.value
+		};
+	}
+	evaluateLt(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Less than function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value < resolvedB.value
+		};
+	}
+	evaluateLte(expression) {
+		if (expression.arguments.length !== 2) throw new Error(`Less than or equal to function expects 2 arguments, got ${expression.arguments.length}`);
+		const resolvedA = this.eval(expression.arguments[0]);
+		const resolvedB = this.eval(expression.arguments[1]);
+		if (resolvedA === void 0 || resolvedB === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedA?.type !== resolvedB?.type) throw new Error(`Less than or equal to function expects the same type for all arguments, got ${resolvedA?.type} and ${resolvedB?.type}`);
+		return {
+			type: ValueType.boolean,
+			value: resolvedA.value <= resolvedB.value
+		};
+	}
+	evaluateInRange(expression) {
+		if (expression.arguments.length !== 4) throw new Error(`In range function expects 4 arguments, got ${expression.arguments.length}`);
+		const resolvedValue = this.eval(expression.arguments[0]);
+		const resolvedMin = this.eval(expression.arguments[1]);
+		const resolvedMax = this.eval(expression.arguments[2]);
+		const resolvedInclusive = this.eval(expression.arguments[3])?.value === true;
+		if (resolvedValue === void 0 || resolvedMin === void 0 || resolvedMax === void 0) return {
+			type: ValueType.boolean,
+			value: false
+		};
+		if (resolvedValue?.type !== ValueType.number || resolvedMin?.type !== ValueType.number || resolvedMax?.type !== ValueType.number) throw new Error(`In range function expects numbers for all arguments, got ${resolvedValue?.type} and ${resolvedMin?.type} and ${resolvedMax?.type}`);
+		if (resolvedInclusive) return {
+			type: ValueType.boolean,
+			value: resolvedValue.value >= resolvedMin.value && resolvedValue.value <= resolvedMax.value
+		};
+		return {
+			type: ValueType.boolean,
+			value: resolvedValue.value > resolvedMin.value && resolvedValue.value < resolvedMax.value
+		};
+	}
+	evaluateSum(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Sum function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((sum, arg) => {
+			if (arg === void 0) return sum;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return sum;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: sum.value + resolvedValue.value
+			};
+			throw new Error(`Sum function expects all arguments to be numbers, got ${resolvedValue?.type}`);
+		}, {
+			type: ValueType.number,
+			value: 0
+		});
+	}
+	evaluateMin(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Min function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((min, arg) => {
+			if (arg === void 0) return min;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return min;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: Math.min(min.value, resolvedValue.value)
+			};
+			throw new Error(`Min function expects all arguments to be numbers, got ${typeof resolvedValue}`);
+		}, {
+			type: ValueType.number,
+			value: Infinity
+		});
+	}
+	evaluateMax(expression) {
+		if (expression.arguments.length < 1) throw new Error(`Max function expects at least 1 argument, got ${expression.arguments.length}`);
+		return expression.arguments.reduce((max, arg) => {
+			if (arg === void 0) return max;
+			const resolvedValue = this.eval(arg);
+			if (resolvedValue === void 0) return max;
+			if (resolvedValue?.type === ValueType.number) return {
+				type: ValueType.number,
+				value: Math.max(max.value, resolvedValue.value)
+			};
+			throw new Error(`Max function expects all arguments to be numbers, got ${typeof resolvedValue}`);
+		}, {
+			type: ValueType.number,
+			value: -Infinity
+		});
+	}
+};
+//#endregion
+//#region src/expressions/template-value.ts
+let TemplateDefTypes = /* @__PURE__ */ function(TemplateDefTypes) {
+	TemplateDefTypes["Default"] = "default";
+	TemplateDefTypes["Date2String"] = "date2string";
+	return TemplateDefTypes;
+}({});
+const serializeTemplateValue = (templateValue) => {
+	const json = {
+		type: templateValue.type,
+		returnType: templateValue.returnType,
+		expression: templateValue.expression?.serialize()
+	};
+	if (templateValue.type === "date2string") json.dateFormat = templateValue.dateFormat;
+	return json;
+};
+const serializeTemplateValues = (templateValues) => {
+	const json = {};
+	for (const [key, value] of templateValues.entries()) json[key] = serializeTemplateValue(value);
+	return json;
+};
+const deserializeTemplateValue = (json) => {
+	return {
+		type: json.type,
+		expression: json.expression ? Expression.deserialize(json.expression) : void 0,
+		returnType: json.returnType,
+		dateFormat: json.dateFormat
+	};
+};
+const deserializeTemplateValues = (json) => {
+	return new Map(Object.entries(json).map(([key, value]) => [key, deserializeTemplateValue(value)]));
+};
+//#endregion
+//#region src/expressions/date-functions.ts
+/** Shared signatures used by authoring, reference diagnostics and assistant validation. */
+const DATE_FUNCTION_SIGNATURES = {
+	date_eq: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.boolean
+	},
+	date_gt: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.boolean
+	},
+	date_gte: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.boolean
+	},
+	date_lt: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.boolean
+	},
+	date_lte: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.boolean
+	},
+	date_add_days: {
+		args: [ValueType.date, ValueType.number],
+		returns: ValueType.date
+	},
+	date_add_months: {
+		args: [ValueType.date, ValueType.number],
+		returns: ValueType.date
+	},
+	date_add_years: {
+		args: [ValueType.date, ValueType.number],
+		returns: ValueType.date
+	},
+	date_diff: {
+		args: [ValueType.date, ValueType.date],
+		returns: ValueType.number
+	},
+	date_min: {
+		args: [ValueType.date],
+		variadic: true,
+		returns: ValueType.date
+	},
+	date_max: {
+		args: [ValueType.date],
+		variadic: true,
+		returns: ValueType.date
+	}
+};
+//#endregion
+//#region src/expressions/reference-integrity.ts
+const ITEM_DISPLAY_DEPENDENCY_OWNER_SCOPE_POLICY = {
+	component: false,
+	item: true,
+	survey: false
+};
+const ITEM_DISPLAY_DEPENDENCY_SURFACE_POLICY = {
+	"display-condition": true,
+	"disabled-condition": false,
+	validation: false,
+	"prefill-condition": false,
+	"prefill-source": false,
+	"template-value": false
+};
+/**
+* Display-condition cycles prevent active-response evaluation, even with prefills.
+* This item-level analysis is complemented by ActiveResponsePlan's full runtime graph,
+* which also includes inherited visibility, component activation and computed dependencies.
+*/
+const SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY = {
+	"invalid-expression": {
+		category: "reference-integrity",
+		disposition: "blocking"
+	},
+	"unknown-response-ref": {
+		category: "reference-integrity",
+		disposition: "blocking"
+	},
+	"expression-reference-type-mismatch": {
+		category: "reference-integrity",
+		disposition: "blocking"
+	},
+	"unknown-reference-value": {
+		category: "reference-integrity",
+		disposition: "blocking"
+	},
+	"display-condition-cycle": {
+		category: "display-dependency",
+		disposition: "blocking"
+	}
+};
+const createExpressionReferenceDiagnostic = (diagnostic) => ({
+	...diagnostic,
+	...SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY[diagnostic.code]
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isJsonExpression = (value) => isRecord(value) && typeof value.type === "string";
+/** Discover references even when a sibling expression is malformed and cannot deserialize. */
+function collectExpressionResponseReferences(expression) {
+	const refs = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (!isRecord(node)) return;
+		if (node.type === ExpressionType.ResponseVariable && isRecord(node.variableRef)) try {
+			const reference = new ValueReference(node.variableRef);
+			refs.set(reference.toString(), reference);
+		} catch {}
+		if (node.type === ExpressionType.ContextVariable) visit(node.key);
+		if (node.type === ExpressionType.Function || node.type === ExpressionType.ContextVariable) {
+			if (Array.isArray(node.arguments)) node.arguments.forEach(visit);
+		}
+	};
+	visit(expression);
+	return [...refs.values()];
+}
+/** Shared by integrity diagnostics and deletion guards for config-owned bounds. */
+const collectConfigValueExpressions = (config) => {
+	const locations = [];
+	const visit = (value, path) => {
+		if (!value || typeof value !== "object") return;
+		for (const [key, child] of Object.entries(value)) {
+			const location = `${path}.${key}`;
+			if (key === "valueExpression") {
+				if (isJsonExpression(child)) locations.push({
+					expression: child,
+					location
+				});
+			} else visit(child, location);
+		}
+	};
+	visit(config, "config");
+	return locations;
+};
+const collectItemExpressionLocations = (item) => {
+	const locations = [];
+	const add = (expression, location, ownerScope, surface) => {
+		if (!isJsonExpression(expression)) return;
+		locations.push({
+			expression,
+			location,
+			ownerItemId: item.id,
+			ownerItemKey: item.metadata?.itemLabel ?? "",
+			ownerScope,
+			surface
+		});
+	};
+	add(item.displayConditions?.root, "displayConditions.root", "item", "display-condition");
+	for (const [componentId, expression] of Object.entries(item.displayConditions?.components ?? {})) add(expression, `displayConditions.components.${componentId}`, "component", "display-condition");
+	for (const [componentId, expression] of Object.entries(item.disabledConditions?.components ?? {})) add(expression, `disabledConditions.components.${componentId}`, "component", "disabled-condition");
+	for (const [validationKey, expression] of Object.entries(item.validations ?? {})) add(expression, `validations.${validationKey}`, "item", "validation");
+	for (const [prefillIndex, prefill] of (item.prefills ?? []).entries()) {
+		const prefillId = prefill.id || String(prefillIndex);
+		add(prefill.when, `prefills.${prefillId}.when`, "item", "prefill-condition");
+		if (prefill.source.type === "expression") add(prefill.source.expression, `prefills.${prefillId}.source.expression`, "item", "prefill-source");
+	}
+	for (const { expression, location } of collectConfigValueExpressions(item.config)) add(expression, location, "item", "validation");
+	return locations;
+};
+const collectSurveyExpressionLocations = (survey) => [...survey.surveyItems.flatMap(collectItemExpressionLocations), ...Object.entries(survey.templateValues ?? {}).flatMap(([templateKey, templateValue]) => templateValue.expression ? [{
+	expression: templateValue.expression,
+	location: `templateValues.${templateKey}.expression`,
+	ownerScope: "survey",
+	surface: "template-value"
+}] : [])];
+const candidateRefs = (unknownRef, availableRefs) => {
+	let parsed;
+	try {
+		parsed = new ValueReference(unknownRef);
+	} catch {
+		return availableRefs.slice(0, 5);
+	}
+	const sameItemAndMethod = availableRefs.filter((candidate) => {
+		try {
+			return new ValueReference(candidate).name === parsed?.name;
+		} catch {
+			return false;
+		}
+	});
+	return (sameItemAndMethod.length > 0 ? sameItemAndMethod : availableRefs).slice(0, 5);
+};
+const findCyclicItemDisplayDependencyEdges = ({ edges, itemIds }) => {
+	const adjacency = new Map(itemIds.map((itemId) => [itemId, /* @__PURE__ */ new Set()]));
+	const reverseAdjacency = new Map(itemIds.map((itemId) => [itemId, /* @__PURE__ */ new Set()]));
+	for (const edge of edges) {
+		adjacency.get(edge.fromItemId)?.add(edge.toItemId);
+		reverseAdjacency.get(edge.toItemId)?.add(edge.fromItemId);
+	}
+	const finishOrder = [];
+	const visited = /* @__PURE__ */ new Set();
+	for (const startItemId of itemIds) {
+		if (visited.has(startItemId)) continue;
+		const stack = [{
+			expanded: false,
+			itemId: startItemId
+		}];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (!current) break;
+			if (current.expanded) {
+				finishOrder.push(current.itemId);
+				continue;
+			}
+			if (visited.has(current.itemId)) continue;
+			visited.add(current.itemId);
+			stack.push({
+				expanded: true,
+				itemId: current.itemId
+			});
+			const dependencies = [...adjacency.get(current.itemId) ?? []];
+			for (let index = dependencies.length - 1; index >= 0; index -= 1) {
+				const dependencyId = dependencies[index];
+				if (visited.has(dependencyId)) continue;
+				stack.push({
+					expanded: false,
+					itemId: dependencyId
+				});
+			}
+		}
+	}
+	const componentByItemId = /* @__PURE__ */ new Map();
+	const componentMembers = /* @__PURE__ */ new Map();
+	for (const startItemId of finishOrder.reverse()) {
+		if (componentByItemId.has(startItemId)) continue;
+		const componentId = componentMembers.size;
+		const members = [];
+		const stack = [startItemId];
+		componentByItemId.set(startItemId, componentId);
+		while (stack.length > 0) {
+			const itemId = stack.pop();
+			if (!itemId) break;
+			members.push(itemId);
+			for (const dependencyOwnerId of reverseAdjacency.get(itemId) ?? []) {
+				if (componentByItemId.has(dependencyOwnerId)) continue;
+				componentByItemId.set(dependencyOwnerId, componentId);
+				stack.push(dependencyOwnerId);
+			}
+		}
+		componentMembers.set(componentId, members.sort());
+	}
+	return edges.flatMap((edge) => {
+		const componentId = componentByItemId.get(edge.fromItemId);
+		if (componentId === void 0 || componentId !== componentByItemId.get(edge.toItemId)) return [];
+		const cycleItemIds = componentMembers.get(componentId) ?? [];
+		if (edge.fromItemId !== edge.toItemId && cycleItemIds.length < 2) return [];
+		return [{
+			edge,
+			cycleItemIds
+		}];
+	});
+};
+const inferExpressionType = (expression, slots) => {
+	if (!expression) return void 0;
+	if (expression.type === ExpressionType.Const) return expression.value?.type;
+	if (expression.type === ExpressionType.ResponseVariable) return slots.get(new ValueReference(expression.variableRef).toString())?.valueType;
+	if (expression.type === ExpressionType.ContextVariable) return expression.contextType === "locale" ? ValueType.string : expression.asType;
+	switch (expression.functionName) {
+		case "and":
+		case "or":
+		case "not":
+		case "eq":
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+		case "in_range":
+		case "list_contains":
+		case "str_eq":
+		case "date_eq":
+		case "date_gt":
+		case "date_gte":
+		case "date_lt":
+		case "date_lte": return ValueType.boolean;
+		case "date_add_days":
+		case "date_add_months":
+		case "date_add_years":
+		case "date_min":
+		case "date_max": return ValueType.date;
+		case "date_diff": return ValueType.number;
+		case "sum":
+		case "min":
+		case "max": return ValueType.number;
+	}
+};
+const itemTypeForList = (type) => {
+	switch (type) {
+		case ValueType.stringArray: return ValueType.string;
+		case ValueType.referenceArray: return ValueType.reference;
+		case ValueType.numberArray: return ValueType.number;
+		case ValueType.dateArray: return ValueType.date;
+		case ValueType.durationArray: return ValueType.duration;
+		default: return;
+	}
+};
+const inspectFunctionReferenceCompatibility = ({ diagnostics, expression, location, slots }) => {
+	if (expression.type === ExpressionType.ContextVariable) {
+		for (const argument of [expression.key, ...expression.arguments ?? []]) if (argument) inspectFunctionReferenceCompatibility({
+			diagnostics,
+			expression: argument,
+			location,
+			slots
+		});
+		return;
+	}
+	if (expression.type !== ExpressionType.Function) return;
+	expression.arguments.forEach((argument) => {
+		if (argument) inspectFunctionReferenceCompatibility({
+			diagnostics,
+			expression: argument,
+			location,
+			slots
+		});
+	});
+	const signature = DATE_FUNCTION_SIGNATURES[expression.functionName];
+	if (signature) {
+		const invalidArity = signature.variadic ? expression.arguments.length < 1 : expression.arguments.length !== signature.args.length;
+		const invalidType = expression.arguments.some((arg, i) => {
+			const actual = inferExpressionType(arg, slots);
+			return actual && actual !== signature.args[signature.variadic ? 0 : i];
+		});
+		if (invalidArity || invalidType) diagnostics.push({
+			code: "expression-reference-type-mismatch",
+			message: `${location.location} has invalid arguments for ${expression.functionName}.`,
+			location: location.location,
+			ownerItemId: location.ownerItemId,
+			ownerItemKey: location.ownerItemKey
+		});
+	}
+	const [left, right] = expression.arguments;
+	const leftType = inferExpressionType(left, slots);
+	const rightType = inferExpressionType(right, slots);
+	if (expression.functionName === "list_contains" ? Boolean(leftType && rightType && itemTypeForList(leftType) !== rightType) : expression.functionName === "eq" ? Boolean(leftType && rightType && leftType !== rightType) : false) diagnostics.push({
+		code: "expression-reference-type-mismatch",
+		message: `${location.location} compares incompatible values (${leftType} and ${rightType}).`,
+		location: location.location,
+		ownerItemId: location.ownerItemId,
+		ownerItemKey: location.ownerItemKey
+	});
+	if (expression.functionName !== "eq" && expression.functionName !== "str_eq" && expression.functionName !== "list_contains") return;
+	const pairs = [[left, right], [right, left]];
+	for (const [variable, constant] of pairs) {
+		if (variable?.type !== ExpressionType.ResponseVariable || constant?.type !== ExpressionType.Const || !constant.value) continue;
+		const slot = slots.get(new ValueReference(variable.variableRef).toString());
+		const domain = slot?.allowedValues ?? slot?.allowedReferenceValues?.map((value) => ({
+			type: ValueType.reference,
+			value
+		}));
+		if (!domain) continue;
+		for (const invalid of invalidResponseDomainValues(constant.value, domain)) {
+			const referenceValue = typeof invalid.value === "string" ? invalid.value : JSON.stringify(invalid.value);
+			diagnostics.push({
+				code: "unknown-reference-value",
+				message: `${location.location} compares slot "${variable.variableRef.slotId}" with invalid value ${JSON.stringify(invalid)}. Allowed values: ${JSON.stringify(domain)}.`,
+				location: location.location,
+				ownerItemId: location.ownerItemId,
+				ownerItemKey: location.ownerItemKey,
+				reference: new ValueReference(variable.variableRef).toString(),
+				referenceValue,
+				candidates: domain.map((value) => String(value.value))
+			});
+		}
+	}
+};
+const analyzeSurveyExpressionReferences = ({ responseSlots, survey }) => {
+	const slots = new Map(responseSlots.map((slot) => [slot.ref, slot]));
+	const availableRefs = responseSlots.map((slot) => slot.ref);
+	const diagnostics = [];
+	const surveyItemIds = survey.surveyItems.map((item) => item.id);
+	const surveyItemIdSet = new Set(surveyItemIds);
+	const itemDisplayDependencyEdges = [];
+	for (const location of collectSurveyExpressionLocations(survey)) {
+		let parsed;
+		try {
+			parsed = Expression.deserialize(location.expression);
+		} catch (error) {
+			diagnostics.push({
+				code: "invalid-expression",
+				message: `${location.location} contains invalid expression JSON: ${error instanceof Error ? error.message : String(error)}`,
+				location: location.location,
+				ownerItemId: location.ownerItemId,
+				ownerItemKey: location.ownerItemKey
+			});
+			continue;
+		}
+		for (const ref of parsed?.responseVariableRefs ?? []) {
+			const reference = ref.toString();
+			if (location.ownerItemId && ITEM_DISPLAY_DEPENDENCY_OWNER_SCOPE_POLICY[location.ownerScope] && ITEM_DISPLAY_DEPENDENCY_SURFACE_POLICY[location.surface] && surveyItemIdSet.has(slots.get(reference)?.itemId ?? "")) itemDisplayDependencyEdges.push({
+				fromItemId: location.ownerItemId,
+				location,
+				reference,
+				toItemId: slots.get(reference).itemId
+			});
+			if (!slots.has(reference)) diagnostics.push({
+				code: "unknown-response-ref",
+				message: `${location.location} references unknown response slot "${reference}".`,
+				location: location.location,
+				ownerItemId: location.ownerItemId,
+				ownerItemKey: location.ownerItemKey,
+				reference,
+				candidates: candidateRefs(reference, availableRefs)
+			});
+		}
+		if (location.location.endsWith(".valueExpression")) {
+			const actual = inferExpressionType(location.expression, slots);
+			if (actual && actual !== ValueType.date) diagnostics.push({
+				code: "expression-reference-type-mismatch",
+				message: `${location.location} must return a date.`,
+				location: location.location,
+				ownerItemId: location.ownerItemId,
+				ownerItemKey: location.ownerItemKey
+			});
+		}
+		inspectFunctionReferenceCompatibility({
+			diagnostics,
+			expression: location.expression,
+			location,
+			slots
+		});
+	}
+	for (const { cycleItemIds, edge } of findCyclicItemDisplayDependencyEdges({
+		edges: itemDisplayDependencyEdges,
+		itemIds: surveyItemIds
+	})) {
+		const isSelfReference = edge.fromItemId === edge.toItemId;
+		diagnostics.push({
+			code: "display-condition-cycle",
+			message: isSelfReference ? `${edge.location.location} for item "${edge.fromItemId}" references its own response "${edge.reference}", creating a circular display dependency.` : `${edge.location.location} for item "${edge.fromItemId}" references item "${edge.toItemId}" within a circular display dependency among ${cycleItemIds.map((itemId) => `"${itemId}"`).join(", ")}.`,
+			location: edge.location.location,
+			ownerItemId: edge.location.ownerItemId,
+			ownerItemKey: edge.location.ownerItemKey,
+			reference: edge.reference
+		});
+	}
+	return diagnostics.map(createExpressionReferenceDiagnostic);
+};
+const expressionReferenceDiagnosticKey = (diagnostic) => [
+	diagnostic.code,
+	diagnostic.ownerItemId ?? "survey",
+	diagnostic.location,
+	diagnostic.reference ?? "",
+	diagnostic.referenceValue ?? ""
+].join("\0");
+const findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories = ({ after, before }) => {
+	const existing = new Set(before.map(expressionReferenceDiagnosticKey));
+	return after.filter((diagnostic) => !existing.has(expressionReferenceDiagnosticKey(diagnostic)));
+};
+const isBlockingSurveyExpressionReferenceDiagnostic = (diagnostic) => {
+	switch (diagnostic.disposition) {
+		case "blocking": return true;
+		case "advisory": return false;
+		default: return true;
+	}
+};
+const findIntroducedBlockingExpressionReferenceDiagnostics = ({ after, before }) => findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories({
+	after,
+	before
+}).filter(isBlockingSurveyExpressionReferenceDiagnostic);
+const replaceResponseVariableReferences = (value, replacements, optionReplacements = {}) => {
+	let changed = false;
+	const visit = (current) => {
+		if (Array.isArray(current)) return current.map(visit);
+		if (!isRecord(current)) return current;
+		const next = Object.fromEntries(Object.entries(current).map(([key, entry]) => [key, visit(entry)]));
+		if (next.type === ExpressionType.ResponseVariable && isRecord(next.variableRef) && typeof next.variableRef.slotId === "string" && replacements[next.variableRef.slotId]) {
+			next.variableRef.slotId = replacements[next.variableRef.slotId];
+			changed = true;
+		}
+		if (next.type === ExpressionType.Const && isRecord(next.value)) {
+			const remap = (id) => {
+				if (!Object.hasOwn(optionReplacements, id)) return id;
+				changed = true;
+				return optionReplacements[id];
+			};
+			if (next.value.type === ValueType.reference && typeof next.value.value === "string") next.value.value = remap(next.value.value);
+			if (next.value.type === ValueType.referenceArray && Array.isArray(next.value.value)) next.value.value = next.value.value.map((id) => typeof id === "string" ? remap(id) : id);
+		}
+		return next;
+	};
+	const rewritten = visit(value);
+	return {
+		changed,
+		value: rewritten
+	};
+};
+const responseValueReferenceIds = (values) => values?.flatMap((value) => value.type === ValueType.reference ? [value.value] : value.type === ValueType.referenceArray ? value.value : []);
+//#endregion
+//#region src/expressions/editors/expression-editor.ts
+var ExpressionEditor = class {
+	returnType;
+	_editorConfig;
+	get editorConfig() {
+		return this._editorConfig;
+	}
+	withEditorConfig(editorConfig) {
+		this._editorConfig = editorConfig;
+		return this;
+	}
+};
+var ConstStringArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.stringArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.stringArray,
+			value: this._values
+		}, this._editorConfig);
+	}
+};
+var ConstStringEditor = class extends ExpressionEditor {
+	returnType = ValueType.string;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.string,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstNumberEditor = class extends ExpressionEditor {
+	returnType = ValueType.number;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.number,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstBooleanEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.boolean,
+			value: this._value
+		}, this._editorConfig);
+	}
+};
+var ConstDateEditor = class extends ExpressionEditor {
+	returnType = ValueType.date;
+	_value;
+	constructor(value, editorConfig) {
+		super();
+		this._value = value;
+		this._editorConfig = editorConfig;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(value) {
+		this._value = value;
+	}
+	getExpression() {
+		const value = this._value;
+		return new ConstExpression({
+			type: ValueType.date,
+			value
+		}, this._editorConfig);
+	}
+};
+var ConstNumberArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.numberArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		return new ConstExpression({
+			type: ValueType.numberArray,
+			value: this._values
+		}, this._editorConfig);
+	}
+};
+var ConstDateArrayEditor = class extends ExpressionEditor {
+	returnType = ValueType.dateArray;
+	_values;
+	constructor(values, editorConfig) {
+		super();
+		this._values = values;
+		this._editorConfig = editorConfig;
+	}
+	get values() {
+		return this._values;
+	}
+	set values(values) {
+		this._values = values;
+	}
+	getExpression() {
+		const value = this._values;
+		return new ConstExpression({
+			type: ValueType.dateArray,
+			value
+		}, this._editorConfig);
+	}
+};
+var ResponseVariableEditor = class extends ExpressionEditor {
+	_variableName;
+	_variableRef;
+	constructor(variableName, variableType, editorConfig) {
+		super();
+		this._variableName = new ValueReference(variableName).toString();
+		this._variableRef = new ValueReference(variableName);
+		this._editorConfig = editorConfig;
+		this.returnType = variableType;
+	}
+	get variableName() {
+		return this._variableName;
+	}
+	get variableRef() {
+		return this._variableRef;
+	}
+	getExpression() {
+		return new ResponseVariableExpression(this._variableName, this._editorConfig);
+	}
+};
+var ContextVariableEditor = class extends ExpressionEditor {
+	_contextType;
+	_key;
+	_args;
+	_asType;
+	constructor(contextType, key, args, asType, editorConfig) {
+		super();
+		this._contextType = contextType;
+		this._key = key;
+		this._args = args;
+		this._asType = asType;
+		this._editorConfig = editorConfig;
+	}
+	getExpression() {
+		return new ContextVariableExpression(this._contextType, this._key?.getExpression(), this._args?.map((arg) => arg.getExpression()), this._asType, this._editorConfig);
+	}
+};
+var CtxLocaleEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(editorConfig) {
+		super(ContextVariableType.Locale, void 0, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxPFlagIsDefinedEditor = class extends ContextVariableEditor {
+	returnType = ValueType.boolean;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.boolean, editorConfig);
+	}
+};
+var CtxPFlagStringEditor = class extends ContextVariableEditor {
+	returnType = ValueType.string;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.string, editorConfig);
+	}
+};
+var CtxPFlagNumEditor = class extends ContextVariableEditor {
+	returnType = ValueType.number;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.number, editorConfig);
+	}
+};
+var CtxPFlagDateEditor = class extends ContextVariableEditor {
+	returnType = ValueType.date;
+	constructor(key, editorConfig) {
+		super(ContextVariableType.ParticipantFlag, key, void 0, ValueType.date, editorConfig);
+	}
+};
+var CtxCustomValueEditor = class extends ContextVariableEditor {
+	constructor(key, asType, editorConfig) {
+		super(ContextVariableType.CustomValue, key, void 0, asType, editorConfig);
+		this.returnType = asType;
+	}
+};
+var CtxCustomExpressionEditor = class extends ContextVariableEditor {
+	constructor(key, args, asType, editorConfig) {
+		super(ContextVariableType.CustomExpression, key, args, asType, editorConfig);
+		this.returnType = asType;
+	}
+};
+var GroupExpressionEditor = class extends ExpressionEditor {
+	_args;
+	constructor(args, editorConfig) {
+		super();
+		this._args = args;
+		this._editorConfig = editorConfig;
+	}
+	get args() {
+		return this._args;
+	}
+	addArg(arg, position) {
+		if (position === void 0) this._args.push(arg);
+		else this._args.splice(position, 0, arg);
+	}
+	removeArg(position) {
+		this._args.splice(position, 1);
+	}
+	replaceArg(position, arg) {
+		this._args[position] = arg;
+	}
+	swapArgs(activeIndex, overIndex) {
+		const newOrder = [...this._args];
+		newOrder.splice(activeIndex, 1);
+		newOrder.splice(overIndex, 0, this._args[activeIndex]);
+		this._args = newOrder;
+	}
+};
+var AndExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.boolean;
+	constructor(args, editorConfig) {
+		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("And expression editor must have boolean arguments");
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression("and", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var OrExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.boolean;
+	constructor(args, editorConfig) {
+		if (args.some((arg) => arg.returnType !== ValueType.boolean)) throw new Error("Or expression editor must have boolean arguments");
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression("or", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var StrListContainsExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_list;
+	_item;
+	constructor(list, item, editorConfig) {
+		super();
+		if (list.returnType !== ValueType.stringArray) throw new Error("List contains expression editor must have a string array list");
+		if (item.returnType !== ValueType.string) throw new Error("List contains expression editor must have a string item");
+		this._list = list;
+		this._item = item;
+		this._editorConfig = editorConfig;
+	}
+	get list() {
+		return this._list;
+	}
+	get item() {
+		return this._item;
+	}
+	set list(list) {
+		this._list = list;
+	}
+	set item(item) {
+		this._item = item;
+	}
+	getExpression() {
+		return new FunctionExpression("list_contains", [this._list?.getExpression(), this._item?.getExpression()], this._editorConfig);
+	}
+};
+var StrEqExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression("str_eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var EqExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression("eq", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var GtExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression("gt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var GteExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression("gte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var LtExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	getExpression() {
+		return new FunctionExpression("lt", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var LteExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	_a;
+	_b;
+	constructor(a, b, editorConfig) {
+		super();
+		this._a = a;
+		this._b = b;
+		this._editorConfig = editorConfig;
+	}
+	get a() {
+		return this._a;
+	}
+	get b() {
+		return this._b;
+	}
+	set b(b) {
+		this._b = b;
+	}
+	set a(a) {
+		this._a = a;
+	}
+	getExpression() {
+		return new FunctionExpression("lte", [this._a?.getExpression(), this._b?.getExpression()], this._editorConfig);
+	}
+};
+var InRangeExpressionEditor = class extends ExpressionEditor {
+	returnType = ValueType.boolean;
+	value;
+	min;
+	max;
+	inclusive;
+	constructor(value, min, max, inclusive, editorConfig) {
+		super();
+		this.value = value;
+		this.min = min;
+		this.max = max;
+		this.inclusive = inclusive;
+		this._editorConfig = editorConfig;
+	}
+	getExpression() {
+		return new FunctionExpression("in_range", [
+			this.value?.getExpression(),
+			this.min?.getExpression(),
+			this.max?.getExpression(),
+			this.inclusive?.getExpression()
+		], this._editorConfig);
+	}
+};
+var SumExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression("sum", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var MinExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression("min", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+var MaxExpressionEditor = class extends GroupExpressionEditor {
+	returnType = ValueType.number;
+	constructor(args, editorConfig) {
+		super(args, editorConfig);
+	}
+	getExpression() {
+		return new FunctionExpression("max", this.args.map((arg) => arg.getExpression()), this._editorConfig);
+	}
+};
+//#endregion
+//#region src/expressions/editors/expression-editor-generators.ts
+const const_string_array = (...values) => {
+	return new ConstStringArrayEditor(values);
+};
+const const_string = (value) => {
+	return new ConstStringEditor(value);
+};
+const const_number_array = (...values) => {
+	return new ConstNumberArrayEditor(values);
+};
+const const_number = (value) => {
+	return new ConstNumberEditor(value);
+};
+const const_boolean = (value) => {
+	return new ConstBooleanEditor(value);
+};
+const const_date = (value) => {
+	return new ConstDateEditor(value);
+};
+const const_date_array = (...values) => {
+	return new ConstDateArrayEditor(values);
+};
+const response_string = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.string);
+};
+const response_string_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.stringArray);
+};
+const response_number = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.number);
+};
+const response_boolean = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.boolean);
+};
+const response_date = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.date);
+};
+const response_number_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.numberArray);
+};
+const response_date_array = (valueRef) => {
+	return new ResponseVariableEditor(valueRef, ValueType.dateArray);
+};
+const ctx_locale = () => {
+	return new CtxLocaleEditor();
+};
+const ctx_pflag_is_defined = (key) => {
+	return new CtxPFlagIsDefinedEditor(key);
+};
+const ctx_pflag_string = (key) => {
+	return new CtxPFlagStringEditor(key);
+};
+const ctx_pflag_num = (key) => {
+	return new CtxPFlagNumEditor(key);
+};
+const ctx_pflag_date = (key) => {
+	return new CtxPFlagDateEditor(key);
+};
+const ctx_custom_value = (key, dType) => {
+	return new CtxCustomValueEditor(key, dType);
+};
+const ctx_custom_expression = (key, args, returnType) => {
+	return new CtxCustomExpressionEditor(key, args, returnType);
+};
+const and = (...args) => {
+	return new AndExpressionEditor(args);
+};
+const or = (...args) => {
+	return new OrExpressionEditor(args);
+};
+const str_list_contains = (list, item) => {
+	return new StrListContainsExpressionEditor(list, item);
+};
+const str_eq = (a, b) => {
+	return new StrEqExpressionEditor(a, b);
+};
+const eq = (a, b) => {
+	return new EqExpressionEditor(a, b);
+};
+const gt = (a, b) => {
+	return new GtExpressionEditor(a, b);
+};
+const gte = (a, b) => {
+	return new GteExpressionEditor(a, b);
+};
+const lt = (a, b) => {
+	return new LtExpressionEditor(a, b);
+};
+const lte = (a, b) => {
+	return new LteExpressionEditor(a, b);
+};
+const in_range = (value, min, max, inclusive) => {
+	return new InRangeExpressionEditor(value, min, max, inclusive);
+};
+const sum = (...args) => {
+	return new SumExpressionEditor(args);
+};
+const min = (...args) => {
+	return new MinExpressionEditor(args);
+};
+const max = (...args) => {
+	return new MaxExpressionEditor(args);
+};
+var CalendarFunctionEditor = class extends ExpressionEditor {
+	name;
+	args;
+	returnType;
+	constructor(name, args, returnType) {
+		super();
+		this.name = name;
+		this.args = args;
+		this.returnType = returnType;
+	}
+	getExpression() {
+		return new FunctionExpression(this.name, this.args.map((arg) => arg.getExpression()));
+	}
+};
+const date_eq = (a, b) => new CalendarFunctionEditor("date_eq", [a, b], ValueType.boolean);
+const date_gt = (a, b) => new CalendarFunctionEditor("date_gt", [a, b], ValueType.boolean);
+const date_gte = (a, b) => new CalendarFunctionEditor("date_gte", [a, b], ValueType.boolean);
+const date_lt = (a, b) => new CalendarFunctionEditor("date_lt", [a, b], ValueType.boolean);
+const date_lte = (a, b) => new CalendarFunctionEditor("date_lte", [a, b], ValueType.boolean);
+const date_add_days = (a, b) => new CalendarFunctionEditor("date_add_days", [a, b], ValueType.date);
+const date_add_months = (a, b) => new CalendarFunctionEditor("date_add_months", [a, b], ValueType.date);
+const date_add_years = (a, b) => new CalendarFunctionEditor("date_add_years", [a, b], ValueType.date);
+const date_diff = (a, b) => new CalendarFunctionEditor("date_diff", [a, b], ValueType.number);
+const date_min = (...args) => new CalendarFunctionEditor("date_min", args, ValueType.date);
+const date_max = (...args) => new CalendarFunctionEditor("date_max", args, ValueType.date);
+//#endregion
+//#region src/survey/items/types.ts
+let ReservedSurveyItemTypes = /* @__PURE__ */ function(ReservedSurveyItemTypes) {
+	ReservedSurveyItemTypes["Group"] = "group";
+	ReservedSurveyItemTypes["PageBreak"] = "page-break";
+	return ReservedSurveyItemTypes;
+}({});
+//#endregion
+//#region src/utils.ts
+function hashString(seed) {
+	let hash = 2166136261;
+	for (let i = 0; i < seed.length; i++) {
+		hash ^= seed.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+function createSeededRandom(seed) {
+	let state = hashString(seed);
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let next = state;
+		next = Math.imul(next ^ next >>> 15, next | 1);
+		next ^= next + Math.imul(next ^ next >>> 7, next | 61);
+		return ((next ^ next >>> 14) >>> 0) / 4294967296;
+	};
+}
+function shuffleArray(values, random = Math.random) {
+	const shuffledValues = [...values];
+	for (let i = shuffledValues.length - 1; i > 0; i--) {
+		const j = Math.floor(random() * (i + 1));
+		[shuffledValues[i], shuffledValues[j]] = [shuffledValues[j], shuffledValues[i]];
+	}
+	return shuffledValues;
+}
+/**
+* Shuffles an array of indices using the Fisher-Yates shuffle algorithm
+* @param length - The length of the array to create indices for
+* @returns A shuffled array of indices from 0 to length-1
+*/
+function shuffleIndices(length, random = Math.random) {
+	return shuffleArray(Array.from({ length }, (_, i) => i), random);
+}
+function structuredCloneMethod(obj) {
+	if (obj === void 0) return obj;
+	if (typeof structuredClone !== "undefined") return structuredClone(obj);
+	return JSON.parse(JSON.stringify(obj));
+}
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function generateId() {
+	const length = 10;
+	const timestamp = Date.now();
+	let encodedTimestamp = "";
+	let t = timestamp;
+	const base = 62;
+	while (t > 0) {
+		encodedTimestamp = ALPHABET.charAt(t % base) + encodedTimestamp;
+		t = Math.floor(t / base);
+	}
+	let randomPart = "";
+	for (let i = 0; i < length; i++) randomPart += ALPHABET.charAt(Math.floor(Math.random() * base));
+	return randomPart + encodedTimestamp;
+}
+/** Alphanumeric chars without ambiguous ones (0/O, 1/I) for human-readable coding keys. */
+const CODING_KEY_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+/**
+* Generates a short random coding key suitable for item keys in exports/codebooks.
+* @param length - Key length (default 4)
+* @returns A random string of the specified length.
+*/
+function generateCodingKey(length = 4) {
+	const base = 32;
+	let key = "";
+	for (let i = 0; i < length; i++) key += CODING_KEY_ALPHABET.charAt(Math.floor(Math.random() * base));
+	return key;
+}
+/** Resolve a sibling key using the editor's stable numeric suffix convention. */
+function resolveUniqueItemKey(key, siblingKeys) {
+	let candidate = key;
+	let suffix = 1;
+	while (siblingKeys.has(candidate)) candidate = `${key}_${suffix++}`;
+	return candidate;
+}
+//#endregion
+//#region src/survey/items/utils.ts
+const displayConditionsFromJson = (json) => {
+	return {
+		root: json.root ? Expression.deserialize(json.root) : void 0,
+		components: json.components ? Object.fromEntries(Object.entries(json.components).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0
+	};
+};
+const disabledConditionsFromJson = (json) => {
+	return { components: json.components ? Object.fromEntries(Object.entries(json.components).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0 };
+};
+//#endregion
+//#region src/survey/items/prefill.ts
+const SurveyItemPrefillApplyMode = { ifEmpty: "ifEmpty" };
+const SurveyItemPrefillTargetType = {
+	itemResponse: "itemResponse",
+	field: "field",
+	embeddedField: "embeddedField"
+};
+function deserializeSurveyItemPrefill(json) {
+	switch (json.source.type) {
+		case "static": return {
+			id: json.id,
+			target: json.target,
+			when: Expression.deserialize(json.when),
+			apply: json.apply,
+			source: {
+				type: "static",
+				value: json.source.value
+			}
+		};
+		case "expression": return {
+			id: json.id,
+			target: json.target,
+			when: Expression.deserialize(json.when),
+			apply: json.apply,
+			source: {
+				type: "expression",
+				expression: Expression.deserialize(json.source.expression) ?? (() => {
+					throw new Error(`Prefill '${json.id}' is missing a valid expression source`);
+				})()
+			}
+		};
+		case "templateValue": return {
+			id: json.id,
+			target: json.target,
+			when: Expression.deserialize(json.when),
+			apply: json.apply,
+			source: {
+				type: "templateValue",
+				key: json.source.key
+			}
+		};
+		case "previousResponse": return {
+			id: json.id,
+			target: json.target,
+			when: Expression.deserialize(json.when),
+			apply: json.apply,
+			source: {
+				type: "previousResponse",
+				ref: json.source.ref,
+				ifUnsupported: json.source.ifUnsupported
+			}
+		};
+		default: throw new Error(`Unsupported prefill source type: ${json.source.type}`);
+	}
+}
+function serializeSurveyItemPrefill(prefill) {
+	switch (prefill.source.type) {
+		case "static": return {
+			id: prefill.id,
+			target: prefill.target,
+			when: prefill.when?.serialize(),
+			apply: prefill.apply,
+			source: {
+				type: "static",
+				value: prefill.source.value
+			}
+		};
+		case "expression": return {
+			id: prefill.id,
+			target: prefill.target,
+			when: prefill.when?.serialize(),
+			apply: prefill.apply,
+			source: {
+				type: "expression",
+				expression: prefill.source.expression.serialize() ?? (() => {
+					throw new Error(`Prefill '${prefill.id}' cannot serialize an empty expression source`);
+				})()
+			}
+		};
+		case "templateValue": return {
+			id: prefill.id,
+			target: prefill.target,
+			when: prefill.when?.serialize(),
+			apply: prefill.apply,
+			source: {
+				type: "templateValue",
+				key: prefill.source.key
+			}
+		};
+		case "previousResponse": return {
+			id: prefill.id,
+			target: prefill.target,
+			when: prefill.when?.serialize(),
+			apply: prefill.apply,
+			source: {
+				type: "previousResponse",
+				ref: prefill.source.ref,
+				ifUnsupported: prefill.source.ifUnsupported
+			}
+		};
+		default: throw new Error(`Unsupported prefill source type: ${prefill.source.type}`);
+	}
+}
+function prefillTargetsEqual(left, right) {
+	if (left.type !== right.type) return false;
+	switch (left.type) {
+		case SurveyItemPrefillTargetType.itemResponse: return true;
+		case SurveyItemPrefillTargetType.field: return left.fieldId === right.fieldId;
+		case SurveyItemPrefillTargetType.embeddedField: return left.optionId === right.optionId && left.fieldId === right.fieldId;
+		default: return false;
+	}
+}
+//#endregion
+//#region src/survey/items/survey-item.ts
+/**
+* Base class for survey item handlers.
+* Each handler holds type, id, key, and config (properly typed) and implements core methods.
+* Subclass for each item type; the core works with SurveyItemHandler only—no casting needed.
+*/
+var SurveyItemCore = class {
+	id;
+	config;
+	_rawItem;
+	displayConditions;
+	disabledConditions;
+	validations;
+	prefills;
+	constructor(rawItem) {
+		this._rawItem = rawItem;
+		this.updateExpressions();
+		this.id = this._rawItem.id;
+		this.config = this.parseConfig(this._rawItem.config);
+	}
+	/** Primitive authors can identify meaningful headings without exposing option/decorative text. */
+	getOutlineContentKeys() {
+		return ["title", "prompt"];
+	}
+	getCompositionTypes() {
+		return [this.type];
+	}
+	/**
+	* Validate/canonicalize updates, initial responses, and configured prefills before evaluation.
+	* Prefills are applied one slot at a time, so multi-slot items must allow partial responses.
+	*/
+	normalizeResponse(response) {
+		return { response };
+	}
+	/** Opt-in component ownership for copy/paste. Existing item formats remain unchanged. */
+	getOwnedComponentIds() {
+		return [];
+	}
+	/** Slots omitted from submissions when their component condition is false; session answers are retained. */
+	getConditionalResponseSlots() {
+		return [];
+	}
+	/** Dependencies used when projecting a stored answer (for example visible choice options). */
+	getActiveResponseDependencies(_slotId) {
+		return {
+			slotIds: [],
+			componentIds: []
+		};
+	}
+	/** Project retained data without mutating it. Dependencies must be declared above. */
+	getActiveResponseValue(_slotId, value, _isVisible, _getAnswer) {
+		return value;
+	}
+	/** Source slots used by a computed reference, for component visibility cycle diagnostics. */
+	getComputedResponseDependencies(slotId) {
+		return this.getResponseSlotDefinitions().find((slot) => slot.slotId === slotId)?.computed?.sourceSlotIds ?? [];
+	}
+	/** Computed references are read-only, evaluated on demand, never persisted/exported as answers. */
+	getComputedResponseValue(_slotId, _response, _isVisible) {}
+	getResponseValidationValues(_response, _isVisible, _evaluate) {
+		return {};
+	}
+	/** Runtime-only checks; authoring may retain incomplete drafts. */
+	getExecutionConfigurationIssues() {
+		return [];
+	}
+	getAvailableResponseValueSlots(byType) {
+		const valueRefs = {};
+		for (const slot of this.getResponseSlotDefinitions()) {
+			valueRefs[JSON.stringify([slot.slotId, "get"])] = slot.valueType;
+			valueRefs[JSON.stringify([slot.slotId, "isDefined"])] = ValueType.boolean;
+		}
+		if (!byType) return valueRefs;
+		return Object.fromEntries(Object.entries(valueRefs).filter(([, valueType]) => valueType === byType));
+	}
+	get rawItem() {
+		return {
+			...this._rawItem,
+			config: this.config
+		};
+	}
+	get metadata() {
+		return this._rawItem.metadata ?? {};
+	}
+	set metadata(metadata) {
+		this.updateRawItem({
+			...this._rawItem,
+			metadata
+		});
+	}
+	get editorMetadata() {
+		return this._rawItem.editorMetadata ?? {};
+	}
+	setCreatedAt(timestamp) {
+		this.updateRawItem({
+			...this._rawItem,
+			editorMetadata: {
+				...this._rawItem.editorMetadata,
+				createdAt: timestamp
+			}
+		});
+	}
+	setModifiedAt(timestamp) {
+		this.updateRawItem({
+			...this._rawItem,
+			editorMetadata: {
+				...this._rawItem.editorMetadata,
+				createdAt: this._rawItem.editorMetadata?.createdAt ?? timestamp,
+				updatedAt: timestamp
+			}
+		});
+	}
+	updateRawItem(rawItem) {
+		if (rawItem.id !== this.id) throw new Error("Cannot update raw item with a different id");
+		this._rawItem = rawItem;
+		this.updateExpressions();
+		this.config = this.parseConfig(rawItem.config);
+	}
+	updateExpressions() {
+		this.displayConditions = this._rawItem.displayConditions ? displayConditionsFromJson(this._rawItem.displayConditions) : void 0;
+		this.disabledConditions = this._rawItem.disabledConditions ? disabledConditionsFromJson(this._rawItem.disabledConditions) : void 0;
+		this.validations = this._rawItem.validations ? Object.fromEntries(Object.entries(this._rawItem.validations).map(([key, value]) => [key, Expression.deserialize(value)])) : void 0;
+		this.prefills = this._rawItem.prefills?.map((prefill) => deserializeSurveyItemPrefill(prefill));
+	}
+	getReferenceUsages() {
+		const usages = [];
+		if (this.displayConditions) {
+			for (const ref of this.displayConditions.root?.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				usageType: "displayConditions",
+				valueReference: ref
+			});
+			for (const [componentKey, expression] of Object.entries(this.displayConditions.components || {})) for (const ref of expression?.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				fullComponentKey: componentKey,
+				usageType: "displayConditions",
+				valueReference: ref
+			});
+		}
+		if (this.disabledConditions) for (const [componentKey, expression] of Object.entries(this.disabledConditions.components || {})) for (const ref of expression?.responseVariableRefs || []) usages.push({
+			itemId: this.id,
+			fullComponentKey: componentKey,
+			usageType: "disabledConditions",
+			valueReference: ref
+		});
+		if (this.validations) for (const [validationKey, expression] of Object.entries(this.validations)) for (const ref of expression?.responseVariableRefs || []) usages.push({
+			itemId: this.id,
+			fullComponentKey: validationKey,
+			usageType: "validations",
+			valueReference: ref
+		});
+		if (this.prefills) for (const prefill of this.prefills) {
+			for (const ref of prefill.when?.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				fullComponentKey: prefill.id,
+				usageType: "prefills",
+				valueReference: ref
+			});
+			if (prefill.source.type === "expression") for (const ref of prefill.source.expression.responseVariableRefs || []) usages.push({
+				itemId: this.id,
+				fullComponentKey: prefill.id,
+				usageType: "prefills",
+				valueReference: ref
+			});
+		}
+		for (const { expression, location } of collectConfigValueExpressions(this.config)) for (const ref of collectExpressionResponseReferences(expression)) usages.push({
+			itemId: this.id,
+			fullComponentKey: location,
+			usageType: "validations",
+			valueReference: ref
+		});
+		return usages;
+	}
+	resolvePrefillTarget(target) {
+		const slotDefinitions = this.getResponseSlotDefinitions();
+		const explicitMatch = slotDefinitions.find((slot) => slot.prefillTarget !== void 0 && prefillTargetsEqual(slot.prefillTarget, target));
+		if (explicitMatch) return explicitMatch;
+		if (target.type === SurveyItemPrefillTargetType.itemResponse && slotDefinitions.length === 1) return slotDefinitions[0];
+	}
+	normalizePrefillValue(_prefill, targetSlot, value) {
+		return value.type === targetSlot.valueType ? value : void 0;
+	}
+};
+//#endregion
+//#region src/survey/item-display-name.ts
+function getCompositionLabel(types, locale) {
+	const language = locale.split("-")[0];
+	const labels = {
+		en: {
+			choiceItem: "Choice",
+			formItem: "Form",
+			formMatrix: "Form matrix",
+			choiceMatrix: "Choice matrix",
+			consentItem: "Consent",
+			infoItem: "Information",
+			group: "Group",
+			"page-break": "Page break",
+			empty: "Empty item"
+		},
+		nl: {
+			choiceItem: "Keuze",
+			formItem: "Formulier",
+			formMatrix: "Formuliermatrix",
+			choiceMatrix: "Keuzematrix",
+			consentItem: "Toestemming",
+			infoItem: "Informatie",
+			group: "Groep",
+			"page-break": "Pagina-einde",
+			empty: "Leeg item"
+		},
+		de: {
+			choiceItem: "Auswahl",
+			formItem: "Formular",
+			formMatrix: "Formularmatrix",
+			choiceMatrix: "Auswahlmatrix",
+			consentItem: "Einwilligung",
+			infoItem: "Information",
+			group: "Gruppe",
+			"page-break": "Seitenumbruch",
+			empty: "Leeres Element"
+		}
+	};
+	const dictionary = labels[language] ?? labels.en;
+	return [...new Set(types)].map((type) => dictionary[type]).filter(Boolean).join(" + ") || dictionary.empty;
+}
+//#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/survey/registry/built-in-items.ts
+var GroupItemCore = class extends SurveyItemCore {
+	type = "group";
+	parseConfig(rawConfig) {
+		const cfg = rawConfig ?? {};
+		return {
+			items: cfg.items,
+			shuffleItems: cfg.shuffleItems,
+			isRoot: cfg.isRoot
+		};
+	}
+	serializeConfig() {
+		return this.config;
+	}
+	isInteractive() {
+		return false;
+	}
+	getResponseSlotDefinitions() {
+		return [];
+	}
+	isRoot() {
+		return this.config.isRoot ?? false;
+	}
+	get items() {
+		return this.config.items ?? [];
+	}
+	/**
+	* Add a child item id to this group at the given index.
+	* @param itemId The id of the item to add to this group.
+	* @param index The index at which to add the item. If not provided, the item is added to the end of the group.
+	*/
+	addChild(itemId, index) {
+		const items = this.config.items ??= [];
+		const insertIndex = index !== void 0 ? Math.min(index, items.length) : items.length;
+		items.splice(insertIndex, 0, itemId);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Remove a child item id from this group.
+	* @param itemId The id of the item to remove from this group.
+	*/
+	removeChild(itemId) {
+		const items = this.config.items ??= [];
+		const index = items.indexOf(itemId);
+		if (index !== -1) {
+			items.splice(index, 1);
+			this.updateRawItem({
+				...this.rawItem,
+				config: { ...this.config }
+			});
+		}
+	}
+	/**
+	* Check if an item is a direct child of this group.
+	*/
+	hasChild(itemId) {
+		return this.items.includes(itemId);
+	}
+	/** Whether items in this group should be shuffled. */
+	get shuffleItems() {
+		return this.config.shuffleItems ?? false;
+	}
+	set shuffleItems(value) {
+		this.config.shuffleItems = value;
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Get the ordered list of child item ids.
+	*/
+	getChildrenIds() {
+		return [...this.items];
+	}
+	/**
+	* Swap two items by their positions in the group.
+	* @throws Error if indices are out of bounds
+	*/
+	swapItemsByIndex(from, to) {
+		const items = this.items;
+		if (from < 0 || from >= items.length || to < 0 || to >= items.length) throw new Error(`Index out of bounds. Valid range is 0-${items.length - 1}`);
+		if (from === to) return;
+		this.config.items = swapArrayElements(items, from, to);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+	/**
+	* Swap two items by their ids.
+	* @throws Error if either id is not found in this group
+	*/
+	swapItemsById(id, withId) {
+		const items = this.items;
+		const index1 = items.indexOf(id);
+		const index2 = items.indexOf(withId);
+		if (index1 === -1) throw new Error(`Item '${id}' not found in group '${this.metadata?.itemLabel ?? ""}'`);
+		if (index2 === -1) throw new Error(`Item '${withId}' not found in group '${this.metadata?.itemLabel ?? ""}'`);
+		this.swapItemsByIndex(index1, index2);
+	}
+	/**
+	* Move an item by id to a specific index.
+	* @throws Error if the item is not found or index is out of bounds
+	*/
+	moveItemToIndex(id, index) {
+		const items = this.items;
+		const fromIndex = items.indexOf(id);
+		if (fromIndex === -1) throw new Error(`Item '${id}' not found in group '${this.metadata?.itemLabel ?? ""}'`);
+		if (index < 0 || index >= items.length) throw new Error(`Index out of bounds. Valid range is 0-${items.length - 1}`);
+		if (fromIndex === index) return;
+		this.config.items = moveArrayElement(items, fromIndex, index);
+		this.updateRawItem({
+			...this.rawItem,
+			config: { ...this.config }
+		});
+	}
+};
+var PageBreakItemCore = class extends SurveyItemCore {
+	type = "page-break";
+	parseConfig(_rawConfig) {
+		return {};
+	}
+	serializeConfig() {}
+	isInteractive() {
+		return false;
+	}
+	getResponseSlotDefinitions() {
+		return [];
+	}
+};
+const builtInItemCoreRegistry = {
+	["group"]: GroupItemCore,
+	["page-break"]: PageBreakItemCore
+};
+const isBuiltInItemType = (itemType) => itemType in builtInItemCoreRegistry;
+//#endregion
+//#region src/survey/registry/item-registry.ts
+/** Convert constructor registry to explicit definitions for higher-layer composition. */
+function toItemTypeDefinitionRegistry(registry) {
+	return Object.fromEntries(Object.entries(registry).map(([itemType, constructor]) => [itemType, {
+		itemType,
+		constructor
+	}]));
+}
+/**
+* Creates a handler instance for a raw survey item.
+* Uses built-in registry for group/page-break, otherwise the provided plugin registry.
+*/
+function createItemCore(rawItem, pluginRegistry) {
+	if (isBuiltInItemType(rawItem.itemType)) {
+		const HandlerClass = builtInItemCoreRegistry[rawItem.itemType];
+		return new HandlerClass(rawItem);
+	}
+	if (pluginRegistry && rawItem.itemType in pluginRegistry) {
+		const HandlerClass = pluginRegistry[rawItem.itemType];
+		return new HandlerClass(rawItem);
+	}
+	throw new Error(`Unknown item type: ${rawItem.itemType}`);
+}
+/**
+* Merge built-in handlers with plugin registry for a complete registry.
+*/
+function createFullRegistry(pluginRegistry) {
+	return {
+		...builtInItemCoreRegistry,
+		...pluginRegistry
+	};
+}
+/** Build full registry as explicit definitions for editor/ui composition. */
+function createItemTypeDefinitionRegistry(pluginRegistry) {
+	return toItemTypeDefinitionRegistry(createFullRegistry(pluginRegistry));
+}
+//#endregion
+//#region src/survey/survey-file-schema.ts
+const CURRENT_SURVEY_SCHEMA_VERSION = 2;
+const CURRENT_SURVEY_SCHEMA = "https://github.com/case-framework/case-survey-toolkit/packages/survey-core/schemas/survey-schema.json";
+//#endregion
+//#region src/survey/utils/translations.ts
+const validateLocale = (locale) => {
+	if (locale.trim() === "") throw new Error("Locale cannot be empty");
+};
+var SurveyItemTranslations = class SurveyItemTranslations {
+	_translations;
+	constructor() {
+		this._translations = {};
+	}
+	setContent(locale, contentKey, content) {
+		validateLocale(locale);
+		if (!this._translations?.[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		if (!content) delete this._translations[locale][contentKey];
+		else this._translations[locale][contentKey] = content;
+	}
+	setAllForLocale(locale, content) {
+		validateLocale(locale);
+		if (!this._translations?.[locale]) {
+			if (!content) return;
+			this._translations[locale] = {};
+		}
+		this._translations[locale] = content || {};
+	}
+	get locales() {
+		return Object.keys(this._translations || {});
+	}
+	getAllForLocale(locale) {
+		return this._translations?.[locale];
+	}
+	getContent(locale, contentKey, fallbackLocale) {
+		const content = this._translations?.[locale]?.[contentKey];
+		if (content) return content;
+		if (fallbackLocale) return this._translations?.[fallbackLocale]?.[contentKey];
+	}
+	/**
+	* Create a deep clone that can be safely mutated before persisting with
+	* `setItemTranslations` or `updateItemTranslations`.
+	*/
+	clone() {
+		const cloned = new SurveyItemTranslations();
+		for (const locale of this.locales) {
+			const localeContent = this.getAllForLocale(locale);
+			if (!localeContent) continue;
+			cloned.setAllForLocale(locale, structuredCloneMethod(localeContent));
+		}
+		return cloned;
+	}
+	/**
+	* Remove a single content key from every locale in this translation set.
+	*/
+	removeContentKey(contentKey) {
+		for (const locale of this.locales) delete this._translations?.[locale]?.[contentKey];
+	}
+	/**
+	* Remove every content key that is exactly the prefix or nested beneath it.
+	*/
+	removeContentKeysWithPrefix(prefix) {
+		for (const locale of this.locales) {
+			const localeContent = this._translations?.[locale];
+			if (!localeContent) continue;
+			for (const contentKey of Object.keys(localeContent)) if (contentKey === prefix || contentKey.startsWith(prefix + ".")) delete localeContent[contentKey];
+		}
+	}
+	/**
+	* Remove empty locales in place.
+	* Returns `undefined` when no translations remain so callers can pass the
+	* result directly into `setItemTranslations` / `updateItemTranslations`.
+	*/
+	compact() {
+		for (const locale of this.locales) {
+			const localeContent = this._translations?.[locale];
+			if (!localeContent) continue;
+			if (Object.keys(localeContent).length === 0) delete this._translations?.[locale];
+		}
+		return this.locales.length > 0 ? this : void 0;
+	}
+};
+var SurveyTranslations = class SurveyTranslations {
+	_translations;
+	constructor(translations) {
+		this._translations = structuredCloneMethod(translations || {});
+	}
+	/** Cheap revision fork. Every writer replaces its path before changing it. */
+	fork() {
+		const next = new SurveyTranslations();
+		next._translations = this._translations;
+		return next;
+	}
+	serialize() {
+		return this.locales.length ? structuredCloneMethod(this._translations) : void 0;
+	}
+	get locales() {
+		return Object.keys(this._translations);
+	}
+	replaceLocale(locale, value) {
+		this._translations = {
+			...this._translations,
+			[locale]: value
+		};
+	}
+	replaceItem(locale, itemId, fields, keepEmpty = false) {
+		const current = this._translations[locale] ?? {};
+		const items = { ...current.itemTranslations };
+		if (fields && (keepEmpty || Object.keys(fields).length)) items[itemId] = fields;
+		else delete items[itemId];
+		this.replaceLocale(locale, {
+			...current,
+			itemTranslations: items
+		});
+	}
+	addLocale(locale) {
+		validateLocale(locale);
+		if (this._translations[locale]) return false;
+		this.replaceLocale(locale, {});
+		return true;
+	}
+	removeLocale(locale) {
+		validateLocale(locale);
+		const next = { ...this._translations };
+		delete next[locale];
+		this._translations = next;
+	}
+	renameLocale(oldLocale, newLocale) {
+		validateLocale(oldLocale);
+		validateLocale(newLocale);
+		if (this._translations[oldLocale]) {
+			this.replaceLocale(newLocale, this._translations[oldLocale]);
+			this.removeLocale(oldLocale);
+		}
+	}
+	cloneLocaleAs(locale, newLocale) {
+		validateLocale(locale);
+		validateLocale(newLocale);
+		if (this._translations[locale]) this.replaceLocale(newLocale, this._translations[locale]);
+	}
+	get surveyCardContent() {
+		const result = {};
+		for (const locale of this.locales) {
+			const content = this._translations[locale].surveyCardContent;
+			if (content) result[locale] = structuredCloneMethod(content);
+		}
+		return result;
+	}
+	get navigationContent() {
+		const result = {};
+		for (const locale of this.locales) {
+			const content = this._translations[locale].navigationContent;
+			if (content) result[locale] = structuredCloneMethod(content);
+		}
+		return result;
+	}
+	get validationMessages() {
+		const result = {};
+		for (const locale of this.locales) {
+			const content = this._translations[locale].validationMessages;
+			if (content) result[locale] = structuredCloneMethod(content);
+		}
+		return result;
+	}
+	setSurveyCardContent(locale, content) {
+		validateLocale(locale);
+		if (!content && !this._translations[locale]) return;
+		this.replaceLocale(locale, {
+			...this._translations[locale],
+			surveyCardContent: structuredCloneMethod(content)
+		});
+	}
+	setNavigationContent(locale, content) {
+		validateLocale(locale);
+		if (!content && !this._translations[locale]) return;
+		this.replaceLocale(locale, {
+			...this._translations[locale],
+			navigationContent: structuredCloneMethod(content)
+		});
+	}
+	setValidationMessages(locale, content) {
+		validateLocale(locale);
+		if (!content && !this._translations[locale]) return;
+		this.replaceLocale(locale, {
+			...this._translations[locale],
+			validationMessages: structuredCloneMethod(content)
+		});
+	}
+	getItemTranslationContent(itemId, locale, contentKey, fallbackLocale) {
+		return structuredCloneMethod(this._translations[locale]?.itemTranslations?.[itemId]?.[contentKey] ?? (fallbackLocale ? this._translations[fallbackLocale]?.itemTranslations?.[itemId]?.[contentKey] : void 0));
+	}
+	setItemTranslationContent(itemId, locale, contentKey, content) {
+		validateLocale(locale);
+		const current = this._translations[locale]?.itemTranslations?.[itemId];
+		if (JSON.stringify(current?.[contentKey]) === JSON.stringify(content)) return false;
+		const fields = { ...current };
+		if (content === void 0) delete fields[contentKey];
+		else fields[contentKey] = structuredCloneMethod(content);
+		this.replaceItem(locale, itemId, fields);
+		return true;
+	}
+	getItemTranslations(itemId) {
+		const result = new SurveyItemTranslations();
+		for (const locale of this.locales) result.setAllForLocale(locale, structuredCloneMethod(this._translations[locale].itemTranslations?.[itemId]));
+		return result.locales.length ? result : void 0;
+	}
+	setItemTranslations(itemId, content) {
+		const normalized = content?.clone().compact();
+		for (const locale of /* @__PURE__ */ new Set([...this.locales, ...normalized?.locales ?? []])) {
+			validateLocale(locale);
+			const fields = normalized?.getAllForLocale(locale);
+			if (fields || this._translations[locale]?.itemTranslations?.[itemId]) this.replaceItem(locale, itemId, fields);
+		}
+	}
+	onComponentKeyChanged(itemId, oldKey, newKey) {
+		for (const locale of this.locales) {
+			const current = this._translations[locale].itemTranslations?.[itemId];
+			if (!current) continue;
+			const fields = { ...current };
+			for (const key of Object.keys(current)) if (key === oldKey || key.startsWith(oldKey + ".")) {
+				fields[key.replace(oldKey, newKey)] = current[key];
+				delete fields[key];
+			}
+			this.replaceItem(locale, itemId, fields, true);
+		}
+	}
+	onComponentDeleted(itemId, componentKey) {
+		for (const locale of this.locales) {
+			const current = this._translations[locale].itemTranslations?.[itemId];
+			if (!current) continue;
+			const fields = { ...current };
+			for (const key of Object.keys(current)) if (key === componentKey || key.startsWith(componentKey + ".")) delete fields[key];
+			this.replaceItem(locale, itemId, fields, true);
+		}
+	}
+	onItemDeleted(itemId) {
+		for (const locale of this.locales) if (this._translations[locale].itemTranslations?.[itemId]) this.replaceItem(locale, itemId);
+	}
+};
+//#endregion
+//#region src/survey/utils/content.ts
+let ContentType = /* @__PURE__ */ function(ContentType) {
+	ContentType["richText"] = "richText";
+	ContentType["plain"] = "plain";
+	ContentType["md"] = "md";
+	return ContentType;
+}({});
+function hasRenderableRichTextBlock(block) {
+	switch (block.type) {
+		case "paragraph": return block.children.length > 0;
+		case "heading": return block.children.length > 0;
+		case "bulletList": return block.items.some((item) => item.children.some((paragraph) => paragraph.children.length > 0));
+		case "image": return true;
+		case "infoBox": return true;
+		case "separator": return true;
+		case "blockExtension": return true;
+	}
+}
+function hasRenderableRichTextContent(content) {
+	return content.doc.blocks.some((block) => hasRenderableRichTextBlock(block));
+}
+function createRichTextContent(text = "") {
+	return {
+		type: "richText",
+		version: 1,
+		doc: {
+			type: "doc",
+			blocks: [{
+				type: "paragraph",
+				children: text.length > 0 ? text.split("\n").flatMap((line, index) => {
+					const parts = [];
+					if (index > 0) parts.push({ type: "lineBreak" });
+					if (line.length > 0) parts.push({
+						type: "text",
+						text: line
+					});
+					return parts;
+				}) : []
+			}]
+		}
+	};
+}
+function getPlainTextFromLinkChildren(children) {
+	return children.map((inline) => {
+		switch (inline.type) {
+			case "text": return inline.text;
+			case "template": return `{${inline.key}}`;
+			case "lineBreak": return "\n";
+		}
+	}).join("");
+}
+function getPlainTextFromInlineNodes(inlines) {
+	return inlines.map((inline) => {
+		switch (inline.type) {
+			case "text": return inline.text;
+			case "template": return `{${inline.key}}`;
+			case "link": return getPlainTextFromLinkChildren(inline.children);
+			case "lineBreak": return "\n";
+			case "inlineExtension": return "";
+		}
+	}).join("");
+}
+function getPlainTextFromParagraphs(paragraphs) {
+	return paragraphs.map((paragraph) => getPlainTextFromInlineNodes(paragraph.children)).join("\n");
+}
+function getPlainTextFromBlock(block) {
+	switch (block.type) {
+		case "paragraph": return getPlainTextFromInlineNodes(block.children);
+		case "heading": return getPlainTextFromInlineNodes(block.children);
+		case "bulletList": return block.items.map((item) => getPlainTextFromParagraphs(item.children)).join("\n");
+		case "image": {
+			const captionText = block.caption ? getPlainTextFromParagraphs(block.caption) : "";
+			return [block.alt ?? "", captionText].filter(Boolean).join("\n");
+		}
+		case "infoBox": return [block.title ? getPlainTextFromInlineNodes(block.title) : "", getPlainTextFromParagraphs(block.children)].filter(Boolean).join("\n");
+		case "separator": return "";
+		case "blockExtension": return "";
+	}
+}
+function getPlainTextFromRichTextContent(content) {
+	return content.doc.blocks.map((block) => getPlainTextFromBlock(block)).filter((text) => text.length > 0).join("\n").trim();
+}
+function getContentPlainText(content) {
+	if (!content) return "";
+	if (content.type !== "richText") return content.content ?? "";
+	return getPlainTextFromRichTextContent(content);
+}
+function isContentEmpty(content) {
+	if (!content) return true;
+	if (content.type !== "richText") return content.content.trim().length === 0;
+	return !hasRenderableRichTextContent(content);
+}
+function getAssetUsagesFromContent(content) {
+	if (!content || content.type !== "richText") return [];
+	const usages = [];
+	content.doc.blocks.forEach((block, blockIndex) => {
+		if (block.type === "image" && block.source.type === "asset") usages.push({
+			assetId: block.source.assetId,
+			blockIndex
+		});
+	});
+	return usages;
+}
+//#endregion
+//#region src/survey/survey.ts
+var Survey = class Survey {
+	pluginRegistry;
+	maxItemsPerPage;
+	metadata;
+	surveyItems = /* @__PURE__ */ new Map();
+	_templateValues = /* @__PURE__ */ new Map();
+	_assets = /* @__PURE__ */ new Map();
+	_translations;
+	constructor(pluginRegistry) {
+		this.pluginRegistry = pluginRegistry;
+		this._translations = new SurveyTranslations();
+	}
+	/**
+	* Derive a read revision from an already detached view. Editable core instances
+	* are never reused: the changed item is reconstructed from owned raw data.
+	* Other detached items are unchanged by translation publication.
+	*/
+	withItemTranslationContent(rawItem, locale, contentKey, content) {
+		const next = new Survey(this.pluginRegistry);
+		next.surveyItems = new Map(this.surveyItems);
+		next.surveyItems.set(rawItem.id, next.createItemFromRaw(structuredCloneMethod(rawItem)));
+		next._translations = this.translations.fork();
+		next._translations.setItemTranslationContent(rawItem.id, locale, contentKey, content);
+		next._assets = this._assets;
+		next._templateValues = this._templateValues;
+		next.metadata = this.metadata;
+		next.maxItemsPerPage = this.maxItemsPerPage;
+		return next;
+	}
+	/** Plugin registry used when parsing items. Exposed for editors that re-parse without their own registry. */
+	getPluginRegistry() {
+		return this.pluginRegistry;
+	}
+	/**
+	* Create a survey item from raw JSON data.
+	* Uses the survey's plugin registry when available.
+	*/
+	createItemFromRaw(rawItem) {
+		return createItemCore(rawItem, this.pluginRegistry);
+	}
+	/**
+	* Create a minimal blank survey with a root group and one empty page.
+	*/
+	static createBlankSurvey(pluginRegistry, surveyKey) {
+		const rawSurvey = {
+			$schema: CURRENT_SURVEY_SCHEMA,
+			schemaVersion: 2,
+			metadata: { surveyKey: surveyKey ?? "survey" },
+			surveyItems: [{
+				id: generateId(),
+				itemType: "group",
+				config: {
+					isRoot: true,
+					items: [],
+					shuffleItems: false
+				}
+			}]
+		};
+		return Survey.fromJson(rawSurvey, pluginRegistry);
+	}
+	static fromJson(json, pluginRegistry) {
+		const survey = new Survey(pluginRegistry);
+		const rawSurvey = json;
+		if (rawSurvey.$schema !== "https://github.com/case-framework/case-survey-toolkit/packages/survey-core/schemas/survey-schema.json") throw new Error(`Unsupported survey schema: ${rawSurvey.$schema}`);
+		if (rawSurvey.schemaVersion !== 2) throw new Error(`Unsupported survey format version: ${String(rawSurvey.schemaVersion)}. Recreate this draft using the current schema.`);
+		survey.surveyItems = /* @__PURE__ */ new Map();
+		if (!rawSurvey.surveyItems || rawSurvey.surveyItems.length === 0) throw new Error("surveyItems is required");
+		rawSurvey.surveyItems.forEach((item) => {
+			if (survey.surveyItems.has(item.id)) throw new Error(`Duplicate survey item identity: ${item.id}`);
+			const surveyItem = createItemCore(item, pluginRegistry);
+			survey.surveyItems.set(surveyItem.id, surveyItem);
+		});
+		if (rawSurvey.templateValues) survey._templateValues = deserializeTemplateValues(rawSurvey.templateValues);
+		if (rawSurvey.assets) survey._assets = new Map(Object.entries(rawSurvey.assets));
+		survey._translations = new SurveyTranslations(rawSurvey.translations);
+		if (rawSurvey.maxItemsPerPage) survey.maxItemsPerPage = rawSurvey.maxItemsPerPage;
+		if (rawSurvey.metadata) survey.metadata = rawSurvey.metadata;
+		return survey;
+	}
+	serialize() {
+		const json = {
+			$schema: CURRENT_SURVEY_SCHEMA,
+			schemaVersion: 2,
+			surveyItems: Array.from(this.surveyItems.values()).map((item) => item.rawItem)
+		};
+		json.translations = this._translations?.serialize();
+		if (this._templateValues) json.templateValues = serializeTemplateValues(this._templateValues);
+		if (this._assets && this._assets.size > 0) json.assets = Object.fromEntries(this._assets.entries());
+		if (this.maxItemsPerPage) json.maxItemsPerPage = this.maxItemsPerPage;
+		if (this.metadata) json.metadata = this.metadata;
+		return json;
+	}
+	get surveyKey() {
+		return this.metadata?.surveyKey;
+	}
+	resolveItemEditorName(itemId, locale = this.locales[0] ?? "en") {
+		const item = this.surveyItems.get(itemId);
+		if (!item) return getCompositionLabel([], locale);
+		const explicit = item.metadata.itemLabel?.trim();
+		if (explicit) return explicit;
+		const translations = this.getItemTranslations(itemId);
+		for (const key of item.getOutlineContentKeys()) {
+			const content = translations?.getContent(locale, key, this.locales[0]);
+			if (content) {
+				const summary = getContentPlainText(content).replace(/\s+/g, " ").trim();
+				if (summary) return summary;
+			}
+		}
+		return getCompositionLabel(item.getCompositionTypes(), locale);
+	}
+	get locales() {
+		return this._translations?.locales || [];
+	}
+	get rootItem() {
+		return Array.from(this.surveyItems.values()).find((item) => item instanceof GroupItemCore && item.isRoot);
+	}
+	get itemOutline() {
+		return [...this.surveyItems.keys()].map((id) => this.getItemDisplayPath(id));
+	}
+	getItemPath(itemId) {
+		const item = this.surveyItems.get(itemId);
+		if (!item) throw new Error(`Item ${itemId} not found`);
+		if (item instanceof GroupItemCore && item.isRoot()) return [];
+		const parentItem = this.getParentItem(itemId);
+		if (!parentItem) throw new Error(`Parent item for ${itemId} not found`);
+		return [...this.getItemPath(parentItem.id), parentItem.id];
+	}
+	getItemDisplayPath(itemId, locale = this.locales[0] ?? "en") {
+		if (!this.surveyItems.has(itemId)) return;
+		const path = this.getItemPath(itemId);
+		const name = this.resolveItemEditorName(itemId, locale);
+		const namePath = path.map((id) => this.resolveItemEditorName(id, locale));
+		return {
+			itemId,
+			name,
+			path,
+			namePath,
+			breadcrumb: [...namePath, name].join(" / "),
+			parentBreadcrumb: namePath.join(" / ")
+		};
+	}
+	getParentItem(itemId) {
+		const item = this.surveyItems.get(itemId);
+		if (!item) throw new Error(`Item ${itemId} not found`);
+		if (item instanceof GroupItemCore && item.isRoot()) return;
+		const parentItem = Array.from(this.surveyItems.values()).find((item) => item instanceof GroupItemCore && item.config.items?.includes(itemId));
+		if (!parentItem) return;
+		return parentItem;
+	}
+	getChildrenItems(parentId) {
+		const parentItem = this.surveyItems.get(parentId);
+		if (!parentItem || !(parentItem instanceof GroupItemCore)) return [];
+		return parentItem.config.items?.map((id) => this.surveyItems.get(id))?.filter((item) => item !== void 0) || [];
+	}
+	getSiblings(itemId) {
+		if (!this.surveyItems.get(itemId)) return [];
+		return this.getParentItem(itemId)?.items?.map((id) => this.surveyItems.get(id))?.filter((item) => item !== void 0) || [];
+	}
+	get translations() {
+		if (!this._translations) this._translations = new SurveyTranslations();
+		return this._translations;
+	}
+	getItemTranslations(id) {
+		if (!this.surveyItems.get(id)) throw new Error(`Item ${id} not found`);
+		return this._translations?.getItemTranslations(id);
+	}
+	getTemplateValue(templateValueKey) {
+		return this._templateValues?.get(templateValueKey);
+	}
+	setTemplateValue(templateValueKey, templateValue) {
+		if (!this._templateValues) this._templateValues = /* @__PURE__ */ new Map();
+		this._templateValues?.set(templateValueKey, templateValue);
+	}
+	deleteTemplateValue(templateValueKey) {
+		this._templateValues?.delete(templateValueKey);
+	}
+	getTemplateValueKeys() {
+		return Array.from(this._templateValues?.keys() || []);
+	}
+	getAsset(assetId) {
+		const asset = this._assets?.get(assetId);
+		return asset ? structuredCloneMethod(asset) : void 0;
+	}
+	setAsset(assetId, asset) {
+		if (!this._assets) this._assets = /* @__PURE__ */ new Map();
+		this._assets.set(assetId, structuredCloneMethod(asset));
+	}
+	deleteAsset(assetId) {
+		this._assets?.delete(assetId);
+	}
+	hasAsset(assetId) {
+		return this._assets?.has(assetId) ?? false;
+	}
+	getAssetIds() {
+		return Array.from(this._assets?.keys() || []);
+	}
+	getAssets() {
+		return new Map(Array.from(this._assets?.entries() || []).map(([assetId, asset]) => [assetId, structuredCloneMethod(asset)]));
+	}
+	getAssetUsages(filterAssetId) {
+		const usages = [];
+		const pushContentUsages = (content, usageScope, contentKey, locale, itemId) => {
+			for (const usage of getAssetUsagesFromContent(content)) {
+				if (filterAssetId && usage.assetId !== filterAssetId) continue;
+				usages.push({
+					assetId: usage.assetId,
+					itemId,
+					locale,
+					contentKey,
+					usageScope,
+					blockIndex: usage.blockIndex
+				});
+			}
+		};
+		const serializedTranslations = this._translations?.serialize();
+		const rootItemId = this.rootItem?.id;
+		if (!serializedTranslations) return usages;
+		for (const [locale, localeTranslations] of Object.entries(serializedTranslations)) {
+			for (const [contentKey, content] of Object.entries(localeTranslations.surveyCardContent || {})) pushContentUsages(content, "surveyCard", contentKey, locale, rootItemId);
+			for (const [contentKey, content] of Object.entries(localeTranslations.navigationContent || {})) pushContentUsages(content, "navigation", contentKey, locale, rootItemId);
+			for (const [contentKey, content] of Object.entries(localeTranslations.validationMessages || {})) pushContentUsages(content, "validationMessages", contentKey, locale, rootItemId);
+			for (const [itemId, itemTranslations] of Object.entries(localeTranslations.itemTranslations || {})) for (const [contentKey, content] of Object.entries(itemTranslations || {})) pushContentUsages(content, "itemTranslation", contentKey, locale, itemId);
+		}
+		return usages;
+	}
+	getAvailableResponseValueSlots(byType) {
+		let valueRefs = {};
+		for (const item of this.surveyItems.values()) valueRefs = {
+			...valueRefs,
+			...item.getAvailableResponseValueSlots(byType)
+		};
+		return valueRefs;
+	}
+	getResponseSlotDefinitions() {
+		return Array.from(this.surveyItems.values()).map((item) => ({
+			itemId: item.id,
+			slots: item.getResponseSlotDefinitions().map((slot) => ({
+				...slot,
+				exportSettings: item.rawItem.responseSettings?.[slot.slotId]
+			}))
+		}));
+	}
+	/** Compile a detached index from item declarations; diagnostics retain incomplete drafts. */
+	getResponseSlotRegistry() {
+		const declarations = this.getResponseSlotDefinitions().map(({ itemId, slots }) => ({
+			itemId,
+			slots: slots.map((slot) => ({
+				...slot,
+				...slot.referenceValueLabelKeys ? { referenceValueLabels: Object.fromEntries(this.locales.map((locale) => [locale, Object.fromEntries(Object.entries(slot.referenceValueLabelKeys).map(([id, key]) => [id, getContentPlainText(this.getItemTranslations(itemId)?.getContent(locale, key, this.locales[0]))]))])) } : {}
+			}))
+		}));
+		const registry = new ResponseSlotRegistry(declarations);
+		for (const { itemId, slots } of declarations) for (const slotId of Object.keys(this.surveyItems.get(itemId).rawItem.responseSettings ?? {})) if (!slots.some((slot) => slot.slotId === slotId)) registry.diagnostics.push({
+			code: "unknown-slot",
+			slotId,
+			itemId,
+			message: `Response settings reference an unknown variable "${slotId}" on item "${itemId}".`
+		});
+		return registry;
+	}
+	/** One typed declaration path for editor, runtime and export integrity checks. */
+	getExpressionResponseSlots() {
+		return this.getResponseSlotRegistry().definitions.flatMap((slot) => ["get", "isDefined"].map((method) => ({
+			ref: JSON.stringify([slot.slotId, method]),
+			itemId: slot.itemId,
+			valueType: method === "get" ? slot.valueType : ValueType.boolean,
+			...method === "get" && slot.allowedValues ? { allowedValues: slot.allowedValues } : {}
+		})));
+	}
+	getExpressionReferenceDiagnostics() {
+		return analyzeSurveyExpressionReferences({
+			survey: this.serialize(),
+			responseSlots: this.getExpressionResponseSlots()
+		});
+	}
+	getBlockingExpressionIssues() {
+		return this.getExpressionReferenceDiagnostics().filter(isBlockingSurveyExpressionReferenceDiagnostic).map((diagnostic) => diagnostic.message);
+	}
+	/**
+	* Get all reference usages for the survey
+	* @param forItemId - optional item id to filter usages for a specific item and its children (if not provided, all usages are returned)
+	* @returns all reference usages for the survey (or for a specific item and its children)
+	*/
+	getReferenceUsages(forItemId) {
+		const usages = [];
+		for (const item of this.surveyItems.values()) {
+			if (forItemId && item.id !== forItemId && !this.isDescendantOf(item.id, forItemId)) continue;
+			usages.push(...item.getReferenceUsages());
+		}
+		if (this._templateValues) for (const [templateValueKey, templateValue] of this._templateValues.entries()) for (const ref of templateValue.expression?.responseVariableRefs || []) usages.push({
+			itemId: templateValueKey,
+			usageType: "templateValues",
+			valueReference: ref
+		});
+		return usages;
+	}
+	isDescendantOf(targetId, ancestorId) {
+		if (targetId === ancestorId) return true;
+		return this.getItemPath(targetId).includes(ancestorId);
+	}
+};
+//#endregion
+//#region src/response-exporter/column-id.ts
+function encodeExportColumnId(identity) {
+	return JSON.stringify(identity);
+}
+function decodeExportColumnId(value) {
+	const tuple = JSON.parse(value);
+	if (!Array.isArray(tuple) || tuple.some((part) => typeof part !== "string") || !(tuple.length === 2 && (tuple[0] === "meta" || tuple[0] === "context") || tuple[0] === "response" && (tuple.length === 3 && tuple[2] === "value" || tuple.length === 4 && tuple[2] === "option"))) throw new Error(`Invalid export column ID: ${value}`);
+	if (JSON.stringify(tuple) !== value) throw new Error("Export column IDs must use the canonical JSON tuple encoding");
+	return tuple;
+}
+//#endregion
+//#region src/response-exporter/types.ts
+/** Meta column keys in fixed order (common attributes first). */
+const META_COLUMN_ORDER = [
+	"submittedAt",
+	"participantId",
+	"responseId",
+	"sourceId"
+];
+/** Built-in transform modes for slot export. */
+const SlotTransformMode = {
+	default: "default",
+	mask: "mask",
+	dateFormat: "dateFormat"
+};
+const EXPORTER_PROFILE_SCHEMA_VERSION = 1;
+/** Source of an export column. */
+const ExportColumnSource = {
+	meta: "meta",
+	context: "context",
+	response: "response"
+};
+//#endregion
+//#region src/response-exporter/slot-formatter.ts
+/** Default transform config when no profile override. */
+const DEFAULT_TRANSFORM = { mode: SlotTransformMode.default };
+/**
+* Export a single response slot to a string. Pure function for unit testing.
+* Uses default formatting by ValueType unless overridden by transformConfig.
+*/
+function exportSingleResponseSlot(params) {
+	const { value, valueType, transformConfig } = params;
+	if (value === void 0 || value === null) return "";
+	const mode = transformConfig.mode;
+	if (mode === SlotTransformMode.mask) return maskValue(value, transformConfig.maskChar ?? "***");
+	if (mode === SlotTransformMode.dateFormat && (valueType === ValueType.date || valueType === ValueType.dateArray)) return formatDateValue(value, transformConfig.dateFormat?.pattern ?? "yyyy-MM-dd");
+	if (value.type === ValueType.reference || value.type === ValueType.referenceArray) {
+		const keys = transformConfig.categorical === "labels" ? transformConfig.optionLabels : transformConfig.optionCodes ?? params.referenceValueKeys;
+		const exportReference = (id) => {
+			if (transformConfig.categorical === "ids") return id;
+			const key = keys && Object.hasOwn(keys, id) ? keys[id] : void 0;
+			if (typeof key !== "string" || !key.trim()) throw new Error(`Missing categorical export mapping for option "${id}"`);
+			return key.trim();
+		};
+		return value.type === ValueType.reference ? exportReference(value.value) : JSON.stringify(value.value.map(exportReference));
+	}
+	return formatDefault(value);
+}
+const BooleanExportValues = {
+	TRUE: "TRUE",
+	FALSE: "FALSE"
+};
+function formatDefault(value) {
+	switch (value.type) {
+		case ValueType.string: return String(value.value);
+		case ValueType.reference: return String(value.value);
+		case ValueType.boolean: return value.value ? BooleanExportValues.TRUE : BooleanExportValues.FALSE;
+		case ValueType.number: return value.precision === NumberPrecision.int ? String(Math.floor(value.value)) : String(value.value);
+		case ValueType.date: return value.value;
+		case ValueType.duration: {
+			const d = value;
+			return `${d.precision === NumberPrecision.int ? Math.floor(d.value) : d.value} ${d.unit}`;
+		}
+		case ValueType.stringArray: return value.value.join("; ");
+		case ValueType.referenceArray: return value.value.join("; ");
+		case ValueType.numberArray: {
+			const arr = value.value;
+			const prec = value.precision;
+			const fmt = (n) => prec === NumberPrecision.int ? Math.floor(n) : n;
+			return arr.map(fmt).join("; ");
+		}
+		case ValueType.dateArray: return value.value.join("; ");
+		case ValueType.durationArray: {
+			const d = value;
+			const prec = d.precision === NumberPrecision.int;
+			const fmt = (n) => prec ? Math.floor(n) : n;
+			return d.value.map((v) => `${fmt(v)} ${d.unit}`).join("; ");
+		}
+		default: return String(value.value ?? "");
+	}
+}
+function formatDateValue(value, pattern) {
+	if (value.type === ValueType.date) return formatCalendarDate(value.value, pattern);
+	if (value.type === ValueType.dateArray) return value.value.map((date) => formatCalendarDate(date, pattern)).join("; ");
+	return formatDefault(value);
+}
+function maskValue(value, maskChar) {
+	return valueToString(value) ? maskChar : "";
+}
+function valueToString(value) {
+	switch (value.type) {
+		case ValueType.string:
+		case ValueType.reference: return String(value.value);
+		case ValueType.stringArray:
+		case ValueType.referenceArray: return value.value.join(" ");
+		default: return String(value.value ?? "");
+	}
+}
+//#endregion
+//#region src/response-exporter/projection.ts
+function optionIds(slot) {
+	return [...new Set((slot.allowedValues ?? []).flatMap((value) => value.type === ValueType.reference ? [value.value] : value.type === ValueType.referenceArray ? value.value : []))];
+}
+function optionMapping(slot, config) {
+	const ids = optionIds(slot);
+	const encoding = config.categorical ?? "codes";
+	const mapping = encoding === "ids" ? Object.fromEntries(ids.map((id) => [id, id])) : encoding === "labels" ? config.optionLabels ?? slot.referenceValueLabels?.[config.locale ?? "en"] ?? {} : config.optionCodes ?? slot.referenceValueKeys ?? {};
+	const used = /* @__PURE__ */ new Set();
+	for (const id of ids) {
+		if (typeof mapping[id] !== "string" || !mapping[id].trim()) throw new Error(`Variable "${slot.variableName}" has no ${encoding} mapping for option "${id}"`);
+		if (used.has(mapping[id])) throw new Error(`Variable "${slot.variableName}" has ambiguous ${encoding} mapping "${mapping[id]}"`);
+		used.add(mapping[id]);
+	}
+	for (const id of [...Object.keys(config.optionCodes ?? {}), ...Object.keys(config.optionLabels ?? {})]) if (!ids.includes(id)) throw new Error(`Mapping for "${slot.variableName}" contains unknown option "${id}"`);
+	return mapping;
+}
+/** Compile every declared role before applying inclusion settings. */
+function projectSlot(slot, config, allRoles = false) {
+	if (![
+		"default",
+		"mask",
+		"dateFormat"
+	].includes(config.mode)) throw new Error(`Unsupported export transform "${config.mode}"`);
+	if (config.categorical && ![
+		"codes",
+		"labels",
+		"ids"
+	].includes(config.categorical)) throw new Error("Unsupported categorical encoding");
+	if (config.multiple && ![
+		"json",
+		"delimited",
+		"indicators"
+	].includes(config.multiple)) throw new Error("Unsupported multiple-selection encoding");
+	if (config.mode === "dateFormat" && slot.valueType !== "date" && slot.valueType !== "date[]") throw new Error("Date formatting requires a date variable");
+	if (config.mode === "dateFormat") {
+		const pattern = config.dateFormat?.pattern ?? "yyyy-MM-dd";
+		if (!pattern.trim()) throw new Error("Date export pattern cannot be empty");
+		formatCalendarDate("2026-01-15", pattern);
+	}
+	if (config.durationUnit && (!Object.values(DurationUnits).includes(config.durationUnit) || !slot.valueType.startsWith("duration"))) throw new Error("Duration units require a duration variable and a supported unit");
+	if (config.booleanValues && (!config.booleanValues.true || !config.booleanValues.false || config.booleanValues.true === config.booleanValues.false)) throw new Error("Boolean export values must be distinct and nonempty");
+	const categorical = slot.valueType === ValueType.reference || slot.valueType === ValueType.referenceArray;
+	if (config.multiple && slot.valueType !== ValueType.referenceArray) throw new Error(`Multiple-selection encoding requires a reference[] variable: ${slot.variableName}`);
+	if ((config.categorical || config.optionCodes || config.optionLabels) && !categorical) throw new Error(`Categorical encoding requires a categorical variable: ${slot.variableName}`);
+	if (config.booleanValues && slot.valueType !== ValueType.boolean) throw new Error(`Boolean encoding requires a boolean variable: ${slot.variableName}`);
+	if (config.precision !== void 0 && ![
+		"number",
+		"number[]",
+		"duration",
+		"duration[]"
+	].includes(slot.valueType)) throw new Error("Precision requires a numeric or duration variable");
+	if (config.precision !== void 0 && (!Number.isInteger(config.precision) || config.precision < 0 || config.precision > 15)) throw new Error("Precision must be an integer between 0 and 15");
+	if (config.multiple === "delimited" && (!config.delimiter || config.delimiter.includes("\"") || /[\r\n]/.test(config.delimiter))) throw new Error("Delimited selection export requires an explicit delimiter without quotes or line breaks");
+	if (!allRoles && (config.include === false || slot.computed && config.include !== true)) return [];
+	const mapping = categorical && !allRoles ? optionMapping(slot, config) : {};
+	const base = {
+		source: "response",
+		itemId: slot.itemId,
+		slotId: slot.slotId,
+		valueType: slot.valueType
+	};
+	const scalar = {
+		...base,
+		id: encodeExportColumnId([
+			"response",
+			slot.slotId,
+			"value"
+		]),
+		header: slot.variableName
+	};
+	const indicators = () => optionIds(slot).map((optionId) => ({
+		...base,
+		id: encodeExportColumnId([
+			"response",
+			slot.slotId,
+			"option",
+			optionId
+		]),
+		header: `${slot.variableName}_${mapping[optionId] ?? optionId}`,
+		optionId
+	}));
+	return allRoles ? [scalar, ...slot.valueType === ValueType.referenceArray ? indicators() : []] : config.multiple === "indicators" ? indicators() : [scalar];
+}
+function formatProjectedValue(slot, column, value, config) {
+	if (value === void 0) return "";
+	if (config.mode === "mask") return config.maskChar ?? "***";
+	if (value.type === ValueType.reference || value.type === ValueType.referenceArray) {
+		const mapping = optionMapping(slot, config);
+		const values = value.type === ValueType.reference ? [value.value] : value.value;
+		if (values.some((id) => !Object.hasOwn(mapping, id))) throw new Error(`Unmapped option in "${slot.variableName}"`);
+		if (column.optionId) return values.includes(column.optionId) ? "1" : "0";
+		const encoded = values.map((id) => mapping[id]);
+		if (value.type === ValueType.reference) return encoded[0];
+		if (config.multiple === "delimited") return encoded.map((entry) => `"${entry.replaceAll("\"", "\"\"")}"`).join(config.delimiter);
+		return JSON.stringify(encoded);
+	}
+	if (value.type === ValueType.boolean) {
+		const values = config.booleanValues ?? {
+			true: "TRUE",
+			false: "FALSE"
+		};
+		if (!values.true || !values.false || values.true === values.false) throw new Error("Boolean export values must be distinct and nonempty");
+		return value.value ? values.true : values.false;
+	}
+	if (value.type === ValueType.duration || value.type === ValueType.durationArray) {
+		const unit = config.durationUnit ?? "seconds";
+		const seconds = {
+			seconds: 1,
+			minutes: 60,
+			hours: 3600,
+			days: 86400,
+			weeks: 604800
+		};
+		if (unit !== value.unit && (!seconds[unit] || !seconds[value.unit])) throw new Error("Calendar months and years cannot be converted to fixed durations");
+		const convert = (number) => {
+			const n = number * (unit === value.unit ? 1 : seconds[value.unit] / seconds[unit]);
+			return config.precision === void 0 ? String(n) : n.toFixed(config.precision);
+		};
+		return Array.isArray(value.value) ? JSON.stringify(value.value.map(convert)) : convert(value.value);
+	}
+	if (value.type === ValueType.number && config.precision !== void 0) return value.value.toFixed(config.precision);
+	if (value.type === ValueType.numberArray && config.precision !== void 0) return `[${value.value.map((number) => number.toFixed(config.precision)).join(",")}]`;
+	if (Array.isArray(value.value) && config.mode !== "dateFormat") return JSON.stringify(value.value);
+	return exportSingleResponseSlot({
+		value,
+		valueType: slot.valueType,
+		transformConfig: config
+	});
+}
+/** Collect draft diagnostics without stopping at the first unfinished variable. */
+function getDefaultProjectionIssues(survey) {
+	const issues = [];
+	const headers = /* @__PURE__ */ new Set([
+		"submittedAt",
+		"participantId",
+		"responseId",
+		"sourceId"
+	]);
+	for (const slot of survey.getResponseSlotRegistry().definitions) try {
+		for (const column of projectSlot(slot, {
+			mode: "default",
+			...slot.exportSettings
+		})) {
+			if (headers.has(column.header)) issues.push(`Duplicate export column header '${column.header}'`);
+			headers.add(column.header);
+		}
+	} catch (error) {
+		issues.push(error instanceof Error ? error.message : String(error));
+	}
+	return issues;
+}
+/** Fully resolved output semantics, shared by compatibility checks and codebooks. */
+function resolvedSlotEncoding(slot, config) {
+	const encoding = {
+		mode: config.mode,
+		include: config.include ?? !slot.computed
+	};
+	if (config.mode === "mask") return {
+		...encoding,
+		maskChar: config.maskChar ?? "***"
+	};
+	if (config.mode === "dateFormat") encoding.dateFormat = { pattern: config.dateFormat?.pattern ?? "yyyy-MM-dd" };
+	if (slot.valueType === "reference" || slot.valueType === "reference[]") {
+		encoding.categorical = config.categorical ?? "codes";
+		if (encoding.categorical === "labels") {
+			encoding.locale = config.locale ?? "en";
+			encoding.optionLabels = optionMapping(slot, config);
+		} else if (encoding.categorical === "codes") encoding.optionCodes = optionMapping(slot, config);
+		if (slot.valueType === "reference[]") {
+			encoding.multiple = config.multiple ?? "json";
+			if (encoding.multiple === "delimited") encoding.delimiter = config.delimiter;
+		}
+	}
+	if (slot.valueType === "boolean") encoding.booleanValues = config.booleanValues ?? {
+		true: "TRUE",
+		false: "FALSE"
+	};
+	if (slot.valueType.startsWith("duration")) encoding.durationUnit = config.durationUnit ?? "seconds";
+	if (config.precision !== void 0) encoding.precision = config.precision;
+	return structuredClone(encoding);
+}
+//#endregion
+export { const_date as $, responseValuesEqual as $n, CtxPFlagDateEditor as $t, createItemTypeDefinitionRegistry as A, deserializeTemplateValue as An, min as At, deserializeSurveyItemPrefill as B, FunctionExpression as Bn, str_list_contains as Bt, SurveyItemTranslations as C, findIntroducedBlockingExpressionReferenceDiagnostics as Cn, eq as Ct, CURRENT_SURVEY_SCHEMA_VERSION as D, responseValueReferenceIds as Dn, lt as Dt, CURRENT_SURVEY_SCHEMA as E, replaceResponseVariableReferences as En, in_range as Et, isBuiltInItemType as F, ConstExpression as Fn, response_number as Ft, generateId as G, ValueReferenceMethod as Gn, ConstDateEditor as Gt, serializeSurveyItemPrefill as H, ResponseVariableExpression as Hn, AndExpressionEditor as Ht, getCompositionLabel as I, ContextVariableExpression as In, response_number_array as It, shuffleIndices as J, allocateResponseVariableName as Jn, ConstStringArrayEditor as Jt, resolveUniqueItemKey as K, ResponseSlotRegistry as Kn, ConstNumberArrayEditor as Kt, SurveyItemCore as L, ContextVariableType as Ln, response_string as Lt, GroupItemCore as M, serializeTemplateValue as Mn, response_boolean as Mt, PageBreakItemCore as N, serializeTemplateValues as Nn, response_date as Nt, createFullRegistry as O, DATE_FUNCTION_SIGNATURES as On, lte as Ot, builtInItemCoreRegistry as P, ExpressionEvaluator as Pn, response_date_array as Pt, const_boolean as Q, responseValueElements as Qn, CtxLocaleEditor as Qt, SurveyItemPrefillApplyMode as R, Expression as Rn, response_string_array as Rt, isContentEmpty as S, expressionReferenceDiagnosticKey as Sn, date_min as St, validateLocale as T, isBlockingSurveyExpressionReferenceDiagnostic as Tn, gte as Tt, createSeededRandom as U, ReferenceUsageType as Un, ConstBooleanEditor as Ut, prefillTargetsEqual as V, FunctionExpressionNames as Vn, sum as Vt, generateCodingKey as W, ValueReference as Wn, ConstDateArrayEditor as Wt, ReservedSurveyItemTypes as X, suggestResponseVariableName as Xn, CtxCustomExpressionEditor as Xt, structuredCloneMethod as Y, isValidResponseVariableName as Yn, ConstStringEditor as Yt, and as Z, invalidResponseDomainValues as Zn, CtxCustomValueEditor as Zt, getAssetUsagesFromContent as _, SURVEY_EXPRESSION_REFERENCE_DIAGNOSTIC_POLICY as _n, differenceCalendarDates as _r, date_gt as _t, resolvedSlotEncoding as a, GtExpressionEditor as an, SurveyItemResponse as ar, ctx_custom_expression as at, hasRenderableRichTextBlock as b, collectExpressionResponseReferences as bn, date_lte as bt, EXPORTER_PROFILE_SCHEMA_VERSION as c, LtExpressionEditor as cn, ValueType as cr, ctx_pflag_date as ct, SlotTransformMode as d, MinExpressionEditor as dn, addCalendarDate as dr, ctx_pflag_string as dt, CtxPFlagIsDefinedEditor as en, validateResponseSlotValue as er, const_date_array as et, decodeExportColumnId as f, OrExpressionEditor as fn, calendarDateBounds as fr, date_add_days as ft, createRichTextContent as g, SumExpressionEditor as gn, compareCalendarDates as gr, date_eq as gt, ContentType as h, StrListContainsExpressionEditor as hn, calendarDateToLocalDate as hr, date_diff as ht, projectSlot as i, ExpressionEditor as in, ResponseItem as ir, const_string_array as it, toItemTypeDefinitionRegistry as j, deserializeTemplateValues as jn, or as jt, createItemCore as k, TemplateDefTypes as kn, max as kt, ExportColumnSource as l, LteExpressionEditor as ln, assertResponseValue as lr, ctx_pflag_is_defined as lt, Survey as m, StrEqExpressionEditor as mn, calendarDatePrecision as mr, date_add_years as mt, getDefaultProjectionIssues as n, CtxPFlagStringEditor as nn, SURVEY_RESPONSE_SCHEMA_VERSION as nr, const_number_array as nt, DEFAULT_TRANSFORM as o, GteExpressionEditor as on, DurationUnits as or, ctx_custom_value as ot, encodeExportColumnId as p, ResponseVariableEditor as pn, calendarDateFromLocalDate as pr, date_add_months as pt, shuffleArray as q, RESPONSE_VARIABLE_NAME_MAX_LENGTH as qn, ConstNumberEditor as qt, optionMapping as r, EqExpressionEditor as rn, SurveyResponse as rr, const_string as rt, exportSingleResponseSlot as s, InRangeExpressionEditor as sn, NumberPrecision as sr, ctx_locale as st, formatProjectedValue as t, CtxPFlagNumEditor as tn, initValueForType as tr, const_number as tt, META_COLUMN_ORDER as u, MaxExpressionEditor as un, isResponseValue as ur, ctx_pflag_num as ut, getContentPlainText as v, analyzeSurveyExpressionReferences as vn, formatCalendarDate as vr, date_gte as vt, SurveyTranslations as w, findIntroducedExpressionReferenceDiagnosticsIncludingAdvisories as wn, gt as wt, hasRenderableRichTextContent as x, collectSurveyExpressionLocations as xn, date_max as xt, getPlainTextFromRichTextContent as y, collectConfigValueExpressions as yn, isCalendarDate as yr, date_lt as yt, SurveyItemPrefillTargetType as z, ExpressionType as zn, str_eq as zt };
+
+//# sourceMappingURL=projection-Bl6qCinx.mjs.map