@case-framework/survey-core 0.8.0 → 0.9.0

package/build/projection-DrLPFroE.mjs

@@ -0,0 +1,2344 @@
+import { $ as inspectAnnotated, B as ValueType, Ct as calendarDaySchema, Dt as isCalendarDate, Et as formatCalendarDate, G as stringRecord, H as isResponseValue, L as surveyContentSchema, O as itemEditorMetadataSchema, Ot as isCalendarDateUnit, R as DurationUnits, Tt as differenceCalendarDates, U as ownValue, W as setOwnValue, _t as CALENDAR_DATE_UNITS, b as CURRENT_SURVEY_SCHEMA, ct as responseValueSchema, d as validateLocalizationRef, gt as visitExpression, h as getContentPlainText, ht as unreachable, l as readLocalizationContent, m as getAssetUsagesFromContent, mt as transformExpression, ot as expressionSchema, pt as operand, q as annotatedReferences, t as SURVEY_LOCALIZATION_SURFACES, ut as collectExpressionDependencies, vt as addCalendarDate, wt as compareCalendarDates, z as NumberPrecision } from "./localization-1lzNpyFX.mjs";
+import { z } from "zod";
+//#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 ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function generateId() {
+	const length = 10;
+	const timestamp = Date.now();
+	let encodedTimestamp = "";
+	let t = timestamp;
+	const base = 62;
+	while (t > 0) {
+		encodedTimestamp = ID_ALPHABET.charAt(t % base) + encodedTimestamp;
+		t = Math.floor(t / base);
+	}
+	let randomPart = "";
+	for (let i = 0; i < length; i++) randomPart += ID_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/expressions/function-signatures.ts
+const comparison = {
+	min: 2,
+	max: 2,
+	required: [0, 1],
+	returns: "boolean"
+};
+const numericAggregate = {
+	min: 1,
+	required: [],
+	variadicGaps: true,
+	returns: "number"
+};
+const dateAdd = {
+	min: 2,
+	max: 2,
+	required: [0, 1],
+	returns: "date"
+};
+/** The exhaustive signature table for every serialized function name. */
+const FUNCTION_SIGNATURES = {
+	and: {
+		min: 0,
+		required: [],
+		variadicGaps: true,
+		returns: "boolean"
+	},
+	or: {
+		min: 0,
+		required: [],
+		variadicGaps: true,
+		returns: "boolean"
+	},
+	not: {
+		min: 1,
+		max: 1,
+		required: [0],
+		returns: "boolean"
+	},
+	list_contains: comparison,
+	list_count: {
+		min: 1,
+		max: 2,
+		required: [0],
+		returns: "number"
+	},
+	if: {
+		min: 2,
+		max: 3,
+		required: [0, 1],
+		returns: { fromArguments: [1, 2] }
+	},
+	eq: comparison,
+	str_eq: comparison,
+	gt: comparison,
+	gte: comparison,
+	lt: comparison,
+	lte: comparison,
+	in_range: {
+		min: 4,
+		max: 4,
+		required: [
+			0,
+			1,
+			2
+		],
+		returns: "boolean"
+	},
+	sum: numericAggregate,
+	min: numericAggregate,
+	max: numericAggregate,
+	date_eq: comparison,
+	date_gt: comparison,
+	date_gte: comparison,
+	date_lt: comparison,
+	date_lte: comparison,
+	date_add_days: dateAdd,
+	date_add_months: dateAdd,
+	date_add_years: dateAdd,
+	date_diff: {
+		min: 3,
+		max: 3,
+		required: [
+			0,
+			1,
+			2
+		],
+		returns: "number"
+	},
+	date_min: {
+		min: 1,
+		required: [0],
+		returns: "date"
+	},
+	date_max: {
+		min: 1,
+		required: [0],
+		returns: "date"
+	}
+};
+/** Return a diagnostic message when a function has too few or too many arguments. */
+function arityIssue(expression) {
+	const signature = FUNCTION_SIGNATURES[expression.functionName];
+	if (expression.arguments.length < signature.min || signature.max !== void 0 && expression.arguments.length > signature.max) return `${expression.functionName} expects ${signature.max === signature.min ? signature.min : signature.max === void 0 ? `at least ${signature.min}` : `${signature.min} to ${signature.max}`} arguments`;
+}
+//#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/expressions/type-inference.ts
+/** Infer expression result types from node shape and the survey's response slot types. */
+/** Infer a node's result type without evaluating it; unknown slot or context types remain undefined. */
+const inferExpressionReturnType = (expression, responseSlotTypes) => expression && visitExpression(expression, {
+	const: (node) => node.value?.type,
+	responseVariable: (node) => node.variableRef.method === "isDefined" ? "boolean" : ownValue(responseSlotTypes, node.variableRef.slotId),
+	ownerState: () => "boolean",
+	contextVariable: (node) => node.contextType === "locale" ? "string" : node.contextType === "currentDate" ? "date" : node.contextType === "participantFlag" ? node.asType ?? "string" : node.asType,
+	function: (node) => {
+		const { returns } = FUNCTION_SIGNATURES[node.functionName];
+		if (typeof returns === "string") return returns;
+		for (const index of returns.fromArguments) {
+			const type = inferExpressionReturnType(operand(node.arguments, index), responseSlotTypes);
+			if (type) return type;
+		}
+	}
+});
+//#endregion
+//#region src/expressions/validation.ts
+/** Report structural and type problems in authored expressions before graph execution. */
+/** Describe operand type mismatches for one function call using known response slot types. */
+function functionTypeIssues(node, types) {
+	const args = Array.from(node.arguments, (_, index) => inferExpressionReturnType(operand(node.arguments, index), types));
+	const messages = [];
+	const requireType = (index, expected) => {
+		const actual = args[index];
+		if (actual && actual !== expected) messages.push(`${node.functionName} argument ${index + 1} must be ${expected}, got ${actual}.`);
+	};
+	const all = (expected) => args.forEach((_, index) => requireType(index, expected));
+	const same = () => {
+		if (args[0] && args[1] && args[0] !== args[1]) messages.push(`${node.functionName} arguments must have the same type, got ${args[0]} and ${args[1]}.`);
+	};
+	const name = node.functionName;
+	switch (name) {
+		case "and":
+		case "or":
+		case "not":
+			all("boolean");
+			break;
+		case "eq":
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte":
+			same();
+			break;
+		case "str_eq":
+			all("string");
+			break;
+		case "sum":
+		case "min":
+		case "max":
+			all("number");
+			break;
+		case "in_range":
+			[
+				0,
+				1,
+				2
+			].forEach((index) => requireType(index, "number"));
+			requireType(3, "boolean");
+			break;
+		case "date_eq":
+		case "date_gt":
+		case "date_gte":
+		case "date_lt":
+		case "date_lte":
+		case "date_min":
+		case "date_max":
+			all("date");
+			break;
+		case "date_diff": {
+			requireType(0, "date");
+			requireType(1, "date");
+			requireType(2, "string");
+			const unit = operand(node.arguments, 2);
+			if (unit?.type === "const" && unit.value?.type === "string" && !isCalendarDateUnit(unit.value.value)) messages.push(`date_diff argument 3 must be one of ${CALENDAR_DATE_UNITS.join(", ")}, got ${JSON.stringify(unit.value.value)}.`);
+			break;
+		}
+		case "date_add_days":
+		case "date_add_months":
+		case "date_add_years":
+			requireType(0, "date");
+			requireType(1, "number");
+			break;
+		case "list_contains":
+			if (args[0] && args[0] !== "string[]" && args[0] !== "reference[]") messages.push(`list_contains argument 1 must be string[] or reference[], got ${args[0]}. Use eq for single-choice reference responses.`);
+			if (args[0] === "string[]") requireType(1, "string");
+			if (args[0] === "reference[]") requireType(1, "reference");
+			break;
+		case "list_count":
+			if (args[0] && !args[0].endsWith("[]")) messages.push(`list_count argument 1 must be a list, got ${args[0]}.`);
+			if (args[1] && !args[1].endsWith("[]")) messages.push(`list_count argument 2 must be a list, got ${args[1]}.`);
+			else if (args[0]?.endsWith("[]")) requireType(1, args[0]);
+			break;
+		case "if":
+			requireType(0, "boolean");
+			if (args[1] && args[2] && args[1] !== args[2]) messages.push(`if branches must have the same type, got ${args[1]} and ${args[2]}.`);
+			break;
+		default: unreachable(name);
+	}
+	return messages;
+}
+/** Locate malformed function calls and unfinished required operands in an expression tree. */
+function expressionIssues(expression) {
+	const issues = [];
+	transformExpression(expression, {
+		const: (node) => node,
+		responseVariable: (node) => node,
+		ownerState: (node) => node,
+		contextVariable: (node) => node,
+		function: (node, path) => {
+			const signature = FUNCTION_SIGNATURES[node.functionName];
+			const arity = arityIssue(node);
+			if (arity) issues.push({
+				path,
+				message: arity
+			});
+			for (let index = 0; index < node.arguments.length; index++) if (!operand(node.arguments, index) && (signature.required.includes(index) || !signature.variadicGaps && signature.max === void 0)) issues.push({
+				path: [
+					...path,
+					"arguments",
+					index
+				],
+				message: `Operand ${index + 1} of ${node.functionName} is unfinished`
+			});
+			return node;
+		}
+	});
+	return issues;
+}
+/**
+* Locate result, operand, and context key type errors. When option domains are supplied,
+* also flag comparisons with option identities outside the response slot's domain.
+*/
+function expressionTypeIssues(expression, types, expectedReturnType, domains) {
+	const issues = [];
+	transformExpression(expression, {
+		const: (node) => node,
+		responseVariable: (node) => node,
+		ownerState: (node) => node,
+		contextVariable: (node, path) => {
+			const keyType = inferExpressionReturnType(node.key, types);
+			if (keyType && keyType !== "string") issues.push({
+				path: [...path, "key"],
+				message: `Context keys must be string, got ${keyType}.`
+			});
+			return node;
+		},
+		function: (node, path) => {
+			for (const message of functionTypeIssues(node, types)) issues.push({
+				path,
+				message
+			});
+			if ([
+				"eq",
+				"list_contains",
+				"list_count"
+			].includes(node.functionName)) for (const [sourceIndex, valueIndex] of [[0, 1], [1, 0]]) {
+				const source = operand(node.arguments, sourceIndex), value = operand(node.arguments, valueIndex);
+				if (source?.type !== "responseVariable" || source.variableRef.method !== "get" || value?.type !== "const" || !value.value) continue;
+				const allowed = domains?.get(source.variableRef.slotId);
+				for (const invalid of allowed ? invalidResponseDomainValues(value.value, allowed) : []) issues.push({
+					path: [
+						...path,
+						"arguments",
+						valueIndex
+					],
+					message: `Slot '${source.variableRef.slotId}' comparison contains an invalid value ${JSON.stringify(invalid.value)}; use a declared option identity, not an export code.`,
+					kind: "reference"
+				});
+			}
+			return node;
+		}
+	});
+	const actual = inferExpressionReturnType(expression, types);
+	if (expectedReturnType && actual && actual !== expectedReturnType) issues.push({
+		path: [],
+		message: `Must return ${expectedReturnType}, but this expression returns ${actual}.`
+	});
+	return issues;
+}
+//#endregion
+//#region src/expressions/evaluator.ts
+/** Evaluate canonical expressions against current answers, owner state, and session context. */
+/** Raised when evaluation encounters an invalid function call or incompatible runtime value. */
+var ExpressionEvaluationError = class extends Error {};
+const boolean = (value) => ({
+	type: "boolean",
+	value
+});
+const number = (value) => ({
+	type: "number",
+	value
+});
+function evaluatedDates(values) {
+	const dates = [];
+	for (const value of values) {
+		if (value?.type !== "date" || !isCalendarDate(value.value)) return void 0;
+		dates.push(value.value);
+	}
+	return dates.length ? dates : void 0;
+}
+function comparableDates(values) {
+	const dates = evaluatedDates(values);
+	if (!dates || dates.some((date) => date.length !== dates[0].length)) return void 0;
+	return dates;
+}
+/** Evaluate the canonical tree; missing data returns undefined, while invalid calls can throw. */
+function evaluateExpression(node, context) {
+	if (!node) return void 0;
+	const evaluate = (child) => evaluateExpression(child, context);
+	return visitExpression(node, {
+		const: (expression) => expression.value,
+		responseVariable: (expression) => {
+			const answer = context.answer(expression.variableRef.slotId);
+			return expression.variableRef.method === "get" ? answer : boolean(answer !== void 0);
+		},
+		ownerState: (expression) => boolean(context.disabled(expression.targetRef.ownerId)),
+		contextVariable: (expression) => {
+			if (expression.contextType === "locale") return context.locale === void 0 ? void 0 : {
+				type: "string",
+				value: context.locale
+			};
+			if (expression.contextType === "currentDate") return context.currentDate === void 0 ? void 0 : {
+				type: "date",
+				value: context.currentDate
+			};
+			const key = evaluate(expression.key);
+			if (key?.type !== "string") return void 0;
+			if (expression.contextType === "participantFlag") {
+				const value = ownValue(context.participantFlags, key.value);
+				if (expression.asType === "boolean") return boolean(value !== void 0);
+				if (value === void 0) return void 0;
+				if (expression.asType === "number") return Number.isNaN(parseFloat(value)) ? void 0 : number(parseFloat(value));
+				if (expression.asType === "date") return isCalendarDate(value) ? {
+					type: "date",
+					value
+				} : void 0;
+				return {
+					type: "string",
+					value
+				};
+			}
+			const value = ownValue(context.customValues, key.value);
+			if (value && expression.asType && value.type !== expression.asType) throw new ExpressionEvaluationError(`Context value '${key.value}' does not have expected type ${expression.asType}`);
+			return value;
+		},
+		function: (expression) => evaluateFunction(expression, evaluate)
+	});
+}
+function evaluateFunction(expression, evaluate) {
+	const arity = arityIssue(expression);
+	if (arity) throw new ExpressionEvaluationError(arity);
+	const arg = (index) => evaluate(operand(expression.arguments, index));
+	const all = () => Array.from(expression.arguments, (_, index) => arg(index));
+	const name = expression.functionName;
+	switch (name) {
+		case "and": return boolean(expression.arguments.every((_, index) => arg(index)?.value === true));
+		case "or": return boolean(expression.arguments.some((_, index) => arg(index)?.value === true));
+		case "not": {
+			const value = arg(0);
+			if (value === void 0) return void 0;
+			if (value.type !== "boolean") throw new ExpressionEvaluationError("not expects a boolean operand");
+			return boolean(!value.value);
+		}
+		case "list_contains": {
+			const list = arg(0), value = arg(1);
+			if (!list || !value) return boolean(false);
+			if (list.type !== "reference[]" && list.type !== "string[]" || value.type !== "reference" && value.type !== "string") throw new ExpressionEvaluationError("list_contains expects a string/reference array and a string/reference value");
+			return boolean(list.value.includes(value.value));
+		}
+		case "list_count": {
+			const list = arg(0);
+			if (!list) return number(0);
+			if (!Array.isArray(list.value)) throw new ExpressionEvaluationError("list_count expects a list operand");
+			if (!operand(expression.arguments, 1)) return number(list.value.length);
+			const filter = arg(1);
+			if (!filter) return number(0);
+			if (filter.type !== list.type) throw new ExpressionEvaluationError("list_count expects a filter of the list's type");
+			const allowed = responseValueElements(filter);
+			return number(responseValueElements(list).filter((entry) => allowed.some((value) => responseValuesEqual(entry, value))).length);
+		}
+		case "if": {
+			const condition = arg(0);
+			if (condition === void 0) return void 0;
+			if (condition.type !== "boolean") throw new ExpressionEvaluationError("if expects a boolean condition");
+			return arg(condition.value ? 1 : 2);
+		}
+		case "eq": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("eq expects matching operand types");
+			return boolean(left.value === right.value);
+		}
+		case "str_eq": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("str_eq expects matching operand types");
+			if (left.type !== "string") throw new ExpressionEvaluationError("str_eq expects string operands");
+			return boolean(left.value === right.value);
+		}
+		case "gt": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("gt expects matching operand types");
+			return boolean(left.value > right.value);
+		}
+		case "gte": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("gte expects matching operand types");
+			return boolean(left.value >= right.value);
+		}
+		case "lt": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("lt expects matching operand types");
+			return boolean(left.value < right.value);
+		}
+		case "lte": {
+			const left = arg(0), right = arg(1);
+			if (!left || !right) return boolean(false);
+			if (left.type !== right.type) throw new ExpressionEvaluationError("lte expects matching operand types");
+			return boolean(left.value <= right.value);
+		}
+		case "in_range": {
+			const value = arg(0), min = arg(1), max = arg(2), inclusive = arg(3)?.value === true;
+			if (!value || !min || !max) return boolean(false);
+			if (value.type !== "number" || min.type !== "number" || max.type !== "number") throw new ExpressionEvaluationError("in_range expects numeric bounds and value");
+			return boolean(inclusive ? value.value >= min.value && value.value <= max.value : value.value > min.value && value.value < max.value);
+		}
+		case "sum": {
+			let result = 0;
+			for (const value of all()) {
+				if (!value) continue;
+				if (value.type !== "number") throw new ExpressionEvaluationError("sum expects numeric operands");
+				result += value.value;
+			}
+			return number(result);
+		}
+		case "min": {
+			let result = Infinity;
+			for (const value of all()) {
+				if (!value) continue;
+				if (value.type !== "number") throw new ExpressionEvaluationError("min expects numeric operands");
+				result = Math.min(result, value.value);
+			}
+			return number(result);
+		}
+		case "max": {
+			let result = -Infinity;
+			for (const value of all()) {
+				if (!value) continue;
+				if (value.type !== "number") throw new ExpressionEvaluationError("max expects numeric operands");
+				result = Math.max(result, value.value);
+			}
+			return number(result);
+		}
+		case "date_add_days": {
+			const date = arg(0), amount = arg(1);
+			if (date?.type !== "date" || amount?.type !== "number") return void 0;
+			const value = addCalendarDate(date.value, amount.value, "days");
+			return value === void 0 ? void 0 : {
+				type: "date",
+				value
+			};
+		}
+		case "date_add_months": {
+			const date = arg(0), amount = arg(1);
+			if (date?.type !== "date" || amount?.type !== "number") return void 0;
+			const value = addCalendarDate(date.value, amount.value, "months");
+			return value === void 0 ? void 0 : {
+				type: "date",
+				value
+			};
+		}
+		case "date_add_years": {
+			const date = arg(0), amount = arg(1);
+			if (date?.type !== "date" || amount?.type !== "number") return void 0;
+			const value = addCalendarDate(date.value, amount.value, "years");
+			return value === void 0 ? void 0 : {
+				type: "date",
+				value
+			};
+		}
+		case "date_diff": {
+			const a = arg(0), b = arg(1), unit = arg(2);
+			if (unit === void 0) return void 0;
+			if (unit.type !== "string" || !isCalendarDateUnit(unit.value)) throw new ExpressionEvaluationError(`date_diff unit must be one of ${CALENDAR_DATE_UNITS.join(", ")}`);
+			if (a?.type !== "date" || b?.type !== "date") return void 0;
+			const value = differenceCalendarDates(a.value, b.value, unit.value);
+			return value === void 0 ? void 0 : number(value);
+		}
+		case "date_eq": {
+			const dates = evaluatedDates(all());
+			if (!dates) return void 0;
+			return boolean(dates[0] === dates[1]);
+		}
+		case "date_gt": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			const comparison = compareCalendarDates(dates[0], dates[1]);
+			return comparison === void 0 ? void 0 : boolean(comparison > 0);
+		}
+		case "date_gte": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			const comparison = compareCalendarDates(dates[0], dates[1]);
+			return comparison === void 0 ? void 0 : boolean(comparison >= 0);
+		}
+		case "date_lt": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			const comparison = compareCalendarDates(dates[0], dates[1]);
+			return comparison === void 0 ? void 0 : boolean(comparison < 0);
+		}
+		case "date_lte": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			const comparison = compareCalendarDates(dates[0], dates[1]);
+			return comparison === void 0 ? void 0 : boolean(comparison <= 0);
+		}
+		case "date_min": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			return {
+				type: "date",
+				value: dates.reduce((a, b) => a < b ? a : b)
+			};
+		}
+		case "date_max": {
+			const dates = comparableDates(all());
+			if (!dates) return void 0;
+			return {
+				type: "date",
+				value: dates.reduce((a, b) => a > b ? a : b)
+			};
+		}
+		default: return unreachable(name);
+	}
+}
+//#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
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		Object.values(value).forEach(deepFreeze);
+	}
+	return value;
+}
+/** A detached, derived index. Ambiguous identities never resolve to an arbitrary owner. */
+var ResponseSlotRegistry = class {
+	slots = /* @__PURE__ */ new Map();
+	frozenDefinitions;
+	diagnostics = [];
+	constructor(declarations) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const declaration of declarations) for (const definition of declaration.slots) {
+			const slot = deepFreeze(structuredClone({
+				...definition,
+				itemId: declaration.itemId,
+				elementId: declaration.elementId
+			}));
+			if (!slot.slotId.trim() || !slot.elementId.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);
+	}
+	/** Slots are deeply frozen and shared; copy one before deriving a changed definition. */
+	get(slotId) {
+		return this.slots.get(slotId);
+	}
+	get definitions() {
+		return this.frozenDefinitions ??= Object.freeze([...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)) diagnostics.push(...this.validateAnswer(slotId, value));
+		return diagnostics;
+	}
+	/** Value diagnostics only; unrelated registry errors belong to the document. */
+	validateAnswer(slotId, value) {
+		const diagnostics = [];
+		const slot = this.slots.get(slotId);
+		if (!slot) {
+			diagnostics.push({
+				code: "unknown-slot",
+				slotId,
+				message: `Answer references unknown or ambiguous slot "${slotId}".`
+			});
+			return diagnostics;
+		}
+		const issues = slot.computed ? [`Computed slot "${slotId}" cannot contain a stored answer.`] : validateResponseSlotValue(slot, value);
+		if (isResponseValue(value) && value.type === "reference[]" && new Set(value.value).size !== value.value.length) issues.push("A selection cannot contain duplicate options");
+		for (const message of issues) diagnostics.push({
+			code: "invalid-answer",
+			slotId,
+			itemId: slot.itemId,
+			message
+		});
+		return diagnostics;
+	}
+};
+//#endregion
+//#region src/survey/item-display-name.ts
+function getCompositionLabel(types, locale, elementLabels = /* @__PURE__ */ new Map()) {
+	const language = locale.split("-")[0];
+	const labels = {
+		en: {
+			group: "Group",
+			"page-break": "Page break",
+			empty: "Empty item"
+		},
+		nl: {
+			group: "Groep",
+			"page-break": "Pagina-einde",
+			empty: "Leeg item"
+		},
+		de: {
+			group: "Gruppe",
+			"page-break": "Seitenumbruch",
+			empty: "Leeres Element"
+		}
+	};
+	const dictionary = labels[language] ?? labels.en;
+	return [...new Set(types)].map((type) => {
+		const labels = elementLabels.get(type);
+		return labels?.[locale] ?? labels?.[language] ?? labels?.en ?? dictionary[type] ?? type;
+	}).filter(Boolean).join(" + ") || dictionary.empty;
+}
+//#endregion
+//#region src/survey/composition/document.ts
+const isAdmissibleInDraft = (diagnostic) => diagnostic.severity !== "error" || diagnostic.kind === "reference";
+const blockingFor = (diagnostics, admission) => diagnostics.filter((diagnostic) => admission === "draft" ? !isAdmissibleInDraft(diagnostic) : diagnostic.severity === "error");
+/**
+* The survey's languages with the default first, so fallbacks never depend on JSON key order.
+* Hosts that hold unparsed survey JSON use this to pick the same language as the runtime.
+*/
+function surveyLocales(survey) {
+	const locales = Object.keys(survey.translations ?? {});
+	const defaultLocale = survey.defaultLocale;
+	return defaultLocale && locales.includes(defaultLocale) ? [defaultLocale, ...locales.filter((locale) => locale !== defaultLocale)] : locales;
+}
+var DefinitionError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(diagnostics.map((diagnostic) => `${JSON.stringify(diagnostic.path)}: ${diagnostic.message}`).join("\n"));
+		this.diagnostics = diagnostics;
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const key = (path) => JSON.stringify(path);
+const prefix = (parent, child) => parent.length <= child.length && parent.every((part, i) => part === child[i]);
+/** Flow membership and assets stay structural; other references may dangle in a draft. */
+const DRAFT_REFERENCE_TARGETS = /* @__PURE__ */ new Set([
+	"slot",
+	"state",
+	"option",
+	"owner",
+	"item"
+]);
+const isFlowMembership = (path) => path[0] === "surveyItems" && path[2] === "config" && path[3] === "items";
+function validateReferences(references, index, report) {
+	for (const reference of references) {
+		const identity = index.identities.get(reference.id);
+		if (!(reference.target === "slot" ? !!index.slots.get(reference.id) : reference.target === "state" ? [
+			"item",
+			"section",
+			"element",
+			"component"
+		].includes(index.owners.get(reference.id)?.kind ?? "") : reference.target === "owner" ? index.owners.has(reference.id) : reference.target === "option" ? identity?.kind === "component" : identity?.kind === reference.target)) report("invalid-reference", reference.path, `Unknown ${reference.target} reference '${reference.id}'`, "error", DRAFT_REFERENCE_TARGETS.has(reference.target) && !isFlowMembership(reference.path) ? "reference" : void 0);
+	}
+}
+function validateLocalization(data, index, report) {
+	const defaultLocale = data.defaultLocale;
+	if (defaultLocale !== void 0 && !Object.hasOwn(data.translations ?? {}, defaultLocale)) report("default-locale", ["defaultLocale"], `Default locale '${defaultLocale}' has no translations`);
+	const references = [];
+	const collectAssets = (content, path) => {
+		for (const usage of getAssetUsagesFromContent(content)) references.push({
+			target: "asset",
+			id: usage.assetId,
+			path: [
+				...path,
+				"doc",
+				"blocks",
+				usage.blockIndex,
+				"source",
+				"assetId"
+			]
+		});
+	};
+	for (const [locale, translation] of Object.entries(data.translations ?? {})) {
+		const path = ["translations", locale];
+		for (const surface of SURVEY_LOCALIZATION_SURFACES) for (const [key, content] of Object.entries(translation[surface] ?? {})) collectAssets(content, [
+			...path,
+			surface,
+			key
+		]);
+		for (const [id, roles] of Object.entries(translation.content)) {
+			references.push({
+				target: "owner",
+				id,
+				path: [
+					...path,
+					"content",
+					id
+				]
+			});
+			for (const [role, content] of Object.entries(roles)) collectAssets(content, [
+				...path,
+				"content",
+				id,
+				role
+			]);
+		}
+	}
+	validateReferences(references, index, report);
+	for (const [locale, translation] of Object.entries(data.translations ?? {})) for (const [id, roles] of Object.entries(translation.content)) {
+		const owner = index.owners.get(id);
+		for (const role of Object.keys(roles)) if (!owner?.roles.some((entry) => entry.role === role)) report("content-role", [
+			"translations",
+			locale,
+			"content",
+			id,
+			role
+		], `Owner '${id}' does not declare content role '${role}'`);
+	}
+}
+function sameJson(left, right) {
+	if (left === right) return true;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((entry, index) => sameJson(entry, right[index]));
+	if (!isRecord(left) || !isRecord(right)) return false;
+	if (![Object.prototype, null].includes(Object.getPrototypeOf(left)) || ![Object.prototype, null].includes(Object.getPrototypeOf(right))) return false;
+	const keys = Object.keys(left).filter((key) => left[key] !== void 0);
+	return keys.length === Object.keys(right).filter((key) => right[key] !== void 0).length && keys.every((key) => Object.hasOwn(right, key) && sameJson(left[key], right[key]));
+}
+function canReuseStructureIndexes(left, right) {
+	const { translations: _leftTranslations, defaultLocale: _leftDefault, surveyItems: leftItems, ...leftFields } = left;
+	const { translations: _rightTranslations, defaultLocale: _rightDefault, surveyItems: rightItems, ...rightFields } = right;
+	return sameJson(leftFields, rightFields) && leftItems.length === rightItems.length && leftItems.every((item, index) => {
+		const { editorMetadata: _leftMetadata, ...leftItem } = item;
+		const { editorMetadata: _rightMetadata, ...rightItem } = rightItems[index];
+		return sameJson(leftItem, rightItem);
+	});
+}
+/** Fail before recursive parsers encounter cyclic input or exceed the common import budget. */
+function checkDocumentBudget(input, maxNodes = 1e5, maxDepth = 128) {
+	const ancestors = /* @__PURE__ */ new Set();
+	const stack = [{
+		value: input,
+		depth: 0
+	}];
+	let nodes = 0;
+	while (stack.length) {
+		const entry = stack.pop();
+		if (typeof entry.value !== "object" || entry.value === null) continue;
+		if (entry.exit) {
+			ancestors.delete(entry.value);
+			continue;
+		}
+		if (++nodes > maxNodes || entry.depth > maxDepth) throw new Error("Survey exceeds the document node/depth budget");
+		if (ancestors.has(entry.value)) throw new Error("Survey input contains an object cycle");
+		ancestors.add(entry.value);
+		stack.push({
+			...entry,
+			exit: true
+		});
+		for (const value of Object.values(entry.value)) stack.push({
+			value,
+			depth: entry.depth + 1
+		});
+	}
+}
+/** One parsed revision, one owner/identity index, and the existing shared response catalog. */
+var SurveyStructure = class {
+	registry;
+	data;
+	owners = /* @__PURE__ */ new Map();
+	identities = /* @__PURE__ */ new Map();
+	elements = /* @__PURE__ */ new Map();
+	bodies = /* @__PURE__ */ new Map();
+	expressions = [];
+	diagnostics = [];
+	slots;
+	rootId;
+	flowItems;
+	ownerPaths = /* @__PURE__ */ new Map();
+	constructor(data, registry, admission) {
+		this.registry = registry;
+		this.data = data;
+		const report = (code, path, message, severity = "error", kind) => this.diagnostics.push({
+			code,
+			path,
+			message,
+			severity,
+			...kind ? { kind } : {}
+		});
+		const nearestOwner = (path) => {
+			for (let length = path.length; length >= 0; length--) {
+				const owner = this.ownerPaths.get(key(path.slice(0, length)));
+				if (owner) return owner;
+			}
+		};
+		const visits = inspectAnnotated(registry.surveySchema, this.data);
+		const bodies = [];
+		for (const visit of visits) {
+			const { annotation, value, path } = visit;
+			if (annotation.kind === "expression") this.expressions.push({
+				expression: expressionSchema.parse(value),
+				path,
+				...annotation.expectedReturnType ? { expectedReturnType: annotation.expectedReturnType } : {}
+			});
+			if (annotation.kind === "owner") {
+				if (!isRecord(value) || typeof value.id !== "string") throw new Error("Content owners require an annotated id");
+				const parent = nearestOwner(path.slice(0, -1));
+				const owner = {
+					id: value.id,
+					kind: "component",
+					path,
+					roles: annotation.roles,
+					parentId: parent?.id,
+					itemId: parent?.itemId ?? value.id,
+					elementId: value.kind === "element" ? value.id : parent?.elementId,
+					visibility: value.visibility === void 0 ? void 0 : expressionSchema.parse(value.visibility),
+					disabled: value.disabled === void 0 ? void 0 : expressionSchema.parse(value.disabled)
+				};
+				if (!this.owners.has(owner.id)) this.owners.set(owner.id, owner);
+				this.ownerPaths.set(key(path), owner);
+			}
+			if (annotation.kind === "identity") {
+				if (typeof value !== "string") throw new Error("Identity annotations require string values");
+				const owner = nearestOwner(path);
+				if (owner && path.length === owner.path.length + 1 && path.at(-1) === "id") owner.kind = annotation.identity;
+				const identity = {
+					id: value,
+					kind: annotation.identity,
+					ownerId: owner?.id,
+					path,
+					slotAlias: annotation.slotAlias
+				};
+				if (this.identities.has(value)) report("duplicate-identity", path, `Identity '${value}' is declared more than once`);
+				else this.identities.set(value, identity);
+			}
+			if (annotation.kind === "body") {
+				const owner = nearestOwner(path);
+				if (!owner) report("body-owner", path, "A body requires a declared content owner");
+				else if (this.bodies.has(owner.id)) {
+					if (key(this.bodies.get(owner.id).path) !== key(path)) report("body-owner", path, "A content owner can own only one body");
+					else if (annotation.followUp) this.bodies.set(owner.id, {
+						ownerId: owner.id,
+						path,
+						followUp: true
+					});
+				} else this.bodies.set(owner.id, {
+					ownerId: owner.id,
+					path,
+					followUp: annotation.followUp
+				});
+				bodies.push({
+					path,
+					followUp: annotation.followUp,
+					triggerId: annotation.followUp ? owner?.id : void 0
+				});
+			}
+		}
+		for (const owner of this.owners.values()) {
+			let sections = owner.kind === "section" ? 1 : 0;
+			let parent = owner.parentId && this.owners.get(owner.parentId);
+			const seen = /* @__PURE__ */ new Set([owner.id]);
+			while (parent) {
+				if (seen.has(parent.id)) break;
+				seen.add(parent.id);
+				if (parent.kind === "section") sections++;
+				parent = parent.parentId && this.owners.get(parent.parentId);
+			}
+			if (sections > 1) report("section-depth", owner.path, "Only one semantic section is allowed along an ownership path");
+			owner.followUpTriggerId = bodies.filter((body) => body.followUp && prefix(body.path, owner.path)).at(-1)?.triggerId;
+		}
+		for (const body of bodies.filter((candidate) => candidate.followUp)) {
+			if (bodies.some((parent) => parent.followUp && parent !== body && prefix(parent.path, body.path))) report("follow-up-depth", body.path, "Follow-ups cannot contain another follow-up, including an empty body");
+			const trigger = body.triggerId && this.owners.get(body.triggerId);
+			if (!trigger || trigger.kind !== "component") report("follow-up-trigger", body.path, "A follow-up must belong to a declared trigger component");
+			if (bodies.some((other) => other !== body && other.followUp && other.triggerId === body.triggerId)) report("follow-up-trigger", body.path, "A trigger can own only one follow-up body");
+		}
+		const declarations = [];
+		for (const item of this.data.surveyItems) {
+			if (item.itemType !== "content") continue;
+			for (const owner of this.owners.values()) {
+				if (owner.itemId !== item.id || owner.kind !== "element") continue;
+				let raw = this.data;
+				for (const segment of owner.path) if (Array.isArray(raw) && typeof segment === "number") raw = raw[segment];
+				else if (isRecord(raw)) raw = ownValue(raw, String(segment));
+				else throw new Error("Invalid derived element path");
+				const node = registry.elementSchema.parse(raw);
+				const facts = registry.get(node.elementType).inspect(node);
+				this.elements.set(node.id, {
+					node,
+					facts,
+					itemId: item.id,
+					path: owner.path
+				});
+				declarations.push({
+					itemId: item.id,
+					elementId: node.id,
+					slots: facts.slots.map((slot) => ({
+						...slot,
+						exportSettings: ownValue(node.exportSettings, slot.slotId)
+					}))
+				});
+				for (const slot of facts.slots) {
+					const identity = this.identities.get(slot.slotId);
+					const slotOwner = identity?.ownerId ? this.owners.get(identity.ownerId) : void 0;
+					if (!identity || identity.kind !== "slot" && !(identity.kind === "component" && identity.slotAlias) || slotOwner?.elementId !== node.id) report("slot-identity", owner.path, `Slot '${slot.slotId}' must be declared by its element schema (or explicitly alias its own component)`);
+				}
+				const ownComponent = (id) => this.owners.get(id)?.elementId === node.id;
+				const storedSlots = facts.slots.filter((slot) => !slot.computed);
+				const boundSlots = /* @__PURE__ */ new Set();
+				for (const binding of facts.bindings) {
+					if (!storedSlots.some((slot) => slot.slotId === binding.slotId) || boundSlots.has(binding.slotId)) report("slot-binding", owner.path, `Invalid or duplicate input binding '${binding.slotId}'`);
+					boundSlots.add(binding.slotId);
+					for (const id of [
+						binding.controlId,
+						...binding.visibilityIds ?? [],
+						...binding.selection?.options ?? []
+					]) if (!ownComponent(id)) report("component-binding", owner.path, `Component '${id}' does not belong to element '${node.id}'`);
+					if (binding.labelRefs) {
+						if (!binding.labelRefs.length) report("control-label", owner.path, "Declared control labels must not be empty");
+						for (const ref of binding.labelRefs) if (!ownComponent(ref.ownerId) || !this.owners.get(ref.ownerId)?.roles.some(({ role }) => role === ref.role)) report("control-label", owner.path, `Control label ${ref.ownerId}.${ref.role} is not an owned content role`);
+					}
+					if (binding.selection && new Set(binding.selection.options).size !== binding.selection.options.length) report("component-binding", owner.path, "Selection options must be unique");
+				}
+				for (const slot of storedSlots) if (!boundSlots.has(slot.slotId)) report("slot-binding", owner.path, `Stored slot '${slot.slotId}' requires a control binding`);
+				for (const [child, parents] of Object.entries(facts.componentParents)) if (!ownComponent(child) || parents.some((id) => !ownComponent(id))) report("component-binding", owner.path, "Component inheritance must stay within its declaring element");
+				for (const binding of facts.followUps) {
+					if (!ownComponent(binding.triggerId)) report("follow-up-activation", owner.path, "Follow-up trigger must belong to its declaring element");
+					if ("selectionSlotId" in binding && !facts.bindings.some((input) => input.slotId === binding.selectionSlotId && input.selection?.options.includes(binding.triggerId))) report("follow-up-activation", owner.path, "Selection activation requires an option of its declared input");
+				}
+				for (const id of Object.keys(node.exportSettings ?? {})) if (!facts.slots.some((slot) => slot.slotId === id)) report("slot-settings-owner", owner.path, `Settings target '${id}' is not owned by this element`);
+				for (const id of Object.keys(node.prefills ?? {})) if (!facts.slots.some((slot) => slot.slotId === id && !slot.computed)) report("prefill-owner", owner.path, `Prefill target '${id}' is not a writable slot owned by this element`);
+				for (const body of bodies.filter((body) => body.followUp && body.triggerId && this.owners.get(body.triggerId)?.elementId === node.id)) {
+					if (!facts.fullWidth) report("follow-up-width", body.path, "Follow-up presentations require a full row");
+					if (!facts.followUps.some((binding) => binding.triggerId === body.triggerId)) report("follow-up-activation", body.path, "Follow-up activation must be declared by its element domain");
+				}
+				for (const binding of facts.followUps) if (!bodies.some((body) => body.followUp && body.triggerId === binding.triggerId)) report("follow-up-activation", owner.path, "Activation references a trigger without a follow-up body");
+			}
+		}
+		this.slots = new ResponseSlotRegistry(declarations);
+		for (const diagnostic of this.slots.diagnostics) report(diagnostic.code, [], diagnostic.message);
+		for (const element of this.elements.values()) for (const [slotId, candidates] of Object.entries(element.node.prefills ?? {})) candidates.forEach((candidate, index) => {
+			const path = [
+				...element.path,
+				"prefills",
+				slotId,
+				index,
+				"source"
+			];
+			if (candidate.source.type === "static") for (const issue of this.slots.validateAnswer(slotId, candidate.source.value)) report("prefill-domain", [...path, "value"], issue.message);
+			if (candidate.source.type === "templateValue" && !ownValue(this.data.templateValues, candidate.source.key)) report("prefill-template", [...path, "key"], `Unknown prefill template '${candidate.source.key}'`);
+		});
+		validateReferences(annotatedReferences(visits).filter((reference) => reference.path[0] !== "translations"), this, report);
+		validateLocalization(this.data, this, report);
+		const items = new Map(this.data.surveyItems.map((item) => [item.id, item]));
+		this.flowItems = items;
+		const roots = this.data.surveyItems.filter((item) => item.itemType === "group" && item.config.isRoot);
+		this.rootId = roots[0]?.id ?? "";
+		if (roots.length !== 1) report("flow-root", ["surveyItems"], "The survey must contain exactly one root group");
+		const parents = /* @__PURE__ */ new Map();
+		for (const item of items.values()) if (item.itemType === "group") for (const child of item.config.items) {
+			if (parents.has(child)) report("flow-parent", [], `Flow item '${child}' has more than one parent`);
+			parents.set(child, item.id);
+			const owner = this.owners.get(child);
+			if (owner) owner.parentId = item.id;
+		}
+		for (const item of items.values()) {
+			const chain = /* @__PURE__ */ new Set();
+			let id = item.id;
+			while (id) {
+				if (chain.has(id)) {
+					report("flow-cycle", [], `Flow cycle through '${id}'`);
+					break;
+				}
+				chain.add(id);
+				id = parents.get(id);
+			}
+			if (item.id === this.rootId && parents.has(item.id)) report("flow-root", [], "The root group cannot have a parent");
+			if (item.id !== this.rootId && !parents.has(item.id)) report("flow-orphan", [], `Flow item '${item.id}' has no parent`);
+			if (item.itemType === "content") for (const rule of item.config.validationRules ?? []) for (const slotId of rule.targets) {
+				const target = this.slots.get(slotId);
+				if (target && target.itemId !== item.id) report("rule-scope", [], `Rule '${rule.id}' targets a slot outside its content item`);
+			}
+		}
+		if (blockingFor(this.diagnostics, admission).length) throw new DefinitionError(this.diagnostics);
+		for (const value of this.owners.values()) freezeDocument(value);
+		for (const value of this.identities.values()) freezeDocument(value);
+		for (const value of this.elements.values()) freezeDocument(value);
+		for (const value of this.bodies.values()) freezeDocument(value);
+		freezeDocument(this.expressions);
+	}
+};
+function freezeDocument(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		Object.values(value).forEach(freezeDocument);
+	}
+	return value;
+}
+/** A detached revision. Translation publication shares immutable structural indexes. */
+var Survey = class Survey {
+	data;
+	registry;
+	structure;
+	itemIndex;
+	definitionDiagnostics;
+	constructor(data, registry, structure, itemIndex = structure.flowItems, definitionDiagnostics = structure.diagnostics) {
+		this.data = data;
+		this.registry = registry;
+		this.structure = structure;
+		this.itemIndex = itemIndex;
+		this.definitionDiagnostics = definitionDiagnostics;
+		freezeDocument(data);
+	}
+	/**
+	* Parse and index one revision. `previous` lets an unchanged structure share its indexes.
+	* Editors, history, editor files and assistant drafts use `admission: "draft"`; everything that
+	* executes, submits or releases a survey keeps the strict default.
+	*/
+	static parse(input, registry, options = {}) {
+		const { previous, admission = "strict" } = options;
+		checkDocumentBudget(input);
+		const data = registry.surveySchema.parse(input);
+		checkDocumentBudget(data);
+		if (previous?.registry === registry && canReuseStructureIndexes(data, previous.data)) {
+			const diagnostics = previous.structure.diagnostics.filter((diagnostic) => !diagnostic.path.length || diagnostic.path[0] !== "translations" && diagnostic.path[0] !== "defaultLocale");
+			const report = (code, path, message, severity = "error", kind) => diagnostics.push({
+				code,
+				path,
+				message,
+				severity,
+				...kind ? { kind } : {}
+			});
+			validateLocalization(data, previous.structure, report);
+			if (blockingFor(diagnostics, admission).length) throw new DefinitionError(diagnostics);
+			return new Survey(data, registry, previous.structure, new Map(data.surveyItems.map((item) => [item.id, item])), diagnostics);
+		}
+		const structure = new SurveyStructure(data, registry, admission);
+		return new Survey(structure.data, registry, structure);
+	}
+	static blank(registry) {
+		return Survey.parse({
+			$schema: CURRENT_SURVEY_SCHEMA,
+			schemaVersion: 3,
+			surveyItems: [{
+				id: generateId(),
+				itemType: "group",
+				config: {
+					isRoot: true,
+					items: []
+				}
+			}]
+		}, registry);
+	}
+	get rootId() {
+		return this.structure.rootId;
+	}
+	get locales() {
+		return surveyLocales(this.data);
+	}
+	get defaultLocale() {
+		return this.locales[0];
+	}
+	get surveyKey() {
+		return this.data.metadata?.surveyKey;
+	}
+	get metadata() {
+		return this.data.metadata;
+	}
+	get maxItemsPerPage() {
+		return this.data.maxItemsPerPage;
+	}
+	get rootItem() {
+		const root = this.getItem(this.rootId);
+		if (root?.itemType !== "group") throw new Error("Validated survey is missing its root group");
+		return root;
+	}
+	getItemPath(itemId) {
+		if (!this.getItem(itemId)) throw new Error(`Item ${itemId} not found`);
+		const path = [];
+		let parent = this.getParentItem(itemId);
+		while (parent) {
+			path.unshift(parent.id);
+			parent = this.getParentItem(parent.id);
+		}
+		return path;
+	}
+	getChildrenItems(parentId) {
+		const parent = this.getItem(parentId);
+		return parent?.itemType === "group" ? parent.config.items.map((id) => this.getItem(id)) : [];
+	}
+	getSiblings(itemId) {
+		const parent = this.getParentItem(itemId);
+		return parent ? this.getChildrenItems(parent.id) : [];
+	}
+	resolveItemEditorName(itemId, locale = this.locales[0] ?? "en") {
+		const item = this.getItem(itemId);
+		if (!item) return getCompositionLabel([], locale);
+		const explicit = item.metadata?.itemLabel?.trim();
+		if (explicit) return explicit;
+		const content = ownValue(this.data.translations, locale)?.content;
+		const summary = (value) => getContentPlainText(value).replace(/\s+/g, " ").trim();
+		const title = summary(ownValue(content, itemId)?.title);
+		if (title) return title;
+		const elements = [...this.elements.values()].filter((element) => element.itemId === itemId);
+		for (const element of elements) {
+			const roles = ownValue(content, element.node.id);
+			const wording = summary(roles?.label) || summary(roles?.body);
+			if (wording) return wording;
+		}
+		return getCompositionLabel(item.itemType === "content" ? elements.map(({ node }) => node.elementType) : [item.itemType], locale, this.registry.labels);
+	}
+	getItemDisplayPath(itemId, locale = this.locales[0] ?? "en") {
+		if (!this.getItem(itemId)) return void 0;
+		const path = this.getItemPath(itemId), 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(" / ")
+		};
+	}
+	getItemEditorBreadcrumb(itemId, locale = this.locales[0] ?? "en") {
+		const path = this.getItemDisplayPath(itemId, locale);
+		if (!path) return void 0;
+		return [...path.namePath.slice(path.path[0] === this.rootId ? 1 : 0), path.name].join(" / ");
+	}
+	get itemOutline() {
+		const result = [];
+		const visit = (item) => {
+			result.push(this.getItemDisplayPath(item.id));
+			this.getChildrenItems(item.id).forEach(visit);
+		};
+		visit(this.rootItem);
+		return result;
+	}
+	getTemplateValue(key) {
+		return ownValue(this.data.templateValues, key);
+	}
+	getTemplateValueKeys() {
+		return Object.keys(this.data.templateValues ?? {});
+	}
+	getAsset(assetId) {
+		return ownValue(this.data.assets, assetId);
+	}
+	getAssets() {
+		return new Map(Object.entries(this.data.assets ?? {}));
+	}
+	getAssetIds() {
+		return Object.keys(this.data.assets ?? {});
+	}
+	hasAsset(assetId) {
+		return Object.hasOwn(this.data.assets ?? {}, assetId);
+	}
+	getAssetUsages(filterAssetId) {
+		const usages = [];
+		const collect = (content, ref, locale) => {
+			for (const usage of getAssetUsagesFromContent(content)) {
+				if (filterAssetId && usage.assetId !== filterAssetId) continue;
+				const itemId = ref.scope === "content" ? this.owners.get(ref.ownerId).itemId : this.rootId;
+				usages.push({
+					...usage,
+					ref,
+					locale,
+					itemId
+				});
+			}
+		};
+		for (const [locale, translation] of Object.entries(this.data.translations ?? {})) {
+			for (const surface of SURVEY_LOCALIZATION_SURFACES) for (const [contentKey, content] of Object.entries(translation[surface] ?? {})) collect(content, {
+				scope: "survey",
+				surface,
+				contentKey
+			}, locale);
+			for (const [ownerId, roles] of Object.entries(translation.content)) for (const [role, content] of Object.entries(roles)) collect(content, {
+				scope: "content",
+				ownerId,
+				role
+			}, locale);
+		}
+		return usages;
+	}
+	get flowItems() {
+		return this.itemIndex;
+	}
+	get owners() {
+		return this.structure.owners;
+	}
+	get identities() {
+		return this.structure.identities;
+	}
+	get elements() {
+		return this.structure.elements;
+	}
+	get expressions() {
+		return this.structure.expressions;
+	}
+	get bodies() {
+		return this.structure.bodies;
+	}
+	get slots() {
+		return this.structure.slots;
+	}
+	get diagnostics() {
+		return this.definitionDiagnostics;
+	}
+	/**
+	* Document-index errors that prevent running, submitting or releasing this revision. Graph
+	* compilation can add more; use getBrokenReferences for the complete set of broken references.
+	*/
+	get blockingDiagnostics() {
+		return this.definitionDiagnostics.filter((diagnostic) => diagnostic.severity === "error");
+	}
+	getItem(itemId) {
+		return this.itemIndex.get(itemId);
+	}
+	getParentItem(itemId) {
+		if (!this.getItem(itemId)) return void 0;
+		const parentId = this.owners.get(itemId)?.parentId;
+		const parent = parentId ? this.getItem(parentId) : void 0;
+		return parent?.itemType === "group" ? parent : void 0;
+	}
+	/** Inclusive ancestry, as used by the outline's subtree/drop guards. */
+	isDescendantOf(itemId, ancestorId) {
+		let item = this.getItem(itemId);
+		while (item) {
+			if (item.id === ancestorId) return true;
+			item = this.getParentItem(item.id);
+		}
+		return false;
+	}
+	serialize() {
+		return structuredClone(this.data);
+	}
+	/** Editor timestamps cannot affect identity, conditions or responses; share their indexes. */
+	withItemEditorMetadata(updates) {
+		if (!updates.size) return this;
+		const items = new Map(this.itemIndex);
+		for (const [id, metadata] of updates) {
+			const item = items.get(id);
+			if (!item) throw new Error(`Unknown item '${id}'`);
+			items.set(id, {
+				...item,
+				editorMetadata: itemEditorMetadataSchema.parse(metadata)
+			});
+		}
+		const data = {
+			...this.data,
+			surveyItems: this.data.surveyItems.map((item) => items.get(item.id))
+		};
+		checkDocumentBudget(data);
+		return new Survey(data, this.registry, this.structure, items, this.definitionDiagnostics);
+	}
+	/** Sets the default language without rebuilding structural indexes. */
+	withDefaultLocale(locale) {
+		if (!Object.hasOwn(this.data.translations ?? {}, locale)) throw new Error(`Default locale '${locale}' has no translations`);
+		return new Survey({
+			...this.data,
+			defaultLocale: locale
+		}, this.registry, this.structure, this.itemIndex, this.definitionDiagnostics);
+	}
+	withLocalizationContent(ref, locale, content) {
+		validateLocalizationRef(this, ref);
+		if (!locale.trim()) throw new Error("A locale is required");
+		if (content === void 0 && readLocalizationContent(this, ref, locale) === void 0) return this;
+		const translations = { ...this.data.translations };
+		const old = ownValue(translations, locale) ?? { content: {} };
+		const translation = {
+			...old,
+			content: { ...old.content }
+		};
+		let fields;
+		if (ref.scope === "content") {
+			fields = { ...ownValue(translation.content, ref.ownerId) };
+			if (content === void 0) delete fields[ref.role];
+			else setOwnValue(fields, ref.role, content);
+			if (Object.keys(fields).length) setOwnValue(translation.content, ref.ownerId, fields);
+			else delete translation.content[ref.ownerId];
+		} else {
+			fields = { ...translation[ref.surface] };
+			if (content === void 0) delete fields[ref.contentKey];
+			else setOwnValue(fields, ref.contentKey, content);
+			translation[ref.surface] = fields;
+		}
+		setOwnValue(translations, locale, translation);
+		const data = {
+			...this.data,
+			translations
+		};
+		checkDocumentBudget(data);
+		if (content !== void 0) {
+			const parsed = surveyContentSchema.parse(content);
+			for (const asset of getAssetUsagesFromContent(parsed)) if (!ownValue(this.data.assets, asset.assetId)) throw new Error(`Unknown content asset '${asset.assetId}'`);
+			setOwnValue(fields, ref.scope === "content" ? ref.role : ref.contentKey, parsed);
+		}
+		return new Survey(data, this.registry, this.structure, this.itemIndex, this.definitionDiagnostics);
+	}
+};
+//#endregion
+//#region src/engine/survey-state-graph.ts
+const stateNodeKey = (type, id) => JSON.stringify([type, id]);
+/** Compiled dependencies for one survey definition; evaluate against current answers and context. */
+var SurveyStateGraph = class {
+	document;
+	nodes = /* @__PURE__ */ new Map();
+	bindings = /* @__PURE__ */ new Map();
+	initializationOrder;
+	/**
+	* Draft-only problems that did not prevent compilation: dangling references (which evaluate as
+	* missing) and unfinished expressions. Always empty for a strict graph.
+	*/
+	admittedDiagnostics;
+	/**
+	* `strict` (default) compiles only executable definitions. `draft` serves editors and editor
+	* previews: unfinished expressions and dangling references are admitted, and a missing answer or
+	* state target reads as missing (unanswered, not disabled, not visible).
+	*/
+	constructor(document, options = {}) {
+		this.document = document;
+		const draft = options.admission === "draft";
+		if (!draft && document.blockingDiagnostics.length) throw new DefinitionError(document.blockingDiagnostics);
+		const diagnostics = [];
+		const admitted = [];
+		const types = Object.fromEntries(document.slots.definitions.map((slot) => [slot.slotId, slot.valueType]));
+		const domains = new Map(document.slots.definitions.flatMap((slot) => slot.allowedValues ? [[slot.slotId, slot.allowedValues]] : []));
+		for (const { expression, path, expectedReturnType } of document.expressions) for (const issue of expressionTypeIssues(expression, types, expectedReturnType, domains)) diagnostics.push({
+			...issue,
+			path: [...path, ...issue.path],
+			code: "expression-type",
+			severity: "error"
+		});
+		for (const element of document.elements.values()) for (const [slotId, candidates] of Object.entries(element.node.prefills ?? {})) candidates.forEach((candidate, index) => {
+			const target = document.slots.get(slotId);
+			const path = [
+				...element.path,
+				"prefills",
+				slotId,
+				index
+			];
+			const check = (expression, expected, at) => {
+				for (const issue of expressionTypeIssues(expression, types, expected, domains)) diagnostics.push({
+					...issue,
+					path: [...at, ...issue.path],
+					code: "prefill-type",
+					severity: "error"
+				});
+			};
+			if (candidate.when) check(candidate.when, "boolean", [...path, "when"]);
+			if (candidate.source.type === "expression") check(candidate.source.expression, target.valueType, [
+				...path,
+				"source",
+				"expression"
+			]);
+			if (candidate.source.type === "templateValue") {
+				const template = ownValue(document.data.templateValues, candidate.source.key);
+				if (template.returnType !== target.valueType) diagnostics.push({
+					code: "prefill-type",
+					severity: "error",
+					path: [...path, "source"],
+					message: `Prefill template produces ${template.returnType}, but '${slotId}' requires ${target.valueType}`
+				});
+				if (template.expression) check(template.expression, template.type === "formatDate" ? "date" : template.returnType, [
+					"templateValues",
+					candidate.source.key,
+					"expression"
+				]);
+			}
+		});
+		for (const { expression, path } of document.expressions) for (const issue of expressionIssues(expression)) (draft ? admitted : diagnostics).push({
+			...issue,
+			path: [...path, ...issue.path],
+			code: "invalid-expression",
+			severity: "error"
+		});
+		const nodePaths = /* @__PURE__ */ new Map();
+		const slotOwners = new Map(document.slots.definitions.map((slot) => [slot.slotId, slot.elementId]));
+		const add = (type, id, dependencies, evaluate) => {
+			const key = stateNodeKey(type, id);
+			if (this.nodes.has(key)) throw new Error(`Duplicate graph node ${key}`);
+			this.nodes.set(key, {
+				key,
+				dependencies,
+				evaluate
+			});
+			const owner = document.owners.get(id) ?? document.owners.get(slotOwners.get(id) ?? "");
+			if (owner) nodePaths.set(key, owner.path);
+		};
+		const edge = (type, id, reason) => ({
+			key: stateNodeKey(type, id),
+			reason
+		});
+		const dependencies = (expression) => {
+			if (!expression) return [];
+			return collectExpressionDependencies(expression).map((dependency) => dependency.kind === "answer" ? edge("answer", dependency.slotId, "authored answer reference") : edge("disabled", dependency.targetRef.ownerId, "authored state reference"));
+		};
+		const evaluate = (expression, read, input, issues, path) => {
+			try {
+				return evaluateExpression(expression, {
+					...input.context,
+					answer: (id) => {
+						const value = read(stateNodeKey("answer", id));
+						return typeof value === "boolean" ? void 0 : value;
+					},
+					disabled: (id) => read(stateNodeKey("disabled", id)) === true
+				});
+			} catch (error) {
+				if (!(error instanceof ExpressionEvaluationError)) throw error;
+				issues.push({
+					code: "condition-evaluation",
+					path,
+					message: error.message,
+					severity: "warning"
+				});
+				return;
+			}
+		};
+		for (const owner of document.owners.values()) {
+			const domainParents = owner.elementId ? ownValue(document.elements.get(owner.elementId)?.facts.componentParents, owner.id) ?? [] : [];
+			const parents = [...owner.parentId ? [owner.parentId] : [], ...domainParents];
+			const inheritedVisibility = parents.map((id) => edge("visibility", id, "visibility inheritance"));
+			const followUp = owner.followUpTriggerId ? [edge("followUpActive", owner.followUpTriggerId, "follow-up activation")] : [];
+			add("visibility", owner.id, [
+				...inheritedVisibility,
+				...followUp,
+				...dependencies(owner.visibility)
+			], (read, input, issues) => {
+				if ([...inheritedVisibility, ...followUp].some((dependency) => read(dependency.key) !== true)) return false;
+				if (!owner.visibility) return true;
+				const result = evaluate(owner.visibility, read, input, issues, [...owner.path, "visibility"]);
+				if (result && result.type !== "boolean") issues.push({
+					code: "condition-type",
+					path: [...owner.path, "visibility"],
+					message: "Visibility must return a boolean",
+					severity: "warning"
+				});
+				return result?.type === "boolean" && result.value;
+			});
+			const inheritedDisabled = parents.map((id) => edge("disabled", id, "disabled inheritance"));
+			add("disabled", owner.id, [...inheritedDisabled, ...dependencies(owner.disabled)], (read, input, issues) => {
+				const inherited = inheritedDisabled.some((dependency) => read(dependency.key) === true);
+				if (!owner.disabled) return inherited;
+				const result = evaluate(owner.disabled, read, input, issues, [...owner.path, "disabled"]);
+				if (!result || result.type !== "boolean") issues.push({
+					code: "condition-type",
+					path: [...owner.path, "disabled"],
+					message: "Disabled condition did not return a boolean; local disabling is false",
+					severity: "warning"
+				});
+				return inherited || result?.type === "boolean" && result.value;
+			});
+		}
+		for (const element of document.elements.values()) {
+			for (const binding of element.facts.bindings) {
+				if (this.bindings.has(binding.slotId)) throw new Error(`Duplicate control binding for ${binding.slotId}`);
+				this.bindings.set(binding.slotId, binding);
+			}
+			for (const slot of element.facts.slots) {
+				const storedKey = stateNodeKey("storedAnswer", slot.slotId);
+				if (!slot.computed) add("storedAnswer", slot.slotId, [], (_read, input, issues) => {
+					const answer = ownValue(input.answers, slot.slotId);
+					if (answer === void 0) return void 0;
+					const errors = validateResponseSlotValue(slot, answer);
+					if (errors.length) {
+						issues.push({
+							code: "invalid-answer",
+							path: ["answers", slot.slotId],
+							message: errors.join("; "),
+							severity: "error"
+						});
+						return;
+					}
+					return answer;
+				});
+				const binding = this.bindings.get(slot.slotId);
+				const visibility = [binding?.controlId ?? element.node.id, ...binding?.visibilityIds ?? []];
+				const options = binding?.selection?.options ?? [];
+				const sources = slot.computed?.sourceSlotIds ?? [];
+				add("answer", slot.slotId, [
+					...visibility.map((id) => edge("visibility", id, "control applicability")),
+					...options.map((id) => edge("visibility", id, "option projection")),
+					...slot.computed ? sources.map((id) => edge("answer", id, "computed source")) : [{
+						key: storedKey,
+						reason: "retained source"
+					}]
+				], (read) => {
+					if (visibility.some((id) => read(stateNodeKey("visibility", id)) !== true)) return void 0;
+					if (slot.computed) return document.registry.get(element.node.elementType).compute(element.node, slot.slotId, (id) => {
+						const value = read(stateNodeKey("answer", id));
+						return typeof value === "boolean" ? void 0 : value;
+					});
+					const value = read(storedKey);
+					if (typeof value === "boolean" || !value) return void 0;
+					if (!binding?.selection) return value;
+					if (value.type === "reference") return read(stateNodeKey("visibility", value.value)) === true ? value : void 0;
+					if (value.type === "reference[]") {
+						const active = value.value.filter((id) => read(stateNodeKey("visibility", id)) === true);
+						return active.length || value.value.length === 0 ? {
+							...value,
+							value: active
+						} : void 0;
+					}
+				});
+			}
+			for (const followUp of element.facts.followUps) {
+				const trigger = edge("visibility", followUp.triggerId, "trigger visibility");
+				if ("selectionSlotId" in followUp) {
+					const selected = edge("storedAnswer", followUp.selectionSlotId, "per-option checked stored selection");
+					add("followUpActive", followUp.triggerId, [trigger, selected], (read) => {
+						if (read(trigger.key) !== true) return false;
+						const value = read(selected.key);
+						return typeof value !== "boolean" && (value?.type === "reference" ? value.value === followUp.triggerId : value?.type === "reference[]" && value.value.includes(followUp.triggerId));
+					});
+				} else add("followUpActive", followUp.triggerId, [trigger, ...dependencies(followUp.expression)], (read, input, issues) => {
+					if (read(trigger.key) !== true) return false;
+					const result = evaluate(followUp.expression, read, input, issues, element.path);
+					if (result && result.type !== "boolean") issues.push({
+						code: "condition-type",
+						path: element.path,
+						message: "Follow-up activation must return a boolean",
+						severity: "warning"
+					});
+					return result?.type === "boolean" && result.value;
+				});
+			}
+		}
+		if (draft) {
+			const missing = /* @__PURE__ */ new Set();
+			for (const node of this.nodes.values()) for (const dependency of node.dependencies) if (!this.nodes.has(dependency.key)) missing.add(dependency.key);
+			for (const { expression } of document.expressions) for (const dependency of dependencies(expression)) if (!this.nodes.has(dependency.key)) missing.add(dependency.key);
+			for (const key of missing) {
+				const [type] = JSON.parse(key);
+				const value = type === "answer" || type === "storedAnswer" ? void 0 : false;
+				this.nodes.set(key, {
+					key,
+					dependencies: [],
+					evaluate: () => value
+				});
+			}
+		}
+		const visited = /* @__PURE__ */ new Set();
+		const visiting = [];
+		const visit = (key, reason) => {
+			if (visited.has(key)) return;
+			const cycle = visiting.findIndex((node) => node.key === key);
+			if (cycle >= 0) {
+				diagnostics.push({
+					code: "dependency-cycle",
+					path: nodePaths.get(key) ?? [],
+					message: "Dependency cycle: " + [...visiting.slice(cycle), {
+						key,
+						reason
+					}].map((node) => `${node.key} (${node.reason})`).join(" → "),
+					severity: "error"
+				});
+				return;
+			}
+			const node = this.nodes.get(key);
+			if (!node) {
+				diagnostics.push({
+					code: "unknown-dependency",
+					path: [],
+					message: `Unknown dependency ${key} (${reason})`,
+					severity: "error"
+				});
+				return;
+			}
+			visiting.push({
+				key,
+				reason
+			});
+			for (const dependency of node.dependencies) visit(dependency.key, dependency.reason);
+			visiting.pop();
+			visited.add(key);
+		};
+		for (const key of this.nodes.keys()) visit(key, "root");
+		if (draft) for (const diagnostic of diagnostics.splice(0)) (diagnostic.kind === "reference" ? admitted : diagnostics).push(diagnostic);
+		if (diagnostics.length) throw new DefinitionError([...diagnostics, ...admitted]);
+		this.admittedDiagnostics = Object.freeze(admitted);
+		const prefills = new Map([...document.elements.values()].flatMap((element) => Object.entries(element.node.prefills ?? {})));
+		const initialization = [], initialized = /* @__PURE__ */ new Set(), initializing = /* @__PURE__ */ new Set();
+		const initialize = (id) => {
+			if (initialized.has(id)) return;
+			if (initializing.has(id)) throw new DefinitionError([{
+				code: "prefill-cycle",
+				severity: "error",
+				path: [],
+				message: `Prefill dependency cycle through '${id}'`
+			}]);
+			initializing.add(id);
+			for (const candidate of prefills.get(id) ?? []) {
+				const expressions = [candidate.when, candidate.source.type === "expression" ? candidate.source.expression : candidate.source.type === "templateValue" ? ownValue(document.data.templateValues, candidate.source.key)?.expression : void 0];
+				for (const expression of expressions) if (expression) {
+					for (const dependency of this.storedDependencies(expression)) if (prefills.has(dependency)) initialize(dependency);
+				}
+			}
+			initializing.delete(id);
+			initialized.add(id);
+			initialization.push(id);
+		};
+		prefills.forEach((_, id) => initialize(id));
+		this.initializationOrder = Object.freeze(initialization);
+	}
+	evaluate(input) {
+		const cache = /* @__PURE__ */ new Map();
+		const diagnostics = [];
+		const read = (key) => {
+			if (cache.has(key)) return cache.get(key);
+			const node = this.nodes.get(key);
+			if (!node) throw new Error(`Unknown response graph node ${key}`);
+			const result = node.evaluate((dependency) => {
+				if (!node.dependencies.some((edge) => edge.key === dependency)) throw new Error(`Undeclared domain dependency ${key} → ${dependency}`);
+				return read(dependency);
+			}, input, diagnostics);
+			cache.set(key, result);
+			return result;
+		};
+		const answer = (id) => {
+			const value = read(stateNodeKey("answer", id));
+			return typeof value === "boolean" ? void 0 : value;
+		};
+		return {
+			answer,
+			stored: (id) => {
+				const value = read(stateNodeKey("storedAnswer", id));
+				return typeof value === "boolean" ? void 0 : value;
+			},
+			visible: (id) => read(stateNodeKey("visibility", id)) === true,
+			disabled: (id) => read(stateNodeKey("disabled", id)) === true,
+			followUpActive: (id) => read(stateNodeKey("followUpActive", id)) === true,
+			activeAnswers: () => Object.fromEntries(this.document.slots.definitions.flatMap((slot) => {
+				const value = answer(slot.slotId);
+				return value === void 0 || slot.computed ? [] : [[slot.slotId, value]];
+			})),
+			get diagnostics() {
+				return diagnostics.map((issue) => ({
+					...issue,
+					path: [...issue.path]
+				}));
+			}
+		};
+	}
+	storedDependencies(expression) {
+		const result = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (key) => {
+			if (visited.has(key)) return;
+			visited.add(key);
+			const [type, id] = JSON.parse(key);
+			if (type === "storedAnswer") result.add(id);
+			const node = this.nodes.get(key);
+			if (!node) throw new Error(`Unknown dependency ${key}`);
+			node.dependencies.forEach((edge) => visit(edge.key));
+		};
+		collectExpressionDependencies(expression).forEach((ref) => visit(ref.kind === "answer" ? stateNodeKey("answer", ref.slotId) : stateNodeKey("disabled", ref.targetRef.ownerId)));
+		return result;
+	}
+};
+/** The same mechanical permissions power controls, batch writes, and validation eligibility. */
+function canWriteSelection(binding, before, after, snapshot) {
+	if (!snapshot.visible(binding.controlId) || snapshot.disabled(binding.controlId) || binding.visibilityIds?.some((id) => !snapshot.visible(id) || snapshot.disabled(id))) return false;
+	const selection = binding.selection;
+	if (!selection) return true;
+	const optionEnabled = (id) => selection.options.includes(id) && snapshot.visible(id) && !snapshot.disabled(id);
+	if (!selection.multiple) {
+		if (after?.type === "reference") return after.value === (before?.type === "reference" ? before.value : void 0) || optionEnabled(after.value);
+		return after === void 0 && selection.allowClear !== false && (before?.type !== "reference" || optionEnabled(before.value));
+	}
+	if (after !== void 0 && after.type !== "reference[]") return false;
+	const oldValues = before?.type === "reference[]" ? before.value : [];
+	const values = after?.type === "reference[]" ? after.value : [];
+	const activeCount = values.filter((id) => snapshot.visible(id)).length;
+	const previousActiveCount = oldValues.filter((id) => snapshot.visible(id)).length;
+	if (selection.maxSelection != null && activeCount > selection.maxSelection && activeCount >= previousActiveCount) return false;
+	return [...oldValues.filter((id) => !values.includes(id)), ...values.filter((id) => !oldValues.includes(id))].every(optionEnabled);
+}
+function hasPermittedChange(binding, snapshot) {
+	if (!snapshot.visible(binding.controlId) || snapshot.disabled(binding.controlId) || binding.visibilityIds?.some((id) => !snapshot.visible(id) || snapshot.disabled(id))) return false;
+	if (!binding.selection) return true;
+	const current = snapshot.stored(binding.slotId);
+	const selection = binding.selection;
+	if (!selection.multiple) {
+		if (current !== void 0 && canWriteSelection(binding, current, void 0, snapshot)) return true;
+		return selection.options.some((id) => (current?.type !== "reference" || current.value !== id) && canWriteSelection(binding, current, {
+			type: "reference",
+			value: id
+		}, snapshot));
+	}
+	const values = current?.type === "reference[]" ? current.value : [];
+	return selection.options.some((id) => canWriteSelection(binding, current, {
+		type: "reference[]",
+		value: values.includes(id) ? values.filter((value) => value !== id) : [...values, id]
+	}, snapshot));
+}
+//#endregion
+//#region src/survey/responses/response-meta.ts
+const SurveyEventTypes = {
+	openSurvey: "openSurvey",
+	pageChanged: "pageChanged",
+	responseChanged: "responseChanged",
+	languageChanged: "languageChanged"
+};
+const surveyEventSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("openSurvey"),
+		timestamp: z.number().finite(),
+		value: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("pageChanged"),
+		timestamp: z.number().finite(),
+		value: z.number().int().nonnegative()
+	}),
+	z.strictObject({
+		type: z.literal("languageChanged"),
+		timestamp: z.number().finite(),
+		value: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("responseChanged"),
+		timestamp: z.number().finite(),
+		slotId: z.string().min(1),
+		operation: z.enum(["set", "clear"])
+	})
+]);
+const itemResponseMetadataSchema = stringRecord(z.string().min(1), z.strictObject({ position: z.number().int().nonnegative() }));
+//#endregion
+//#region src/survey/responses/survey-response.ts
+const SURVEY_RESPONSE_SCHEMA_VERSION = 2;
+const surveyResponseSchema = z.strictObject({
+	schemaVersion: z.literal(2),
+	responseId: z.string().min(1),
+	/** The exact definition the answers were given against; slot and option IDs are only meaningful with it. */
+	definitionId: z.string().min(1),
+	participantId: z.string().optional(),
+	submittedAt: z.number().finite().optional(),
+	answers: stringRecord(z.string().min(1), responseValueSchema),
+	itemMetadata: itemResponseMetadataSchema.optional(),
+	events: z.array(surveyEventSchema),
+	/** Host-provided values stored and exported with the response, e.g. a tracking ID. */
+	customValues: stringRecord(z.string().min(1), responseValueSchema).optional(),
+	evaluationContext: z.strictObject({
+		locale: z.string().min(1),
+		currentDate: calendarDaySchema.optional(),
+		participantFlags: stringRecord(z.string(), z.string()).optional()
+	}).optional(),
+	/** Reproduces item and option shuffles. */
+	randomization: z.strictObject({ seed: z.string().min(1) }).optional()
+});
+/** Publication and schema association belong to the host, never to an answer address. */
+var SurveyResponse = class SurveyResponse {
+	responseId;
+	definitionId;
+	participantId;
+	submittedAt;
+	answers = Object.create(null);
+	itemMetadata = Object.create(null);
+	events = [];
+	customValues;
+	evaluationContext;
+	randomization;
+	constructor(responseId, definitionId) {
+		this.responseId = responseId;
+		this.definitionId = definitionId;
+	}
+	serialize() {
+		return structuredClone({
+			schemaVersion: 2,
+			responseId: this.responseId,
+			definitionId: this.definitionId,
+			participantId: this.participantId,
+			submittedAt: this.submittedAt,
+			answers: this.answers,
+			itemMetadata: this.itemMetadata,
+			events: this.events,
+			customValues: this.customValues,
+			evaluationContext: this.evaluationContext,
+			randomization: this.randomization
+		});
+	}
+	static deserialize(input) {
+		const json = surveyResponseSchema.parse(input);
+		const response = new SurveyResponse(json.responseId, json.definitionId);
+		response.answers = json.answers;
+		response.participantId = json.participantId;
+		response.submittedAt = json.submittedAt;
+		response.itemMetadata = json.itemMetadata ?? {};
+		response.events = json.events;
+		response.customValues = json.customValues;
+		response.evaluationContext = json.evaluationContext;
+		response.randomization = json.randomization;
+		return response;
+	}
+};
+//#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/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/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.maskText ?? "***");
+	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, maskText) {
+	return valueToString(value) ? maskText : "";
+}
+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 ?? ownValue(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.maskText ?? "***";
+	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
+	});
+}
+/** Internal typed diagnostics let authoring distinguish conflicts from unfinished mappings. */
+function getDefaultProjectionDiagnostics(survey) {
+	const issues = [];
+	const headers = /* @__PURE__ */ new Set([
+		"submittedAt",
+		"participantId",
+		"responseId",
+		"sourceId"
+	]);
+	const definitions = survey.slots.definitions;
+	const slots = definitions.some((slot) => slot.exportSettings?.categorical === "labels") ? localizeExportSlots(survey, definitions) : definitions;
+	for (const slot of slots) try {
+		for (const column of projectSlot(slot, {
+			mode: "default",
+			...slot.exportSettings
+		})) {
+			if (headers.has(column.header)) issues.push({
+				code: "duplicate-header",
+				header: column.header,
+				message: `Duplicate export column header '${column.header}'`
+			});
+			headers.add(column.header);
+		}
+	} catch (error) {
+		issues.push({
+			code: "invalid-projection",
+			slotId: slot.slotId,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return issues;
+}
+/** Collect draft diagnostics without stopping at the first unfinished variable. */
+function getDefaultProjectionIssues(survey) {
+	return getDefaultProjectionDiagnostics(survey).map((issue) => issue.message);
+}
+/** 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,
+		maskText: config.maskText ?? "***"
+	};
+	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);
+}
+/** Localization is projected from this exact revision, never cached in structural slot identities. */
+function localizedExportSlots(survey) {
+	return localizeExportSlots(survey, survey.slots.definitions);
+}
+function localizeExportSlots(survey, definitions) {
+	const fallbackLocale = survey.locales[0];
+	return definitions.map((slot) => ({
+		...slot,
+		referenceValueLabels: Object.fromEntries([.../* @__PURE__ */ new Set([...survey.locales, ...Object.keys(slot.referenceValueLabels ?? {})])].map((locale) => [locale, Object.fromEntries(optionIds(slot).flatMap((id) => {
+			const label = survey.owners.get(id)?.roles.some((role) => role.role === "label") ? getContentPlainText(readLocalizationContent(survey, {
+				scope: "content",
+				ownerId: id,
+				role: "label"
+			}, locale) ?? (fallbackLocale ? readLocalizationContent(survey, {
+				scope: "content",
+				ownerId: id,
+				role: "label"
+			}, fallbackLocale) : void 0)).trim() : ownValue(ownValue(slot.referenceValueLabels, locale), id);
+			return label ? [[id, label]] : [];
+		}))]))
+	}));
+}
+//#endregion
+export { shuffleArray as $, isAdmissibleInDraft as A, expressionIssues as B, surveyEventSchema as C, DefinitionError as D, hasPermittedChange as E, allocateResponseVariableName as F, responseValueElements as G, functionTypeIssues as H, isValidResponseVariableName as I, FUNCTION_SIGNATURES as J, responseValuesEqual as K, suggestResponseVariableName as L, getCompositionLabel as M, ResponseSlotRegistry as N, Survey as O, RESPONSE_VARIABLE_NAME_MAX_LENGTH as P, resolveUniqueItemKey as Q, ExpressionEvaluationError as R, itemResponseMetadataSchema as S, canWriteSelection as T, inferExpressionReturnType as U, expressionTypeIssues as V, invalidResponseDomainValues as W, generateCodingKey as X, createSeededRandom as Y, generateId as Z, SlotTransformMode as _, optionIds as a, surveyResponseSchema as b, resolvedSlotEncoding as c, exportSingleResponseSlot as d, shuffleIndices as et, decodeExportColumnId as f, META_COLUMN_ORDER as g, ExportColumnSource as h, localizedExportSlots as i, surveyLocales as j, checkDocumentBudget as k, BooleanExportValues as l, EXPORTER_PROFILE_SCHEMA_VERSION as m, getDefaultProjectionDiagnostics as n, optionMapping as o, encodeExportColumnId as p, validateResponseSlotValue as q, getDefaultProjectionIssues as r, projectSlot as s, formatProjectedValue as t, structuredCloneMethod as tt, DEFAULT_TRANSFORM as u, SURVEY_RESPONSE_SCHEMA_VERSION as v, SurveyStateGraph as w, SurveyEventTypes as x, SurveyResponse as y, evaluateExpression as z };
+
+//# sourceMappingURL=projection-DrLPFroE.mjs.map