@case-framework/survey-core 0.7.0 → 0.9.0

package/build/editor.mjs

@@ -1,211 +1,8 @@
-import { $ as generateId, nt as structuredCloneMethod, t as Survey, u as SurveyItemTranslations, v as GroupItemCore } from "./survey-BKblV5rN.mjs";
-//#region src/editor/item-copy-paste.ts
-var ItemCopyPaste = class ItemCopyPaste {
-	survey;
-	constructor(survey) {
-		this.survey = survey;
-	}
-	/**
-	* Copy a survey item and all its data to clipboard format
-	* When copying a group, automatically includes all items in the subtree
-	* @param itemId - The id of the item to copy
-	* @returns Clipboard data that can be serialized to JSON for clipboard
-	*/
-	copyItem(itemId) {
-		if (!this.survey.surveyItems.get(itemId)) throw new Error(`Item with id '${itemId}' not found`);
-		const itemsToCopy = this.collectItemsForCopy(itemId);
-		const items = itemsToCopy.map((id) => {
-			const item = this.survey.surveyItems.get(id);
-			if (!item) throw new Error(`Item with id '${id}' not found during copy`);
-			return {
-				itemId: id,
-				itemData: item.rawItem
-			};
-		});
-		const translations = {};
-		itemsToCopy.forEach((id) => {
-			try {
-				const itemTranslations = this.survey.getItemTranslations(id);
-				if (itemTranslations?.locales?.length) {
-					const serializedTranslations = {};
-					itemTranslations.locales.forEach((locale) => {
-						const localeContent = itemTranslations.getAllForLocale(locale);
-						if (localeContent) serializedTranslations[locale] = localeContent;
-					});
-					translations[id] = serializedTranslations;
-				} else translations[id] = {};
-			} catch {
-				translations[id] = {};
-			}
-		});
-		return {
-			type: "survey-item",
-			version: "1.0.0",
-			items,
-			translations,
-			rootItemId: itemId,
-			timestamp: Date.now()
-		};
-	}
-	/**
-	* Collect all items that should be copied, including subtree for groups
-	* @param itemId - The root item id
-	* @returns Array of item keys to copy
-	*/
-	collectItemsForCopy(itemId) {
-		const itemsToCopy = [itemId];
-		const item = this.survey.surveyItems.get(itemId);
-		if (!item) return [];
-		if (item instanceof GroupItemCore) {
-			const childIds = item.items;
-			if (childIds.length > 0) childIds.forEach((childId) => {
-				const childItems = this.collectItemsForCopy(childId);
-				itemsToCopy.push(...childItems);
-			});
-		}
-		return itemsToCopy;
-	}
-	/**
-	* Add an item to its parent group.
-	* Ensures key uniqueness among siblings.
-	* @param target - Target location information
-	* @param item - The item to add (may have key adjusted for uniqueness)
-	*/
-	addItemToParentGroup(target, item) {
-		const parentGroup = this.survey.surveyItems.get(target.parentId);
-		if (!parentGroup) throw new Error(`Parent item with id '${target.parentId}' not found`);
-		if (!(parentGroup instanceof GroupItemCore)) throw new Error(`Parent item '${target.parentId}' is not a group item`);
-		const siblings = parentGroup.items.map((id) => this.survey.surveyItems.get(id)).filter((s) => s !== void 0);
-		const siblingKeys = new Set(siblings.map((s) => s.key));
-		let uniqueKey = item.key;
-		if (siblingKeys.has(uniqueKey)) {
-			let counter = 1;
-			const originalKey = item.key;
-			while (siblingKeys.has(uniqueKey)) {
-				uniqueKey = originalKey + `_${counter}`;
-				counter++;
-			}
-			if (uniqueKey !== item.key) {
-				const updatedRawItem = {
-					...item.rawItem,
-					key: uniqueKey
-				};
-				const newItem = this.survey.createItemFromRaw(updatedRawItem);
-				this.survey.surveyItems.delete(item.id);
-				this.survey.surveyItems.set(newItem.id, newItem);
-				item = newItem;
-			}
-		}
-		const insertIndex = target.index !== void 0 ? Math.min(target.index, parentGroup.items.length) : parentGroup.items.length;
-		parentGroup.addChild(item.id, insertIndex);
-	}
-	/**
-	* Paste a survey item from clipboard data to a target location
-	* Handles multiple items and subtrees from the clipboard data
-	* @param clipboardData - The clipboard data containing the item(s) to paste
-	* @param target - Target location where to paste the item
-	* @returns The id of the pasted root item
-	*/
-	pasteItem(clipboardData, target) {
-		if (!ItemCopyPaste.isValidClipboardData(clipboardData)) throw new Error("Invalid clipboard data format");
-		const idMapping = {};
-		clipboardData.items.forEach(({ itemId }) => {
-			idMapping[itemId] = generateId();
-		});
-		clipboardData.items.forEach(({ itemId, itemData }) => {
-			const newId = idMapping[itemId];
-			if (newId) {
-				const updatedItemData = this.updateItemIdsInData(itemData, idMapping);
-				updatedItemData.id = newId;
-				const newItem = this.survey.createItemFromRaw(updatedItemData);
-				this.survey.surveyItems.set(newItem.id, newItem);
-				if (itemId === clipboardData.rootItemId) this.addItemToParentGroup(target, newItem);
-			}
-		});
-		const updatedTranslations = this.updateTranslations(clipboardData.translations, idMapping);
-		Object.keys(updatedTranslations).forEach((itemId) => {
-			const itemTranslations = new SurveyItemTranslations();
-			const serializedData = updatedTranslations[itemId];
-			Object.keys(serializedData).forEach((locale) => {
-				itemTranslations.setAllForLocale(locale, serializedData[locale]);
-			});
-			this.survey.translations.setItemTranslations(itemId, itemTranslations);
-		});
-		return idMapping[clipboardData.rootItemId];
-	}
-	/**
-	* Update all item ids in the raw item data recursively
-	*/
-	updateItemIdsInData(itemData, idMapping) {
-		const updatedData = JSON.parse(JSON.stringify(itemData));
-		if (updatedData.itemType === "group" && updatedData.config) {
-			const config = updatedData.config;
-			if (config.items) config.items = config.items.map((childId) => idMapping[childId] ?? childId);
-		}
-		this.updateExpressionsInItemData(updatedData, idMapping);
-		return updatedData;
-	}
-	/**
-	* Update expressions in item data that reference the old ids
-	*/
-	updateExpressionsInItemData(itemData, idMapping) {
-		if (itemData.displayConditions?.root) this.updateExpressionReferences(itemData.displayConditions.root, idMapping);
-		if (itemData.displayConditions?.components) Object.values(itemData.displayConditions.components).forEach((expr) => {
-			if (expr) this.updateExpressionReferences(expr, idMapping);
-		});
-		if (itemData.disabledConditions?.components) Object.values(itemData.disabledConditions.components).forEach((expr) => {
-			if (expr) this.updateExpressionReferences(expr, idMapping);
-		});
-		if (itemData.validations) Object.values(itemData.validations).forEach((expr) => {
-			if (expr) this.updateExpressionReferences(expr, idMapping);
-		});
-		if (itemData.prefills) itemData.prefills.forEach((prefill) => {
-			if (prefill.when) this.updateExpressionReferences(prefill.when, idMapping);
-			if (prefill.source.type === "expression") this.updateExpressionReferences(prefill.source.expression, idMapping);
-			if (prefill.source.type === "previousResponse") prefill.source.ref.itemId = idMapping[prefill.source.ref.itemId] ?? prefill.source.ref.itemId;
-		});
-	}
-	/**
-	* Update references in a single expression (recursive)
-	*/
-	updateExpressionReferences(expression, idMapping) {
-		if (!expression || typeof expression !== "object") return;
-		const expr = expression;
-		if (Array.isArray(expr.data)) expr.data.forEach((arg) => {
-			if (arg && typeof arg === "object" && arg !== null && "str" in arg) {
-				const argObj = arg;
-				if (typeof argObj.str === "string" && Object.prototype.hasOwnProperty.call(idMapping, argObj.str)) argObj.str = idMapping[argObj.str];
-				this.updateExpressionReferences(arg, idMapping);
-			}
-		});
-		Object.keys(expr).forEach((key) => {
-			const val = expr[key];
-			if (val && typeof val === "object") this.updateExpressionReferences(val, idMapping);
-		});
-	}
-	/**
-	* Update translation keys for the pasted item
-	*/
-	updateTranslations(translations, idMapping) {
-		const newTranslations = {};
-		Object.keys(translations).forEach((itemId) => {
-			const itemTranslations = translations[itemId];
-			const newItemId = idMapping[itemId];
-			newTranslations[newItemId] = itemTranslations;
-		});
-		return newTranslations;
-	}
-	/**
-	* Validate clipboard data format
-	*/
-	static isValidClipboardData(data) {
-		if (typeof data !== "object" || data === null || data === void 0) return false;
-		const clipboardData = data;
-		if (clipboardData.rootItemId === void 0 || typeof clipboardData.rootItemId !== "string" || !Array.isArray(clipboardData.items) || clipboardData.items.length === 0 || typeof clipboardData.translations !== "object" || clipboardData.translations === null || Array.isArray(clipboardData.translations)) return false;
-		return clipboardData.type === "survey-item" && clipboardData.version === "1.0.0" && clipboardData.items.every((item) => typeof item === "object" && item !== null && typeof item.itemId === "string" && item.itemId.length > 0 && typeof item.itemData === "object" && item.itemData !== null && !Array.isArray(item.itemData) && typeof item.itemData.itemType === "string") && clipboardData.items.some((item) => item.itemId === clipboardData.rootItemId);
-	}
-};
-//#endregion
+import { $ as inspectAnnotated, G as stringRecord, U as ownValue, W as setOwnValue, X as contentOwnerIds, it as transformAnnotated, l as readLocalizationContent, mt as transformExpression, nt as remapAnnotated, ot as expressionSchema, q as annotatedReferences, tt as referenceId } from "./localization-1lzNpyFX.mjs";
+import { D as DefinitionError, F as allocateResponseVariableName, I as isValidResponseVariableName, O as Survey, Z as generateId, i as localizedExportSlots, k as checkDocumentBudget, n as getDefaultProjectionDiagnostics, r as getDefaultProjectionIssues, s as projectSlot, tt as structuredCloneMethod, w as SurveyStateGraph } from "./projection-DrLPFroE.mjs";
+import { t as answerTypeReservationsSchema } from "./answer-types-Dtm6MqZQ.mjs";
+import { SURVEY_EDITOR_ITEM_COLORS } from "./editor/colors.mjs";
+import { z } from "zod";
 //#region src/editor/undo-redo.ts
 const CommitSource = {
 	USER: "user",
@@ -239,34 +36,17 @@ function cloneAssets(assets) {
 	return structuredCloneMethod(assets);
 }
 function normalizeHistoryEntry(entry) {
-	if ("kind" in entry) {
-		if (entry.kind === "survey-snapshot") return {
-			kind: "survey-snapshot",
-			survey: structuredCloneMethod(entry.survey),
-			timestamp: entry.timestamp,
-			meta: entry.meta,
-			memorySize: entry.memorySize
-		};
-		return {
-			kind: "asset-change",
-			changes: structuredCloneMethod(entry.changes),
-			timestamp: entry.timestamp,
-			meta: entry.meta,
-			memorySize: entry.memorySize
-		};
-	}
+	if (entry.kind !== "survey-snapshot" && entry.kind !== "asset-change") throw new Error("Unsupported history entry kind");
 	return {
-		kind: "survey-snapshot",
-		survey: structuredCloneMethod(entry.survey),
-		timestamp: entry.timestamp,
-		meta: entry.meta,
-		memorySize: entry.memorySize
+		...structuredCloneMethod(entry),
+		id: entry.id ?? generateId()
 	};
 }
 var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	history = [];
 	currentIndex = -1;
 	_config;
+	baseAssetSize;
 	_initialAssets;
 	constructor(initialSurvey, config = {}, meta = {
 		label: "Initial state",
@@ -284,7 +64,8 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	saveEntry(entry) {
 		const payload = entry.kind === "survey-snapshot" ? {
 			kind: entry.kind,
-			survey: entry.survey
+			survey: entry.survey,
+			changes: entry.changes
 		} : {
 			kind: entry.kind,
 			changes: entry.changes
@@ -293,6 +74,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		this.history = this.history.slice(0, this.currentIndex + 1);
 		this.history.push({
 			...structuredCloneMethod(entry),
+			id: generateId(),
 			timestamp: Date.now(),
 			memorySize
 		});
@@ -302,12 +84,12 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	saveSnapshot(survey, meta) {
 		this.saveEntry({
 			kind: "survey-snapshot",
-			survey: structuredCloneMethod(survey),
+			survey,
 			meta
 		});
 	}
 	getBaseAssetsSize() {
-		return this._initialAssets ? MemoryCalculator.calculateSize(this._initialAssets) : 0;
+		return this.baseAssetSize ??= this._initialAssets ? MemoryCalculator.calculateSize(this._initialAssets) : 0;
 	}
 	cleanupHistory() {
 		const maxMemoryBytes = this._config.maxTotalMemoryMB * 1024 * 1024;
@@ -321,6 +103,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		const nextEntry = this.history[nextStateIndex];
 		const newFirstEntry = {
 			kind: "survey-snapshot",
+			id: nextEntry.id,
 			survey: nextStateSurvey,
 			meta: nextEntry.meta,
 			timestamp: nextEntry.timestamp,
@@ -330,8 +113,9 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 			})
 		};
 		const removedBytes = this.history[0].memorySize;
-		this._initialAssets = cloneAssets(nextStateAssets);
-		this.history = [newFirstEntry, ...this.history.slice(nextStateIndex + 1)];
+		this._initialAssets = nextStateAssets;
+		this.baseAssetSize = void 0;
+		this.history = [newFirstEntry, ...this.history.slice(2)];
 		this.currentIndex--;
 		return removedBytes;
 	}
@@ -347,8 +131,8 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		throw new Error("Invalid history state");
 	}
 	applyAssetPatch(assets, patch) {
-		const nextAssets = structuredCloneMethod(assets);
-		if (patch.next) nextAssets[patch.assetId] = structuredCloneMethod(patch.next);
+		const nextAssets = assets;
+		if (patch.next) setOwnValue(nextAssets, patch.assetId, structuredCloneMethod(patch.next));
 		else delete nextAssets[patch.assetId];
 		return nextAssets;
 	}
@@ -357,13 +141,23 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		let assets = cloneAssets(this._initialAssets) ?? {};
 		for (let i = 1; i <= index; i++) {
 			const entry = this.history[i];
-			if (entry.kind !== "asset-change") continue;
-			for (const patch of entry.changes) assets = this.applyAssetPatch(assets, patch);
+			for (const patch of entry.changes ?? []) assets = this.applyAssetPatch(assets, patch);
 		}
 		return Object.keys(assets).length > 0 ? assets : void 0;
 	}
-	commit(survey, meta) {
-		this.saveSnapshot(survey, meta);
+	getEntryId(index) {
+		return this.history[index]?.id;
+	}
+	findEntryIndex(id) {
+		return this.history.findIndex((entry) => entry.id === id);
+	}
+	commit(survey, meta, changes) {
+		this.saveEntry({
+			kind: "survey-snapshot",
+			survey,
+			meta,
+			...changes?.length ? { changes } : {}
+		});
 	}
 	commitAssetChange(changes, meta) {
 		if (changes.length === 0) return;
@@ -407,7 +201,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	}
 	getMemoryUsage() {
 		return {
-			totalMB: this.getTotalMemoryUsage() / (1024 * 1024),
+			totalMB: this.getTotalMemoryUsage() / 1048576,
 			entries: this.history.length
 		};
 	}
@@ -422,6 +216,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 			index,
 			kind: entry.kind,
 			meta: entry.meta,
+			id: entry.id ?? generateId(),
 			timestamp: entry.timestamp,
 			memorySize: entry.memorySize,
 			isCurrent: index === this.currentIndex
@@ -440,6 +235,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 				index,
 				kind: entry.kind,
 				meta: entry.meta,
+				id: entry.id ?? generateId(),
 				timestamp: entry.timestamp,
 				memorySize: entry.memorySize,
 				isCurrent: index === this.currentIndex
@@ -484,6 +280,8 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 				if (entry.kind === "survey-snapshot") return {
 					kind: "survey-snapshot",
 					survey: entry.survey,
+					changes: entry.changes,
+					id: entry.id ?? generateId(),
 					timestamp: entry.timestamp,
 					meta: entry.meta,
 					memorySize: entry.memorySize
@@ -491,6 +289,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 				return {
 					kind: "asset-change",
 					changes: entry.changes,
+					id: entry.id ?? generateId(),
 					timestamp: entry.timestamp,
 					meta: entry.meta,
 					memorySize: entry.memorySize
@@ -512,9 +311,10 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		if (!jsonData.config) throw new Error("Invalid object: config is required");
 		const normalizedHistory = jsonData.history.map(normalizeHistoryEntry);
 		const firstEntry = normalizedHistory[0];
-		const instance = new SurveyEditorUndoRedo(firstEntry.kind === "survey-snapshot" ? firstEntry.survey : (() => {
+		const firstSurvey = firstEntry.kind === "survey-snapshot" ? firstEntry.survey : (() => {
 			throw new Error("Invalid object: first history entry must resolve to a survey snapshot");
-		})(), jsonData.config, firstEntry.meta, initialAssetsOverride ?? jsonData.initialAssets);
+		})();
+		const instance = new SurveyEditorUndoRedo(firstSurvey, jsonData.config, firstEntry.meta, initialAssetsOverride ?? jsonData.initialAssets);
 		instance.history = normalizedHistory;
 		instance.currentIndex = jsonData.currentIndex;
 		instance._initialAssets = cloneAssets(initialAssetsOverride ?? jsonData.initialAssets);
@@ -522,530 +322,1336 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	}
 };
 //#endregion
+//#region src/editor/response-naming.ts
+function readPath(input, path) {
+	let value = input;
+	for (const key of path) if (Array.isArray(value) && typeof key === "number") value = value[key];
+	else if (value !== null && typeof value === "object" && !Array.isArray(value) && Object.hasOwn(value, key)) value = Reflect.get(value, key);
+	else throw new Error("Response naming declaration does not match its config");
+	return value;
+}
+function writePath(input, path, value) {
+	if (!path.length) throw new Error("Invalid response naming path");
+	const parent = readPath(input, path.slice(0, -1));
+	if (!parent || typeof parent !== "object") throw new Error("Response naming declaration does not match its config");
+	const key = path.at(-1);
+	if (Array.isArray(parent) && typeof key === "number") parent[key] = value;
+	else setOwnValue(parent, String(key), value);
+}
+const assertName = (name) => {
+	if (!isValidResponseVariableName(name)) throw new Error(`Invalid variable name "${name}". Use lowercase snake_case, starting with a letter, at most 32 characters.`);
+};
+/** Detached, validated preview; applying it uses the editor's ordinary mutation/history path. */
+function previewNaming(survey, edits) {
+	const registry = survey.slots;
+	const raw = structuredClone(survey.serialize());
+	const config = (slot) => readPath(raw, [...survey.elements.get(slot.elementId).path, "config"]);
+	for (const edit of edits) if ("slotId" in edit) {
+		const slot = registry.get(edit.slotId);
+		if (!slot) throw new Error(`Unknown response variable "${edit.slotId}"`);
+		if (slot.naming?.kind === "matrix") throw new Error("Matrix cell names are derived; edit the matrix prefix or row/column coding names");
+		if (!slot.naming) throw new Error(`The input owning "${edit.slotId}" does not expose a naming mutation`);
+		assertName(edit.variableName);
+		writePath(config(slot), slot.naming.path, edit.variableName);
+	} else {
+		const slots = registry.definitions.filter((slot) => slot.elementId === edit.elementId && slot.naming?.kind === "matrix");
+		if (!slots.length) throw new Error(`Unknown matrix element "${edit.elementId}"`);
+		for (const [ids, kind] of [[edit.rows, "row"], [edit.columns, "column"]]) for (const [id, name] of Object.entries(ids ?? {})) {
+			assertName(name);
+			const slot = slots.find((slot) => kind === "row" ? slot.rowId === id : slot.columnId === id);
+			const naming = slot?.naming;
+			const path = naming?.kind === "matrix" ? kind === "row" ? naming.rowPath : naming.columnPath : void 0;
+			if (!slot || !path) throw new Error(`Unknown matrix ${kind} "${id}"`);
+			writePath(config(slot), path, name);
+		}
+		if (edit.prefix !== void 0) {
+			assertName(edit.prefix);
+			const slot = slots[0], naming = slot.naming;
+			if (naming?.kind === "matrix") writePath(config(slot), naming.prefixPath, edit.prefix);
+		}
+	}
+	const next = Survey.parse(raw, survey.registry, { admission: "draft" });
+	const nextRegistry = next.slots;
+	const beforeIssues = new Set(registry.diagnostics.map((issue) => JSON.stringify(issue)));
+	const issues = nextRegistry.diagnostics.filter((issue) => !beforeIssues.has(JSON.stringify(issue)));
+	if (issues.length) throw new Error(issues.map((issue) => issue.message).join("\n"));
+	const changes = nextRegistry.definitions.flatMap((slot) => {
+		const before = registry.get(slot.slotId).variableName;
+		return before === slot.variableName ? [] : [{
+			slotId: slot.slotId,
+			itemId: slot.itemId,
+			before,
+			after: slot.variableName
+		}];
+	});
+	return {
+		survey: next.serialize(),
+		changes
+	};
+}
+function assertProjectionChanges(before, after) {
+	const existing = new Set(getDefaultProjectionIssues(before));
+	const introduced = getDefaultProjectionIssues(after).filter((issue) => !existing.has(issue));
+	if (introduced.length) throw new Error(introduced.join("\n"));
+}
+function previewResponseNaming(survey, edits) {
+	const preview = previewNaming(survey, edits);
+	assertProjectionChanges(survey, Survey.parse(preview.survey, survey.registry, { admission: "draft" }));
+	return preview;
+}
+/** Naming, categorical codes, and formats share one detached, atomic preview. */
+function previewResponseSettings(survey, naming, settings) {
+	const preview = previewNaming(survey, naming);
+	const raw = preview.survey;
+	const registry = survey.slots;
+	const codeWrites = /* @__PURE__ */ new Map();
+	for (const edit of settings) {
+		const slot = registry.get(edit.slotId);
+		if (!slot) throw new Error(`Unknown response variable "${edit.slotId}"`);
+		const path = survey.elements.get(slot.elementId).path;
+		const element = survey.registry.elementSchema.parse(readPath(raw, path));
+		for (const [id, code] of Object.entries(edit.optionCodes ?? {})) {
+			const path = ownValue(slot.optionCodePaths, id);
+			if (!path) throw new Error(`Option "${id}" does not expose an export-code mutation`);
+			if (!code.trim()) throw new Error("Option export codes cannot be empty");
+			const target = JSON.stringify([slot.elementId, path]);
+			const previous = codeWrites.get(target);
+			if (previous && previous.code !== code) throw new Error(`Conflicting export codes for shared option "${id}" on variables "${registry.get(previous.slotId).variableName}" and "${slot.variableName}". Supply one code for this shared option.`);
+			codeWrites.set(target, {
+				code,
+				slotId: slot.slotId
+			});
+			writePath(element.config, path, code);
+		}
+		if (edit.exportSettings) element.exportSettings = {
+			...element.exportSettings,
+			[slot.slotId]: structuredClone(edit.exportSettings)
+		};
+		writePath(raw, path, element);
+	}
+	const next = Survey.parse(raw, survey.registry, { admission: "draft" });
+	for (const slot of localizedExportSlots(next).filter((slot) => settings.some((edit) => edit.slotId === slot.slotId))) projectSlot(slot, {
+		mode: "default",
+		...slot.exportSettings
+	});
+	assertProjectionChanges(survey, next);
+	return {
+		...preview,
+		survey: next.serialize()
+	};
+}
+/** Allocate names using declared mutation locations, including every nested element. */
+function allocateCopiedResponseNames(schema, input, registry, occupied) {
+	const used = new Set(occupied);
+	return transformAnnotated(schema, input, ({ annotation, value }) => {
+		if (annotation.kind !== "owner" || !value || typeof value !== "object" || !("kind" in value) || value.kind !== "element") return value;
+		const node = registry.elementSchema.parse(value);
+		const definition = registry.get(node.elementType);
+		const paths = /* @__PURE__ */ new Map();
+		for (const slot of definition.inspect(node).slots) {
+			const naming = slot.naming;
+			if (!naming) {
+				if (used.has(slot.variableName)) throw new Error(`Cannot copy variable '${slot.variableName}': element '${node.elementType}' must declare a naming location to resolve the duplicate name`);
+				used.add(slot.variableName);
+				continue;
+			}
+			const path = ["config", ...naming.kind === "variable" ? naming.path : naming.prefixPath];
+			const base = readPath(node, path);
+			if (typeof base !== "string") throw new Error("Invalid response naming location");
+			const key = JSON.stringify(path);
+			const group = paths.get(key) ?? {
+				path,
+				base,
+				slots: /* @__PURE__ */ new Set(),
+				maxLength: 32
+			};
+			group.slots.add(slot.slotId);
+			group.maxLength = Math.min(group.maxLength, 32 - (slot.variableName.length - base.length));
+			paths.set(key, group);
+		}
+		for (const { path, base, slots, maxLength } of paths.values()) {
+			let candidate = base, attempts = 0;
+			const names = () => definition.inspect(node).slots.filter((slot) => slots.has(slot.slotId)).map((slot) => slot.variableName);
+			while (names().some((name) => used.has(name))) {
+				if (++attempts > used.size + 1) throw new Error(`Element '${node.elementType}' does not honor its declared naming location`);
+				const before = names();
+				candidate = allocateResponseVariableName(candidate, /* @__PURE__ */ new Set([candidate]), maxLength);
+				writePath(node, path, candidate);
+				if (before.every((name, index) => name === names()[index])) throw new Error(`Element '${node.elementType}' does not honor its declared naming location`);
+			}
+			names().forEach((name) => used.add(name));
+		}
+		return node;
+	});
+}
+//#endregion
+//#region src/editor/item-copy-paste.ts
+/** Only the current format is accepted. Parsing is repeated at the paste boundary. */
+function createItemClipboardSchema(registry) {
+	const shape = registry.surveySchema.shape;
+	return z.strictObject({
+		type: z.literal("survey-item"),
+		version: z.literal(2),
+		rootItemId: referenceId("item"),
+		surveyItems: shape.surveyItems,
+		translations: shape.translations,
+		assets: shape.assets
+	}).superRefine((payload, ctx) => {
+		const items = new Map(payload.surveyItems.map((item) => [item.id, item]));
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (id) => {
+			if (visited.has(id)) {
+				ctx.addIssue({
+					code: "custom",
+					message: "Clipboard flow must be a tree"
+				});
+				return;
+			}
+			visited.add(id);
+			const item = items.get(id);
+			if (!item) {
+				ctx.addIssue({
+					code: "custom",
+					message: "Clipboard flow cannot reference an external child"
+				});
+				return;
+			}
+			if (item.itemType === "group") {
+				if (item.config.isRoot) ctx.addIssue({
+					code: "custom",
+					message: "A root group cannot be pasted"
+				});
+				item.config.items.forEach(visit);
+			}
+		};
+		visit(payload.rootItemId);
+		if (items.size !== payload.surveyItems.length || visited.size !== items.size) ctx.addIssue({
+			code: "custom",
+			message: "Clipboard contains duplicate or disconnected flow items"
+		});
+	});
+}
+function copySurveyItem(survey, itemId) {
+	if (!survey.getItem(itemId)) throw new Error(`Unknown item '${itemId}'`);
+	const items = survey.data.surveyItems.filter((item) => survey.isDescendantOf(item.id, itemId));
+	const itemIds = new Set(items.map((item) => item.id));
+	const owners = new Set([...survey.owners.values()].filter((owner) => itemIds.has(owner.itemId)).map((owner) => owner.id));
+	const payload = {
+		type: "survey-item",
+		version: 2,
+		rootItemId: itemId,
+		surveyItems: structuredClone(items).map((item) => item.itemType === "group" && item.config.isRoot ? {
+			...item,
+			config: {
+				...item.config,
+				isRoot: false
+			}
+		} : item),
+		translations: Object.fromEntries(Object.entries(survey.data.translations ?? {}).flatMap(([locale, translation]) => {
+			const content = Object.fromEntries(Object.entries(translation.content).filter(([id, roles]) => owners.has(id) && Object.keys(roles).length > 0));
+			return Object.keys(content).length ? [[locale, { content }]] : [];
+		}))
+	};
+	const schema = createItemClipboardSchema(survey.registry);
+	const assetIds = new Set(inspectAnnotated(schema, payload).flatMap(({ annotation, value }) => annotation.kind === "reference" && annotation.target === "asset" && typeof value === "string" ? [value] : []));
+	payload.assets = Object.fromEntries([...assetIds].map((id) => [id, ownValue(survey.data.assets, id)]));
+	return schema.parse(payload);
+}
+/** Prepare a detached payload; the editor publishes it only after whole-document validation. */
+function prepareItemPaste(survey, input) {
+	checkDocumentBudget(input);
+	const schema = createItemClipboardSchema(survey.registry);
+	const payload = schema.parse(input);
+	const ids = /* @__PURE__ */ new Map();
+	for (const { annotation, value } of inspectAnnotated(schema, payload)) {
+		if (annotation.kind !== "identity" || typeof value !== "string") continue;
+		if (ids.has(value)) throw new Error(`Duplicate clipboard identity '${value}'`);
+		const reuse = annotation.identity === "asset" && JSON.stringify(ownValue(survey.data.assets, value)) === JSON.stringify(ownValue(payload.assets, value));
+		ids.set(value, reuse ? value : generateId());
+	}
+	return allocateCopiedResponseNames(schema, remapAnnotated(schema, payload, ids), survey.registry, new Set(survey.slots.definitions.map((slot) => slot.variableName)));
+}
+//#endregion
+//#region src/editor/session-schema.ts
+/** The saved editor session is separate from both survey definitions and participant resume state. */
+function createEditorSessionSchema(registry) {
+	const survey = registry.surveySchema;
+	const asset = registry.surveySchema.shape.assets.unwrap().valueType;
+	const assets = stringRecord(z.string().min(1), asset);
+	const patch = z.strictObject({
+		assetId: z.string().min(1),
+		prev: asset.optional(),
+		next: asset.optional()
+	});
+	const entry = {
+		id: z.string().min(1).optional(),
+		timestamp: z.number().finite(),
+		memorySize: z.number().nonnegative().finite(),
+		meta: z.strictObject({
+			label: z.string(),
+			source: z.enum(CommitSource).optional()
+		})
+	};
+	return z.strictObject({
+		version: z.literal(2),
+		survey,
+		hasUncommittedChanges: z.boolean(),
+		answerTypes: answerTypeReservationsSchema,
+		undoRedo: z.strictObject({
+			history: z.array(z.discriminatedUnion("kind", [z.strictObject({
+				...entry,
+				kind: z.literal("survey-snapshot"),
+				survey,
+				changes: z.array(patch).optional()
+			}), z.strictObject({
+				...entry,
+				kind: z.literal("asset-change"),
+				changes: z.array(patch)
+			})])).min(1),
+			currentIndex: z.number().int().nonnegative(),
+			initialAssets: assets.optional(),
+			config: z.strictObject({
+				maxTotalMemoryMB: z.number().positive().finite(),
+				minHistorySize: z.number().int().nonnegative(),
+				maxHistorySize: z.number().int().positive()
+			})
+		}).superRefine((value, context) => {
+			if (value.currentIndex >= value.history.length) context.addIssue({
+				code: "custom",
+				path: ["currentIndex"],
+				message: "History index is outside the stored history"
+			});
+			if (value.history[0]?.kind !== "survey-snapshot") context.addIssue({
+				code: "custom",
+				path: ["history", 0],
+				message: "History must start with a survey snapshot"
+			});
+		})
+	});
+}
+//#endregion
 //#region src/editor/survey-editor.ts
-function stripAssetsFromSurveySnapshot(survey) {
-	const snapshot = structuredCloneMethod(survey);
-	delete snapshot.assets;
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function at(input, path) {
+	let value = input;
+	for (const part of path) if (Array.isArray(value) && typeof part === "number") value = value[part];
+	else if (record(value)) value = ownValue(value, String(part));
+	else throw new Error(`Invalid derived location ${JSON.stringify(path)}`);
+	return value;
+}
+function arrayAt(input, path) {
+	const value = at(input, path);
+	if (!Array.isArray(value)) throw new Error("Expected array at derived location");
+	return value;
+}
+function setAt(input, path, value) {
+	const parent = at(input, path.slice(0, -1)), part = path.at(-1);
+	if (Array.isArray(parent) && typeof part === "number") parent[part] = value;
+	else if (record(parent) && typeof part === "string") setOwnValue(parent, part, value);
+	else throw new Error("Invalid mutation location");
+}
+const inside = (ancestor, path) => ancestor.length <= path.length && ancestor.every((part, i) => path[i] === part);
+function stripAssets(survey) {
+	const { assets: _assets, ...snapshot } = survey;
 	return snapshot;
 }
-function mergeSurveySnapshotWithAssets(snapshot, assets) {
-	const merged = structuredCloneMethod(snapshot);
-	if (assets && Object.keys(assets).length > 0) merged.assets = structuredCloneMethod(assets);
-	else delete merged.assets;
-	return merged;
+/** Compare persisted JSON semantics without depending on object property insertion order. */
+function equal(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((value, index) => equal(value, right[index]));
+	if (!record(left) || !record(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) && equal(left[key], right[key]));
+}
+/** Element mutations may edit their owned wording, never another owner's content or survey UI. */
+function assertElementTranslationScope(before, after, owners) {
+	const surfaces = (translation) => Object.fromEntries(Object.entries(translation ?? {}).filter(([key]) => key !== "content"));
+	for (const locale of /* @__PURE__ */ new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})])) {
+		const previous = ownValue(before, locale), next = ownValue(after, locale);
+		if (!previous || !next || !equal(surfaces(previous), surfaces(next))) throw new Error(`Element edits cannot change survey-level translations or add/remove locale '${locale}'`);
+		for (const owner of /* @__PURE__ */ new Set([...Object.keys(previous?.content ?? {}), ...Object.keys(next?.content ?? {})])) if (!owners.has(owner) && !equal(ownValue(previous?.content, owner), ownValue(next?.content, owner))) throw new Error(`Element edits cannot change content owned by '${owner}' in locale '${locale}'`);
+	}
+}
+/** Derive modification ownership from the committed revision, including nested localized content. */
+function timestampEditedItems(before, after) {
+	const previous = new Map(before.surveyItems.map((item) => [item.id, item]));
+	const positions = (items) => new Map(items.flatMap((item) => item.itemType === "group" ? item.config.items.map((id, index) => [id, [item.id, index]]) : []));
+	const previousPositions = positions(before.surveyItems);
+	const nextPositions = positions(after.data.surveyItems);
+	const changed = /* @__PURE__ */ new Set();
+	for (const item of after.data.surveyItems) if (!equal(previous.get(item.id), item) || !equal(previousPositions.get(item.id), nextPositions.get(item.id))) changed.add(item.id);
+	for (const locale of /* @__PURE__ */ new Set([...Object.keys(before.translations ?? {}), ...after.locales])) {
+		const oldContent = ownValue(before.translations, locale)?.content ?? {};
+		const newContent = ownValue(after.data.translations, locale)?.content ?? {};
+		for (const id of /* @__PURE__ */ new Set([...Object.keys(oldContent), ...Object.keys(newContent)])) {
+			if (equal(ownValue(oldContent, id), ownValue(newContent, id))) continue;
+			const owner = after.owners.get(id);
+			if (owner) changed.add(owner.itemId);
+		}
+	}
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	return after.withItemEditorMetadata(new Map([...changed].map((id) => {
+		const original = previous.get(id);
+		return [id, {
+			createdAt: original ? original.editorMetadata?.createdAt ?? timestamp : timestamp,
+			updatedAt: timestamp
+		}];
+	})));
+}
+/** A surviving answer identity cannot acquire a different wire value type. */
+function getAnswerTypeChangeDiagnostics(before, after) {
+	if (before.slots === after.slots) return [];
+	return answerTypeDiagnostics(after, (id) => before.slots.get(id)?.valueType);
 }
+function answerTypeDiagnostics(after, previousType) {
+	return after.slots.definitions.flatMap((slot) => {
+		const previous = previousType(slot.slotId);
+		return previous && previous !== slot.valueType ? [{
+			code: "answer-type-change",
+			severity: "error",
+			path: after.identities.get(slot.slotId)?.path ?? after.elements.get(slot.elementId).path,
+			message: `Answer '${slot.variableName}' (${slot.slotId}) cannot change from ${previous} to ${slot.valueType} while keeping its ID. Allocate a new answer ID and explicitly repair its references, prefills and export settings in the same transaction.`
+		}] : [];
+	});
+}
+function assertStableAnswerTypes(before, after) {
+	const diagnostics = getAnswerTypeChangeDiagnostics(before, after);
+	if (diagnostics.length) throw new DefinitionError(diagnostics);
+}
+/** All human and assistant operations publish through this transaction/history owner. */
 var SurveyEditor = class SurveyEditor {
-	_survey;
-	_undoRedo;
-	_hasUncommittedChanges = false;
-	_pluginRegistry;
-	constructor(survey, config = {}, meta) {
-		this._survey = survey;
-		const { pluginRegistry, ...undoRedoConfig } = config;
-		this._pluginRegistry = pluginRegistry;
+	current;
+	answerTypes = /* @__PURE__ */ new Map();
+	rememberedSlots;
+	_history;
+	listeners = /* @__PURE__ */ new Set();
+	mutationEpoch = 0;
+	fieldWriteDepth = 0;
+	actionDepth = 0;
+	actionMeta;
+	pendingSurvey = false;
+	pendingAssets = [];
+	pendingMeta;
+	constructor(survey, options = {}, meta) {
+		const { answerTypes, ...config } = options;
+		this.answerTypes = new Map(answerTypeReservationsSchema.parse(answerTypes ?? []));
+		const diagnostics = answerTypeDiagnostics(survey, (id) => this.answerTypes.get(id));
+		if (diagnostics.length) throw new DefinitionError(diagnostics);
+		this.current = survey;
+		this.rememberAnswerTypes(survey);
 		const serialized = survey.serialize();
-		this._undoRedo = new SurveyEditorUndoRedo(stripAssetsFromSurveySnapshot(serialized), undoRedoConfig, meta, serialized.assets);
+		this._history = new SurveyEditorUndoRedo(stripAssets(serialized), config, meta, serialized.assets);
 	}
-	/** Returns an immutable copy of the current survey state. */
 	get survey() {
-		const serialized = this._survey.serialize();
-		const registry = this._pluginRegistry ?? this._survey.getPluginRegistry();
-		return Survey.fromJson(serialized, registry);
+		return this.current;
+	}
+	get history() {
+		return this._history;
+	}
+	getAnswerTypes() {
+		return [...this.answerTypes];
 	}
 	get hasUncommittedChanges() {
-		return this._hasUncommittedChanges;
+		return this.pendingSurvey || this.pendingAssets.length > 0;
 	}
-	get undoRedo() {
-		return this._undoRedo;
+	get hasCommittedChanges() {
+		return this.history.getCurrentIndex() > 0;
 	}
-	commit(meta) {
-		if (!this._hasUncommittedChanges) return;
-		this._undoRedo.commit(stripAssetsFromSurveySnapshot(this._survey.serialize()), meta);
-		this._hasUncommittedChanges = false;
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
 	}
-	restoreHistoryState(snapshot, assets) {
-		this._survey = Survey.fromJson(mergeSurveySnapshotWithAssets(snapshot, assets), this._pluginRegistry);
+	notify() {
+		this.listeners.forEach((listener) => listener());
+	}
+	rememberAnswerTypes(survey) {
+		if (this.rememberedSlots === survey.slots) return;
+		for (const slot of survey.slots.definitions) this.answerTypes.set(slot.slotId, slot.valueType);
+		this.rememberedSlots = survey.slots;
+	}
+	publish(next) {
+		this.current = next;
+		if (this.actionDepth) return;
+		this.rememberAnswerTypes(next);
+		this.mutationEpoch++;
+		this.notify();
+	}
+	trackPending(next, meta) {
+		this.pendingSurvey = !equal(stripAssets(next.data), this.history.getCurrentState());
+		const previous = this.history.getCurrentAssets() ?? {}, assets = next.data.assets ?? {};
+		this.pendingAssets = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(assets)])].filter((id) => !equal(ownValue(previous, id), ownValue(assets, id))).map((assetId) => ({
+			assetId,
+			prev: ownValue(previous, assetId),
+			next: ownValue(assets, assetId)
+		}));
+		this.pendingMeta ??= meta;
+	}
+	accept(next, meta, staged = false) {
+		if (equal(next.data, this.current.data)) return;
+		assertStableAnswerTypes(this.current, next);
+		if (this.current.slots !== next.slots) {
+			const diagnostics = answerTypeDiagnostics(next, (id) => this.answerTypes.get(id));
+			if (diagnostics.length) throw new DefinitionError(diagnostics);
+			const existing = new Set(getDefaultProjectionDiagnostics(this.current).flatMap((issue) => issue.code === "duplicate-header" ? [issue.header] : []));
+			const introduced = getDefaultProjectionDiagnostics(next).filter((issue) => issue.code === "duplicate-header" && !existing.has(issue.header));
+			if (introduced.length) throw new Error(introduced.map((issue) => issue.message).join("\n"));
+		}
+		if (!this.fieldWriteDepth && !this.actionDepth && !staged) {
+			const pending = this.current;
+			this.commitIfNeeded();
+			if (this.current !== pending) {
+				const metadata = /* @__PURE__ */ new Map();
+				for (const item of next.data.surveyItems) {
+					const before = pending.getItem(item.id)?.editorMetadata;
+					const committed = this.current.getItem(item.id)?.editorMetadata;
+					if (committed && equal(item.editorMetadata, before) && !equal(before, committed)) metadata.set(item.id, committed);
+				}
+				next = next.withItemEditorMetadata(metadata);
+			}
+		}
+		const baseline = this.current;
+		const pending = {
+			survey: this.pendingSurvey,
+			assets: this.pendingAssets,
+			meta: this.pendingMeta
+		};
+		try {
+			this.trackPending(next, meta);
+			this.current = next;
+			if (!this.fieldWriteDepth && !this.actionDepth && !staged) this.recordCommit(meta);
+		} catch (error) {
+			this.current = baseline;
+			this.pendingSurvey = pending.survey;
+			this.pendingAssets = pending.assets;
+			this.pendingMeta = pending.meta;
+			throw error;
+		}
+		this.publish(this.current);
+	}
+	transact(meta, operation) {
+		const draft = this.current.serialize();
+		const hadLocales = this.current.locales.length > 0;
+		operation(draft);
+		const first = Object.keys(draft.translations ?? {})[0];
+		if (!hadLocales && first !== void 0) draft.defaultLocale ??= first;
+		const next = Survey.parse(draft, this.current.registry, { admission: "draft" });
+		new SurveyStateGraph(next, { admission: "draft" });
+		this.accept(next, meta);
+	}
+	/** Synchronous compound UI action: validated writes, one publication/history entry, rollback on failure. */
+	runAction(operation) {
+		if (!this.actionDepth) this.commitIfNeeded();
+		const baseline = this.current;
+		const pending = {
+			survey: this.pendingSurvey,
+			assets: this.pendingAssets,
+			meta: this.pendingMeta,
+			actionMeta: this.actionMeta
+		};
+		this.actionDepth++;
+		let result;
+		try {
+			result = operation();
+			if (result && typeof result === "object" && "then" in result) throw new Error("Editor actions must be synchronous");
+			assertStableAnswerTypes(baseline, this.current);
+		} catch (error) {
+			this.current = baseline;
+			this.pendingSurvey = pending.survey;
+			this.pendingAssets = pending.assets;
+			this.pendingMeta = pending.meta;
+			this.actionMeta = pending.actionMeta;
+			throw error;
+		} finally {
+			this.actionDepth--;
+		}
+		if (!this.actionDepth) {
+			const meta = this.actionMeta ?? this.pendingMeta ?? { label: "Edit survey" };
+			this.actionMeta = void 0;
+			const changed = !equal(baseline.data, this.current.data);
+			if (!changed) {
+				this.current = baseline;
+				this.pendingSurvey = pending.survey;
+				this.pendingAssets = pending.assets;
+				this.pendingMeta = pending.meta;
+			}
+			if (changed) {
+				try {
+					this.recordCommit(meta);
+				} catch (error) {
+					this.current = baseline;
+					this.pendingSurvey = pending.survey;
+					this.pendingAssets = pending.assets;
+					this.pendingMeta = pending.meta;
+					this.actionMeta = pending.actionMeta;
+					throw error;
+				}
+				this.publish(this.current);
+			}
+		}
+		return result;
+	}
+	getLocalizedContent(ref, locale) {
+		return readLocalizationContent(this.current, ref, locale);
+	}
+	setLocalizedContent(ref, locale, content, meta = { label: "Edit translated content" }) {
+		let next = this.current.withLocalizationContent(ref, locale, content);
+		if (!this.current.locales.length && next.locales.length && next.data.defaultLocale === void 0) next = next.withDefaultLocale(next.locales[0]);
+		this.accept(next, meta);
+	}
+	/** Reuses the editor's field session boundary; no separate editable survey or history. */
+	beginFieldEdit(itemId) {
+		if (this.hasUncommittedChanges || this.actionDepth) throw new Error("Finish pending changes before editing a field");
+		if (itemId && !this.current.data.surveyItems.some((item) => item.id === itemId)) throw new Error(`Unknown item '${itemId}'`);
+		let expectedEpoch = this.mutationEpoch;
+		const history = this.history, index = history.getCurrentIndex();
+		const owns = () => this.mutationEpoch === expectedEpoch && this.history === history && history.getCurrentIndex() === index;
+		const run = (write) => {
+			if (!owns()) throw new Error("Field edit was superseded by another action");
+			this.fieldWriteDepth++;
+			try {
+				return write();
+			} finally {
+				this.fieldWriteDepth--;
+				expectedEpoch = this.mutationEpoch;
+			}
+		};
+		return {
+			run,
+			reconcile: (restoreValue) => {
+				if (!owns()) return false;
+				if (restoreValue) run(restoreValue);
+				this.restoreHistoryState(history.getCurrentState());
+				expectedEpoch = this.mutationEpoch;
+				return true;
+			}
+		};
+	}
+	recordCommit(meta) {
+		if (!this.hasUncommittedChanges) return false;
+		if (this.pendingSurvey) {
+			const stamped = timestampEditedItems(this.history.getCurrentState(), this.current);
+			this.history.commit(stripAssets(stamped.serialize()), meta, this.pendingAssets);
+			this.current = stamped;
+		} else this.history.commitAssetChange(this.pendingAssets, meta);
+		this.pendingSurvey = false;
+		this.pendingAssets = [];
+		this.pendingMeta = void 0;
+		this.mutationEpoch++;
+		return true;
+	}
+	commit(meta) {
+		if (this.actionDepth) {
+			this.actionMeta = meta;
+			return;
+		}
+		if (this.recordCommit(meta)) this.notify();
 	}
 	commitIfNeeded() {
-		if (this._hasUncommittedChanges) this.commit({
+		this.commit(this.pendingMeta ?? {
 			label: "Latest content changes",
 			source: CommitSource.SYSTEM
 		});
 	}
+	restoreHistoryState(snapshot) {
+		const assets = this.history.getCurrentAssets();
+		const next = Survey.parse({
+			...snapshot,
+			...assets ? { assets } : {}
+		}, this.current.registry, {
+			previous: this.current,
+			admission: "draft"
+		});
+		this.pendingSurvey = false;
+		this.pendingAssets = [];
+		this.pendingMeta = void 0;
+		this.publish(next);
+	}
 	undo() {
-		if (this._hasUncommittedChanges) {
-			this.restoreHistoryState(this._undoRedo.getCurrentState(), this._undoRedo.getCurrentAssets());
-			this._hasUncommittedChanges = false;
+		if (this.actionDepth) throw new Error("History navigation cannot run inside an edit action");
+		if (this.hasUncommittedChanges) {
+			this.restoreHistoryState(this.history.getCurrentState());
 			return true;
-		} else {
-			const previousState = this._undoRedo.undo();
-			if (previousState) {
-				this.restoreHistoryState(previousState, this._undoRedo.getCurrentAssets());
-				this._hasUncommittedChanges = false;
-				return true;
-			}
-			return false;
 		}
+		const value = this.history.undo();
+		if (!value) return false;
+		this.restoreHistoryState(value);
+		return true;
 	}
 	redo() {
-		if (this._hasUncommittedChanges) return false;
-		const nextState = this._undoRedo.redo();
-		if (nextState) {
-			this.restoreHistoryState(nextState, this._undoRedo.getCurrentAssets());
-			this._hasUncommittedChanges = false;
-			return true;
-		}
-		return false;
+		if (this.actionDepth) throw new Error("History navigation cannot run inside an edit action");
+		if (this.hasUncommittedChanges) return false;
+		const value = this.history.redo();
+		if (!value) return false;
+		this.restoreHistoryState(value);
+		return true;
 	}
-	/**
-	* Jump to a specific index in the history (can go forward or backward)
-	*/
-	jumpToIndex(targetIndex) {
-		if (this._hasUncommittedChanges) return false;
-		const targetState = this._undoRedo.jumpToIndex(targetIndex);
-		if (targetState) {
-			this.restoreHistoryState(targetState, this._undoRedo.getCurrentAssets());
-			this._hasUncommittedChanges = false;
-			return true;
-		}
-		return false;
+	jumpToIndex(index) {
+		if (this.actionDepth) throw new Error("History navigation cannot run inside an edit action");
+		if (this.hasUncommittedChanges) return false;
+		const value = this.history.jumpToIndex(index);
+		if (!value) return false;
+		this.restoreHistoryState(value);
+		return true;
 	}
 	canUndo() {
-		return this._hasUncommittedChanges || this._undoRedo.canUndo();
+		return this.hasUncommittedChanges || this.history.canUndo();
 	}
 	canRedo() {
-		return !this._hasUncommittedChanges && this._undoRedo.canRedo();
+		return !this.hasUncommittedChanges && this.history.canRedo();
 	}
 	getUndoMeta() {
-		if (this._hasUncommittedChanges) return {
-			label: "Latest content changes",
-			source: CommitSource.SYSTEM
-		};
-		return this._undoRedo.getUndoMeta();
+		return this.hasUncommittedChanges ? this.pendingMeta ?? null : this.history.getUndoMeta();
 	}
 	getRedoMeta() {
-		if (this._hasUncommittedChanges) return null;
-		return this._undoRedo.getRedoMeta();
+		return this.hasUncommittedChanges ? null : this.history.getRedoMeta();
 	}
 	getMemoryUsage() {
-		return this._undoRedo.getMemoryUsage();
+		return this.history.getMemoryUsage();
 	}
 	getUndoRedoConfig() {
-		return this._undoRedo.getConfig();
+		return this.history.getConfig();
 	}
-	/**
-	* Get committed changes after the initial editor state up to the current undo/redo position.
-	*/
 	getCommitsSinceInitial() {
-		return this._undoRedo.getCommitsSinceInitial();
+		return this.history.getCommitsSinceInitial();
 	}
-	/**
-	* Serialize the SurveyEditor state to JSON
-	* @returns A JSON-serializable object containing the complete editor state
-	*/
 	toJson() {
 		return {
-			version: "1.0.0",
-			survey: this._survey.serialize(),
-			undoRedo: this._undoRedo.serialize(),
-			hasUncommittedChanges: this._hasUncommittedChanges
+			version: 2,
+			survey: this.current.serialize(),
+			undoRedo: structuredClone(this.history.serialize()),
+			hasUncommittedChanges: this.hasUncommittedChanges,
+			answerTypes: this.getAnswerTypes()
 		};
 	}
-	/**
-	* Create a new SurveyEditor instance from JSON data
-	* @param jsonData The serialized editor state
-	* @param pluginRegistry Optional plugin registry for deserializing survey state (required when survey contains custom item types)
-	* @returns A new SurveyEditor instance with the restored state
-	*/
-	static fromJson(jsonData, pluginRegistry) {
-		if (!jsonData.survey) throw new Error("Invalid object: survey is required");
-		if (!jsonData.undoRedo) throw new Error("Invalid object: undoRedo is required");
-		if (typeof jsonData.hasUncommittedChanges !== "boolean") throw new Error("Invalid object: hasUncommittedChanges must be a boolean");
-		if (jsonData.version && !jsonData.version.startsWith("1.")) console.warn(`Warning: Loading SurveyEditor with version ${jsonData.version}, current version is 1.0.0`);
-		const editor = new SurveyEditor(Survey.fromJson(jsonData.survey, pluginRegistry), { pluginRegistry });
-		editor._undoRedo = SurveyEditorUndoRedo.deserialize({
-			...jsonData.undoRedo,
-			history: jsonData.undoRedo.history.map((entry) => "survey" in entry ? {
-				...entry,
-				survey: stripAssetsFromSurveySnapshot(entry.survey)
-			} : entry)
-		}, jsonData.survey.assets);
-		editor._hasUncommittedChanges = JSON.stringify(stripAssetsFromSurveySnapshot(jsonData.survey)) !== JSON.stringify(editor._undoRedo.getCurrentState());
+	static fromJson(input, registry) {
+		const data = createEditorSessionSchema(registry).parse(input);
+		const answerTypes = new Map(data.answerTypes);
+		const checkAnswerTypes = (survey) => {
+			const diagnostics = answerTypeDiagnostics(survey, (id) => answerTypes.get(id));
+			if (diagnostics.length) throw new DefinitionError(diagnostics);
+			for (const slot of survey.slots.definitions) if (!answerTypes.has(slot.slotId)) throw new Error(`Stored answer type is missing for '${slot.slotId}'`);
+		};
+		let historySurvey;
+		let previous;
+		let currentHistoryRevision;
+		const assets = structuredClone(data.undoRedo.initialAssets ?? {});
+		for (const [index, entry] of data.undoRedo.history.entries()) {
+			for (const patch of entry.changes ?? []) {
+				if (!equal(ownValue(assets, patch.assetId), patch.prev)) throw new Error(`Inconsistent asset history for '${patch.assetId}'`);
+				if (patch.next) setOwnValue(assets, patch.assetId, patch.next);
+				else delete assets[patch.assetId];
+			}
+			if (entry.kind === "survey-snapshot") {
+				if (entry.survey.assets !== void 0) throw new Error("History snapshots must use the shared asset history");
+				historySurvey = entry.survey;
+			}
+			if (!historySurvey) throw new Error("History requires an initial survey snapshot");
+			const snapshot = Survey.parse({
+				...historySurvey,
+				...Object.keys(assets).length ? { assets } : {}
+			}, registry, {
+				previous,
+				admission: "draft"
+			});
+			if (snapshot.slots !== previous?.slots) new SurveyStateGraph(snapshot, { admission: "draft" });
+			checkAnswerTypes(snapshot);
+			previous = snapshot;
+			if (index === data.undoRedo.currentIndex) currentHistoryRevision = snapshot;
+		}
+		const editor = new SurveyEditor(Survey.parse(data.survey, registry, {
+			previous: currentHistoryRevision,
+			admission: "draft"
+		}));
+		if (editor.survey.slots !== currentHistoryRevision?.slots) new SurveyStateGraph(editor.survey, { admission: "draft" });
+		checkAnswerTypes(editor.survey);
+		editor.answerTypes = answerTypes;
+		editor._history = SurveyEditorUndoRedo.deserialize(data.undoRedo);
+		editor.trackPending(editor.current);
+		if (editor.hasUncommittedChanges !== data.hasUncommittedChanges) throw new Error("Stored pending-edit state does not match the current history revision");
 		return editor;
 	}
-	markAsModified() {
-		this._hasUncommittedChanges = true;
-	}
-	createEditorTimestamp() {
-		return (/* @__PURE__ */ new Date()).toISOString();
+	getAsset(id) {
+		return structuredClone(ownValue(this.current.data.assets, id));
 	}
-	touchItemModifiedMetadata(itemId, timestamp = this.createEditorTimestamp()) {
-		const item = this._survey.surveyItems.get(itemId);
-		if (!item) return;
-		item.setModifiedAt(timestamp);
+	getAssets() {
+		return new Map(Object.entries(structuredClone(this.current.data.assets ?? {})));
 	}
 	addItem(target, item, content) {
-		if (this._survey.surveyItems.has(item.id)) throw new Error(`Item with id '${item.id}' already exists in the survey`);
-		this.markAsModified();
-		const timestamp = this.createEditorTimestamp();
-		let parentGroup;
-		if (!target) {
-			const rootItem = this._survey.rootItem;
-			if (!rootItem) throw new Error("No root group found in survey");
-			if (!(rootItem instanceof GroupItemCore)) throw new Error("Root item is not a group item");
-			parentGroup = rootItem;
-		} else {
-			const targetItem = this._survey.surveyItems.get(target.parentId);
-			if (!targetItem) throw new Error(`Parent item with id '${target.parentId}' not found`);
-			if (!(targetItem instanceof GroupItemCore)) throw new Error(`Parent item '${target.parentId}' is not a group item (${targetItem.type})`);
-			parentGroup = targetItem;
-		}
-		if (parentGroup.hasChild(item.id)) throw new Error(`Item ${item.id} already in this group`);
-		const siblings = Array.from(this._survey.surveyItems.values()).filter((sItem) => parentGroup.items?.includes(sItem.id));
-		let counter = 1;
-		const originalKey = item.key;
-		let uniqueKey = originalKey;
-		while (siblings.some((sibling) => sibling.key === uniqueKey)) {
-			uniqueKey = `${originalKey}_${counter}`;
-			counter++;
+		this.insertItemTree(target, item.id, [item], content);
+	}
+	/** Validate a preset's entire flow subtree together, including forward references. */
+	insertItemTree(target, rootItemId, items, content, meta = { label: "Add item" }) {
+		if (!items.some((item) => item.id === rootItemId)) throw new Error("Preset root is missing");
+		const byId = new Map(items.map((item) => [item.id, item]));
+		if (byId.size !== items.length) throw new Error("Duplicate preset item identity");
+		const visited = /* @__PURE__ */ new Set();
+		const pending = [rootItemId];
+		while (pending.length) {
+			const id = pending.pop();
+			const item = byId.get(id);
+			if (!item || visited.has(id)) throw new Error("Preset must be a self-contained flow tree");
+			visited.add(id);
+			if (item.itemType === "group") pending.push(...item.config.items);
 		}
-		let insertIndex;
-		if (target?.index !== void 0) insertIndex = Math.min(target.index, parentGroup.items.length);
-		else insertIndex = parentGroup.items.length;
-		item.updateRawItem({
-			...item.rawItem,
-			key: uniqueKey
+		if (visited.size !== items.length) throw new Error("Preset contains disconnected items");
+		this.transact(meta, (draft) => {
+			const parent = draft.surveyItems.find((candidate) => candidate.id === target.parentId);
+			if (parent?.itemType !== "group") throw new Error("Item target must be a group");
+			if (target.index !== void 0 && (!Number.isInteger(target.index) || target.index < 0)) throw new Error("Invalid item insertion index");
+			parent.config.items.splice(Math.min(target.index ?? parent.config.items.length, parent.config.items.length), 0, rootItemId);
+			draft.surveyItems.push(...structuredClone(items));
+			if (content) {
+				draft.translations ??= {};
+				const translation = ownValue(draft.translations, content.locale) ?? { content: {} };
+				setOwnValue(draft.translations, content.locale, translation);
+				for (const [owner, roles] of Object.entries(content.content)) {
+					if (this.current.owners.has(owner)) throw new Error(`Initial localized owner '${owner}' already exists`);
+					setOwnValue(translation.content, owner, structuredClone(roles));
+				}
+			}
 		});
-		item.setCreatedAt(timestamp);
-		item.setModifiedAt(timestamp);
-		this._survey.surveyItems.set(item.id, item);
-		parentGroup.addChild(item.id, insertIndex);
-		this.touchItemModifiedMetadata(parentGroup.id, timestamp);
-		if (content) this._survey.translations.setItemTranslations(item.id, content);
-	}
-	removeItem(itemId, nested = false) {
-		this.markAsModified();
-		const timestamp = this.createEditorTimestamp();
-		const item = this._survey.surveyItems.get(itemId);
-		if (!item) return false;
-		const parentItem = this._survey.getParentItem(itemId);
-		if (!parentItem) throw new Error(`Item with id '${itemId}' is the root item`);
-		if (item instanceof GroupItemCore) for (const childId of item.getChildrenIds()) this.removeItem(childId, true);
-		this._survey.surveyItems.delete(itemId);
-		this._survey.translations?.onItemDeleted(itemId);
-		if (!nested) {
-			parentItem.removeChild(itemId);
-			this.touchItemModifiedMetadata(parentItem.id, timestamp);
-		}
-		return true;
 	}
-	moveItem(itemId, newTarget) {
-		this.markAsModified();
-		const timestamp = this.createEditorTimestamp();
-		const item = this._survey.surveyItems.get(itemId);
-		if (!item) throw new Error(`Item with id '${itemId}' not found`);
-		const targetItem = this._survey.surveyItems.get(newTarget.parentId);
-		if (!targetItem) throw new Error(`Target parent with id '${newTarget.parentId}' not found`);
-		if (!(targetItem instanceof GroupItemCore)) throw new Error(`Target parent '${newTarget.parentId}' is not a group item (${targetItem.type})`);
-		if (this._survey.isDescendantOf(newTarget.parentId, itemId)) throw new Error(`Cannot move item '${itemId}' to its descendant '${newTarget.parentId}'`);
-		const currentParentItem = this._survey.getParentItem(itemId);
-		if (currentParentItem?.id === newTarget.parentId) throw new Error(`Item '${itemId}' is already in the target parent '${newTarget.parentId}'`);
-		if (currentParentItem) {
-			const currentParentGroup = currentParentItem;
-			currentParentGroup.removeChild(itemId);
-			this.touchItemModifiedMetadata(currentParentGroup.id, timestamp);
-		}
-		const targetGroup = targetItem;
-		const siblings = Array.from(this._survey.surveyItems.values()).filter((sItem) => targetGroup.hasChild(sItem.id));
-		let counter = 1;
-		let uniqueKey = item.key;
-		while (siblings.some((sibling) => sibling.key === uniqueKey)) {
-			uniqueKey = `${item.key}_${counter}`;
-			counter++;
-		}
-		if (uniqueKey !== item.key) item.updateRawItem({
-			...item.rawItem,
-			key: uniqueKey
+	getItemDataCopy(itemId) {
+		const item = this.current.getItem(itemId);
+		if (!item) throw new Error(`Unknown item '${itemId}'`);
+		return structuredClone(item);
+	}
+	updateItem(itemId, update, meta = { label: "Edit item" }) {
+		const existing = this.current.getItem(itemId);
+		if (!existing) throw new Error(`Unknown item '${itemId}'`);
+		if (update.id !== void 0 && update.id !== itemId) throw new Error("Updating an item cannot change its identity");
+		this.transact(meta, (draft) => {
+			const index = draft.surveyItems.findIndex((item) => item.id === itemId);
+			const next = {
+				...existing,
+				...update,
+				id: itemId
+			};
+			setAt(draft, ["surveyItems", index], next);
 		});
-		const insertIndex = newTarget.index !== void 0 ? Math.min(newTarget.index, targetGroup.items.length) : targetGroup.items.length;
-		targetGroup.addChild(itemId, insertIndex);
-		this.touchItemModifiedMetadata(targetGroup.id, timestamp);
-		this.touchItemModifiedMetadata(itemId, timestamp);
-		return true;
 	}
-	/** Move several independent item subtrees as one ordered block. */
-	moveItems(itemIds, newTarget) {
-		const requestedIds = [...new Set(itemIds)];
-		const selectedIds = requestedIds.filter((itemId) => !requestedIds.some((candidateId) => candidateId !== itemId && this._survey.isDescendantOf(itemId, candidateId)));
-		if (selectedIds.length === 0) return false;
-		const targetGroup = this._survey.surveyItems.get(newTarget.parentId);
-		if (!(targetGroup instanceof GroupItemCore)) throw new Error(`Target parent '${newTarget.parentId}' is not a group item`);
-		const entries = selectedIds.map((itemId) => {
-			const item = this._survey.surveyItems.get(itemId);
-			const parent = this._survey.getParentItem(itemId);
-			if (!item || !(parent instanceof GroupItemCore)) throw new Error(`Item '${itemId}' cannot be moved`);
-			if (itemId === newTarget.parentId || this._survey.isDescendantOf(newTarget.parentId, itemId)) throw new Error(`Cannot move item '${itemId}' into its own subtree`);
-			return {
-				item,
-				parent,
-				index: parent.items.indexOf(itemId)
-			};
+	/** Repair answer reads only; state targets and previous-survey prefill references are distinct. */
+	rewriteAnswerReferences(replacements) {
+		let changed = 0;
+		const raw = transformAnnotated(this.current.registry.surveySchema, this.current.data, ({ annotation, value }) => {
+			if (annotation.kind !== "expression") return value;
+			return transformExpression(expressionSchema.parse(value), {
+				const: (node) => node,
+				function: (node) => node,
+				contextVariable: (node) => node,
+				ownerState: (node) => node,
+				responseVariable: (node) => {
+					const slotId = ownValue(replacements, node.variableRef.slotId);
+					if (!slotId || slotId === node.variableRef.slotId) return node;
+					changed++;
+					return {
+						...node,
+						variableRef: {
+							...node.variableRef,
+							slotId
+						}
+					};
+				}
+			});
 		});
-		const order = /* @__PURE__ */ new Map();
-		let orderIndex = 0;
-		const visit = (group) => {
-			for (const childId of group.items) {
-				order.set(childId, orderIndex++);
-				const child = this._survey.surveyItems.get(childId);
-				if (child instanceof GroupItemCore) visit(child);
-			}
-		};
-		const root = this._survey.rootItem;
-		if (root) visit(root);
-		entries.sort((a, b) => (order.get(a.item.id) ?? 0) - (order.get(b.item.id) ?? 0));
-		const selectedSet = new Set(entries.map(({ item }) => item.id));
-		const requestedIndex = newTarget.index ?? targetGroup.items.length;
-		const removedBeforeTarget = targetGroup.items.slice(0, requestedIndex).filter((id) => selectedSet.has(id)).length;
-		const insertionIndex = Math.max(0, requestedIndex - removedBeforeTarget);
-		const timestamp = this.createEditorTimestamp();
-		this.markAsModified();
-		for (const { item, parent } of entries) {
-			parent.removeChild(item.id);
-			this.touchItemModifiedMetadata(parent.id, timestamp);
+		if (changed) {
+			const next = Survey.parse(raw, this.current.registry, { admission: "draft" });
+			new SurveyStateGraph(next, { admission: "draft" });
+			this.accept(next, { label: "Repair answer references" });
 		}
-		const siblingKeys = new Set(targetGroup.items.map((id) => this._survey.surveyItems.get(id)?.key).filter((key) => Boolean(key)));
-		entries.forEach(({ item }, offset) => {
-			const originalKey = item.key;
-			let uniqueKey = originalKey;
-			let counter = 1;
-			while (siblingKeys.has(uniqueKey)) uniqueKey = `${originalKey}_${counter++}`;
-			if (uniqueKey !== item.key) item.updateRawItem({
-				...item.rawItem,
-				key: uniqueKey
-			});
-			siblingKeys.add(uniqueKey);
-			targetGroup.addChild(item.id, insertionIndex + offset);
-			this.touchItemModifiedMetadata(item.id, timestamp);
+		return changed;
+	}
+	renameResponseVariables(edits) {
+		return this.updateResponseSettings(edits, []);
+	}
+	updateResponseSettings(naming, settings) {
+		const preview = previewResponseSettings(this.current, naming, settings);
+		const next = Survey.parse(preview.survey, this.current.registry, { admission: "draft" });
+		new SurveyStateGraph(next, { admission: "draft" });
+		this.accept(next, { label: "Edit response variables" });
+		return preview.changes;
+	}
+	addLocale(locale) {
+		if (!locale.trim()) throw new Error("A locale is required");
+		if (Object.hasOwn(this.current.data.translations ?? {}, locale)) return false;
+		this.transact({ label: `Add language: ${locale}` }, (draft) => {
+			draft.translations ??= {};
+			setOwnValue(draft.translations, locale, { content: {} });
 		});
-		this.touchItemModifiedMetadata(targetGroup.id, timestamp);
 		return true;
 	}
-	/**
-	* Get a deep copy of an item's raw data.
-	* The returned object is independent of the survey—mutating it will not affect the survey.
-	* Use this when you need to edit an item in a form or pass it to updateItem after modifications.
-	*
-	* @param itemId - The ID of the item to copy
-	* @returns A deep copy of the item's RawSurveyItem data
-	* @throws Error if the item is not found
-	*/
-	getItemDataCopy(itemId) {
-		const item = this._survey.surveyItems.get(itemId);
-		if (!item) throw new Error(`Item with id '${itemId}' not found`);
-		return JSON.parse(JSON.stringify(item.rawItem));
+	removeLocale(locale) {
+		if (!Object.hasOwn(this.current.data.translations ?? {}, locale)) return false;
+		this.transact({ label: `Remove language: ${locale}` }, (draft) => {
+			delete draft.translations?.[locale];
+			if (draft.defaultLocale === locale) {
+				const next = Object.keys(draft.translations ?? {})[0];
+				if (next === void 0) delete draft.defaultLocale;
+				else draft.defaultLocale = next;
+			}
+		});
+		return true;
 	}
-	/**
-	* Update an item's data in the survey.
-	* Can update common attributes (displayConditions, disabledConditions, validations, etc.)
-	* as well as type-specific config.
-	*
-	* Use getItemDataCopy to obtain an editable copy, modify it, then pass it here.
-	* Alternatively, pass a Partial to merge specific fields (top-level keys only;
-	* e.g. config replaces the entire config object).
-	*
-	* @param itemId - The ID of the item to update (must match data.id if provided)
-	* @param rawItemData - Full RawSurveyItem or Partial to merge. The id cannot be changed.
-	*/
-	updateItem(itemId, rawItemData) {
-		const existingItem = this._survey.surveyItems.get(itemId);
-		if (!existingItem) throw new Error(`Item with id '${itemId}' not found`);
-		if ("id" in rawItemData && rawItemData.id !== void 0 && rawItemData.id !== itemId) throw new Error(`Cannot change item id from '${itemId}' to '${rawItemData.id}'`);
-		const merged = {
-			...existingItem.rawItem,
-			...rawItemData,
-			id: itemId
-		};
-		const newKey = merged.key ?? existingItem.key;
-		const parentGroup = this._survey.getParentItem(itemId);
-		if (parentGroup) {
-			const siblingWithSameKey = (parentGroup.items ?? []).filter((id) => id !== itemId).map((id) => this._survey.surveyItems.get(id)).find((s) => s !== void 0 && s.key === newKey);
-			if (siblingWithSameKey) throw new Error(`Key '${newKey}' is already in use by sibling item '${siblingWithSameKey.id}'`);
-		}
-		const newItem = this._survey.createItemFromRaw({
-			...merged,
-			editorMetadata: existingItem.rawItem.editorMetadata
+	/** Sets the source language that exports and hosts fall back to. */
+	setDefaultLocale(locale) {
+		if (!Object.hasOwn(this.current.data.translations ?? {}, locale)) throw new Error(`Unknown locale '${locale}'`);
+		if (this.current.data.defaultLocale === locale) return false;
+		this.transact({ label: `Set default language: ${locale}` }, (draft) => {
+			draft.defaultLocale = locale;
 		});
-		newItem.setModifiedAt(this.createEditorTimestamp());
-		this._survey.surveyItems.set(itemId, newItem);
-		this.markAsModified();
-	}
-	updateItemTranslations(itemId, updatedContent) {
-		const item = this._survey.surveyItems.get(itemId);
-		if (!item) return false;
-		this.markAsModified();
-		item.setModifiedAt(this.createEditorTimestamp());
-		this._survey.translations.setItemTranslations(itemId, updatedContent);
 		return true;
 	}
-	/**
-	* Update survey-level translations that are not tied to specific items.
-	* Use these for survey card, navigation, validation messages, etc.
-	*/
 	updateSurveyTranslations(updates) {
-		this.markAsModified();
-		if (updates.surveyCard) this._survey.translations.setSurveyCardContent(updates.surveyCard.locale, updates.surveyCard.content);
-		if (updates.navigation) this._survey.translations.setNavigationContent(updates.navigation.locale, updates.navigation.content);
-		if (updates.validationMessages) this._survey.translations.setValidationMessages(updates.validationMessages.locale, updates.validationMessages.content);
-	}
-	/** Add an empty survey locale so it can be authored before translated content exists. */
-	addLocale(locale) {
-		const added = this._survey.translations.addLocale(locale);
-		if (added) this.markAsModified();
-		return added;
-	}
-	/** Remove a locale and every survey- and item-level translation stored for it. */
-	removeLocale(locale) {
-		if (!this._survey.locales.includes(locale)) return false;
-		this._survey.translations.removeLocale(locale);
-		this.markAsModified();
-		return true;
+		this.transact({ label: "Edit survey wording" }, (draft) => {
+			const apply = (surface, update) => {
+				if (!update) return;
+				if (!update.locale.trim()) throw new Error("A locale is required");
+				const existing = ownValue(draft.translations, update.locale);
+				if (update.content === void 0 && existing?.[surface] === void 0) return;
+				draft.translations ??= {};
+				const translation = existing ?? { content: {} };
+				setOwnValue(draft.translations, update.locale, translation);
+				if (update.content === void 0) delete translation[surface];
+				else translation[surface] = structuredClone(update.content);
+			};
+			apply("surveyCardContent", updates.surveyCard);
+			apply("navigationContent", updates.navigation);
+			apply("validationMessages", updates.validationMessages);
+		});
 	}
-	/**
-	* Get maxItemsPerPage immutably (returns a copy).
-	*/
 	getMaxItemsPerPage() {
-		const val = this._survey.maxItemsPerPage;
-		return val ? { ...val } : void 0;
+		return structuredClone(this.current.data.maxItemsPerPage);
 	}
-	/**
-	* Update maxItemsPerPage.
-	*/
 	updateMaxItemsPerPage(value) {
-		this.markAsModified();
-		this._survey.maxItemsPerPage = value ? { ...value } : void 0;
+		this.transact({ label: "Change page size" }, (draft) => {
+			if (value === void 0) delete draft.maxItemsPerPage;
+			else draft.maxItemsPerPage = structuredClone(value);
+		});
 	}
-	/**
-	* Get metadata immutably (returns a copy).
-	*/
 	getMetadata() {
-		const val = this._survey.metadata;
-		return val ? { ...val } : void 0;
+		return structuredClone(this.current.data.metadata);
 	}
-	/**
-	* Update metadata.
-	*/
 	updateMetadata(metadata) {
-		this.markAsModified();
-		this._survey.metadata = metadata ? { ...metadata } : void 0;
+		this.transact({ label: "Edit survey metadata" }, (draft) => {
+			if (metadata === void 0) delete draft.metadata;
+			else draft.metadata = structuredClone(metadata);
+		});
 	}
-	/**
-	* Get a template value immutably (returns a deep copy).
-	*/
 	getTemplateValue(key) {
-		const val = this._survey.getTemplateValue(key);
-		return val ? structuredCloneMethod(val) : void 0;
+		return structuredClone(this.current.getTemplateValue(key));
 	}
-	/**
-	* Get all template values immutably (returns a new Map with deep-copied values).
-	*/
 	getTemplateValues() {
-		const keys = this._survey.getTemplateValueKeys();
-		const result = /* @__PURE__ */ new Map();
-		for (const key of keys) {
-			const val = this._survey.getTemplateValue(key);
-			if (val) result.set(key, structuredCloneMethod(val));
-		}
-		return result;
+		return new Map(Object.entries(structuredClone(this.current.data.templateValues ?? {})));
 	}
-	/**
-	* Add or replace a template value.
-	*/
-	setTemplateValue(key, templateValue) {
-		this.markAsModified();
-		this._survey.setTemplateValue(key, structuredCloneMethod(templateValue));
+	setTemplateValue(key, value) {
+		this.transact({ label: `Edit template: ${key}` }, (draft) => {
+			draft.templateValues ??= {};
+			setOwnValue(draft.templateValues, key, structuredClone(value));
+		});
 	}
-	/**
-	* Remove a template value.
-	*/
 	removeTemplateValue(key) {
-		this.markAsModified();
-		this._survey.deleteTemplateValue(key);
-	}
-	/**
-	* Get a survey asset immutably.
-	*/
-	getAsset(assetId) {
-		const asset = this._survey.getAsset(assetId);
-		return asset ? structuredCloneMethod(asset) : void 0;
+		this.transact({ label: `Remove template: ${key}` }, (draft) => {
+			delete draft.templateValues?.[key];
+		});
 	}
-	/**
-	* Get all survey assets immutably.
-	*/
-	getAssets() {
-		return this._survey.getAssets();
+	stageAsset(id, asset) {
+		const draft = this.current.serialize();
+		draft.assets ??= {};
+		if (asset) setOwnValue(draft.assets, id, asset);
+		else {
+			delete draft.assets[id];
+			if (!Object.keys(draft.assets).length) delete draft.assets;
+		}
+		this.accept(Survey.parse(draft, this.current.registry, { admission: "draft" }), { label: `Update asset: ${id}` }, true);
 	}
-	/**
-	* Add or replace a survey asset.
-	*/
-	setAsset(assetId, asset) {
-		const previousAsset = this._survey.getAsset(assetId);
-		this._survey.setAsset(assetId, structuredCloneMethod(asset));
-		this._undoRedo.commitAssetChange([{
-			assetId,
-			prev: previousAsset,
-			next: structuredCloneMethod(asset)
-		}], {
-			label: `Update asset: ${assetId}`,
+	setAsset(id, asset) {
+		this.transact({
+			label: `Update asset: ${id}`,
 			source: CommitSource.USER
+		}, (draft) => {
+			draft.assets ??= {};
+			setOwnValue(draft.assets, id, asset);
 		});
 	}
-	/**
-	* Remove a survey asset.
-	*/
-	removeAsset(assetId) {
-		const previousAsset = this._survey.getAsset(assetId);
-		if (!previousAsset) return;
-		this._survey.deleteAsset(assetId);
-		this._undoRedo.commitAssetChange([{
-			assetId,
-			prev: previousAsset
-		}], {
-			label: `Remove asset: ${assetId}`,
+	removeAsset(id) {
+		this.transact({
+			label: `Remove asset: ${id}`,
 			source: CommitSource.USER
+		}, (draft) => {
+			if (draft.assets) {
+				delete draft.assets[id];
+				if (!Object.keys(draft.assets).length) delete draft.assets;
+			}
 		});
 	}
-	/**
-	* Copy a survey item and all its data to clipboard format
-	* @param itemId - The ID of the item to copy
-	* @returns Clipboard data that can be serialized to JSON for clipboard
-	*/
-	copyItem(itemId) {
-		return new ItemCopyPaste(this._survey).copyItem(itemId);
+	/** Shared insertion used by the survey catalog and a layout's element catalog. */
+	insertElement(input, target, meta = { label: "Add element" }, initialContent) {
+		const element = this.current.registry.elementSchema.parse(input);
+		const layoutTarget = target && "layoutId" in target ? target : void 0;
+		const bodyTarget = target && "bodyOwnerId" in target ? target : void 0;
+		const body = bodyTarget ? this.current.bodies.get(bodyTarget.bodyOwnerId) : void 0;
+		if (bodyTarget && !body) throw new Error(`Unknown body owner '${bodyTarget.bodyOwnerId}'`);
+		const flowTarget = target && "parentId" in target ? target : { parentId: this.current.rootId };
+		if (target?.index !== void 0 && (!Number.isInteger(target.index) || target.index < 0)) throw new Error("An insertion index must be a nonnegative integer");
+		if (!layoutTarget && !bodyTarget && this.current.getItem(flowTarget.parentId)?.itemType !== "group") throw new Error(`Target parent '${flowTarget.parentId}' is not a group item`);
+		const itemId = layoutTarget ? this.containingItem(layoutTarget.layoutId) : bodyTarget ? this.containingItem(bodyTarget.bodyOwnerId) : generateId();
+		this.transact(meta, (draft) => {
+			if (initialContent) {
+				draft.translations ??= {};
+				const translation = ownValue(draft.translations, initialContent.locale) ?? { content: {} };
+				setOwnValue(draft.translations, initialContent.locale, translation);
+				for (const [owner, roles] of Object.entries(initialContent.content)) {
+					if (this.current.owners.has(owner)) throw new Error(`Initial localized owner '${owner}' already exists`);
+					setOwnValue(translation.content, owner, structuredClone(roles));
+				}
+			}
+			if (layoutTarget) {
+				const elements = arrayAt(draft, [...this.identityPath(layoutTarget.layoutId, "layout"), "elements"]);
+				elements.splice(layoutTarget.index ?? elements.length, 0, element);
+			} else if (body && bodyTarget) {
+				const blocks = arrayAt(draft, [...body.path, "blocks"]);
+				blocks.splice(bodyTarget.index ?? blocks.length, 0, {
+					id: generateId(),
+					kind: "layout",
+					layout: {
+						mode: "automatic",
+						maxColumns: 1
+					},
+					elements: [element]
+				});
+			} else {
+				draft.surveyItems.push({
+					id: itemId,
+					itemType: "content",
+					config: { body: { blocks: [{
+						id: generateId(),
+						kind: "layout",
+						layout: {
+							mode: "automatic",
+							maxColumns: 1
+						},
+						elements: [element]
+					}] } }
+				});
+				const parent = draft.surveyItems.find((item) => item.id === flowTarget.parentId);
+				if (parent?.itemType !== "group") throw new Error("Insertion requires a flow group");
+				parent.config.items.splice(flowTarget.index ?? parent.config.items.length, 0, itemId);
+			}
+		});
+		return {
+			itemId,
+			elementId: element.id
+		};
 	}
-	/**
-	* Paste a survey item from clipboard data to a target location
-	* @param clipboardData - The clipboard data containing the item to paste
-	* @param target - Target location where to paste the item
-	* @returns The ID of the pasted item
-	*/
-	pasteItem(clipboardData, target) {
-		this.markAsModified();
-		const timestamp = this.createEditorTimestamp();
-		const itemIdsBeforePaste = new Set(this._survey.surveyItems.keys());
-		const newItemId = new ItemCopyPaste(this._survey).pasteItem(clipboardData, target);
-		const pastedItemIds = Array.from(this._survey.surveyItems.keys()).filter((itemId) => !itemIdsBeforePaste.has(itemId));
-		for (const itemId of pastedItemIds) {
-			const item = this._survey.surveyItems.get(itemId);
-			if (item) {
-				item.setCreatedAt(timestamp);
-				item.setModifiedAt(timestamp);
+	moveItem(itemId, target, meta = { label: "Move item" }) {
+		return this.moveItems([itemId], target, meta);
+	}
+	/** Retain the outline's ordered-block move semantics, publishing one validated revision. */
+	moveItems(itemIds, target, meta = { label: "Move items" }) {
+		const survey = this.current;
+		const requested = [...new Set(itemIds)];
+		if (!requested.length) return false;
+		for (const id of requested) {
+			if (!survey.getItem(id)) throw new Error(`Item with id '${id}' not found`);
+			if (id === survey.rootId) throw new Error("The root group cannot be moved");
+		}
+		const destination = survey.getItem(target.parentId);
+		if (!destination) throw new Error(`Target parent with id '${target.parentId}' not found`);
+		if (destination.itemType !== "group") throw new Error(`Target parent '${target.parentId}' is not a group item`);
+		const selected = requested.filter((id) => !requested.some((other) => other !== id && survey.isDescendantOf(id, other)));
+		for (const id of selected) if (survey.isDescendantOf(destination.id, id)) throw new Error(`Cannot move item '${id}' into its own subtree`);
+		if (target.index !== void 0 && (!Number.isInteger(target.index) || target.index < 0)) throw new Error("An insertion index must be a nonnegative integer");
+		const selectedSet = new Set(selected);
+		const ordered = [];
+		const visit = (id) => {
+			if (selectedSet.has(id)) ordered.push(id);
+			const item = survey.getItem(id);
+			if (item?.itemType === "group") item.config.items.forEach(visit);
+		};
+		visit(survey.rootId);
+		const requestedIndex = Math.min(target.index ?? destination.config.items.length, destination.config.items.length);
+		const removedBefore = destination.config.items.slice(0, requestedIndex).filter((id) => selectedSet.has(id)).length;
+		const parents = new Set(selected.map((id) => survey.getParentItem(id).id));
+		parents.add(destination.id);
+		const lists = /* @__PURE__ */ new Map();
+		for (const id of parents) {
+			const group = survey.getItem(id);
+			if (group?.itemType !== "group") throw new Error(`Unknown parent group '${id}'`);
+			lists.set(id, group.config.items.filter((child) => !selectedSet.has(child)));
+		}
+		lists.get(destination.id).splice(requestedIndex - removedBefore, 0, ...ordered);
+		if (![...lists].some(([id, children]) => {
+			const group = survey.getItem(id);
+			return group?.itemType === "group" && !equal(group.config.items, children);
+		})) return false;
+		this.transact(meta, (draft) => {
+			for (const item of draft.surveyItems) {
+				const children = lists.get(item.id);
+				if (item.itemType === "group" && children) item.config.items = children;
+			}
+		});
+		return true;
+	}
+	identityPath(id, kind) {
+		const declaration = this.current.identities.get(id);
+		if (!declaration || kind && declaration.kind !== kind) throw new Error(`Unknown ${kind ?? "identity"} '${id}'`);
+		return declaration.path.slice(0, -1);
+	}
+	containingItem(id) {
+		const declaration = this.current.identities.get(id);
+		const owner = declaration?.ownerId ? this.current.owners.get(declaration.ownerId) : void 0;
+		if (!owner) throw new Error(`No containing item for '${id}'`);
+		return owner.itemId;
+	}
+	/** Edit wording only for this element and its added/removed descendants, in existing locales. */
+	updateElement(elementId, update, meta = { label: "Edit element" }, renewOwnerIds = /* @__PURE__ */ new Map()) {
+		const path = this.identityPath(elementId, "element");
+		this.transact(meta, (draft) => {
+			const schema = this.current.registry.elementSchema;
+			const element = schema.parse(at(draft, path));
+			const before = contentOwnerIds(schema, element);
+			const elementType = element.elementType;
+			const translations = draft.translations ?? {};
+			update(element, translations);
+			if (Object.keys(translations).length || draft.translations) draft.translations = translations;
+			if (element.id !== elementId || element.elementType !== elementType) throw new Error("Element identity and type cannot change during a settings update");
+			const next = schema.parse(element);
+			const remaining = contentOwnerIds(schema, next);
+			assertElementTranslationScope(this.current.data.translations, draft.translations, /* @__PURE__ */ new Set([...before, ...remaining]));
+			for (const translation of Object.values(draft.translations ?? {})) for (const ownerId of before) if (!remaining.has(ownerId)) delete translation.content[ownerId];
+			setAt(draft, path, next);
+			for (const from of renewOwnerIds.keys()) if (from === elementId || !before.has(from) || !remaining.has(from)) throw new Error(`Cannot renew '${from}': it must be a surviving owner inside the element`);
+			if (renewOwnerIds.size) {
+				const visits = inspectAnnotated(this.current.registry.surveySchema, draft).sort((a, b) => b.path.length - a.path.length || Number(a.key) - Number(b.key));
+				for (const visit of visits) {
+					if (visit.annotation.kind === "expression") setAt(draft, visit.path, transformExpression(expressionSchema.parse(visit.value), {
+						const: (node) => node,
+						function: (node) => node,
+						contextVariable: (node) => node,
+						responseVariable: (node) => node,
+						ownerState: (node) => ({
+							...node,
+							targetRef: { ownerId: renewOwnerIds.get(node.targetRef.ownerId) ?? node.targetRef.ownerId }
+						})
+					}));
+					if (visit.annotation.kind !== "identity" && !(visit.annotation.kind === "reference" && !visit.annotation.external && (visit.annotation.target === "owner" || visit.annotation.target === "state")) || typeof visit.value !== "string") continue;
+					const to = renewOwnerIds.get(visit.value);
+					if (!to) continue;
+					if (visit.key) {
+						const parent = at(draft, visit.path.slice(0, -1));
+						if (!record(parent) || Object.hasOwn(parent, to)) throw new Error(`Cannot move owned content to '${to}'`);
+						setOwnValue(parent, to, ownValue(parent, visit.value));
+						delete parent[visit.value];
+					} else setAt(draft, visit.path, to);
+				}
 			}
+		});
+	}
+	addLayout(bodyOwnerId) {
+		const body = this.current.bodies.get(bodyOwnerId);
+		if (!body) throw new Error(`Unknown body owner '${bodyOwnerId}'`);
+		const id = generateId();
+		this.transact({ label: "Add layout" }, (draft) => {
+			arrayAt(draft, [...body.path, "blocks"]).push({
+				id,
+				kind: "layout",
+				layout: {
+					mode: "automatic",
+					maxColumns: 2
+				},
+				elements: []
+			});
+		});
+		return id;
+	}
+	addSection(bodyOwnerId) {
+		const body = this.current.bodies.get(bodyOwnerId);
+		if (!body) throw new Error(`Unknown body owner '${bodyOwnerId}'`);
+		const id = generateId();
+		this.transact({ label: "Add section" }, (draft) => {
+			arrayAt(draft, [...body.path, "blocks"]).push({
+				id,
+				kind: "section",
+				body: { blocks: [{
+					id: generateId(),
+					kind: "layout",
+					layout: {
+						mode: "automatic",
+						maxColumns: 1
+					},
+					elements: []
+				}] }
+			});
+		});
+		return id;
+	}
+	updateLayout(layoutId, layout) {
+		this.transact({ label: "Change columns" }, (draft) => setAt(draft, [...this.identityPath(layoutId, "layout"), "layout"], layout));
+	}
+	removalScope(ids) {
+		const paths = [];
+		for (const id of new Set(ids)) {
+			if (id === this.current.rootId) throw new Error("The root group cannot be removed");
+			const declaration = this.current.identities.get(id);
+			if (!declaration || ![
+				"element",
+				"layout",
+				"section",
+				"item"
+			].includes(declaration.kind)) throw new Error("Only structural nodes can be removed directly");
+			if (declaration.kind === "item") {
+				for (const item of this.current.data.surveyItems) if (this.current.isDescendantOf(item.id, id)) paths.push(this.identityPath(item.id));
+			} else paths.push(this.identityPath(id));
 		}
-		this.touchItemModifiedMetadata(target.parentId, timestamp);
-		return newItemId;
+		const roots = paths.filter((path, index) => !paths.some((other, otherIndex) => otherIndex !== index && inside(other, path) && (other.length < path.length || otherIndex < index)));
+		const includes = (path) => roots.some((root) => inside(root, path));
+		return {
+			roots,
+			owned: new Set([...this.current.identities.values()].filter((entry) => includes(entry.path)).map((entry) => entry.id)),
+			includes
+		};
+	}
+	/** Includes whole flow subtrees; deletion never silently rewrites an authored rule. */
+	deletionImpact(id) {
+		const { owned, includes } = this.removalScope(typeof id === "string" ? [id] : id);
+		return annotatedReferences(inspectAnnotated(this.current.registry.surveySchema, this.current.data)).filter((ref) => owned.has(ref.id) && !includes(ref.path) && ref.path[0] !== "translations" && !(ref.target === "item" && ref.path[0] === "surveyItems" && ref.path.includes("items")));
+	}
+	remove(id) {
+		return this.removeNodes([id]);
+	}
+	removeItem(itemId) {
+		if (!this.current.getItem(itemId)) return false;
+		return this.removeItems([itemId]);
+	}
+	removeItems(itemIds) {
+		if (itemIds.some((id) => !this.current.getItem(id))) throw new Error("Unknown flow item in removal request");
+		return this.removeNodes(itemIds);
+	}
+	removeNodes(ids) {
+		if (!ids.length) return false;
+		const { roots, owned } = this.removalScope(ids);
+		roots.sort((left, right) => {
+			for (let i = 0; i < Math.min(left.length, right.length); i++) {
+				const a = left[i], b = right[i];
+				if (a !== b) return typeof a === "number" && typeof b === "number" ? b - a : String(b).localeCompare(String(a));
+			}
+			return right.length - left.length;
+		});
+		this.transact({ label: "Remove content" }, (draft) => {
+			for (const path of roots) {
+				const index = path.at(-1);
+				if (typeof index !== "number") throw new Error("Structural content must belong to an ordered list");
+				arrayAt(draft, path.slice(0, -1)).splice(index, 1);
+			}
+			for (const item of draft.surveyItems) if (item.itemType === "group") item.config.items = item.config.items.filter((child) => !owned.has(child));
+			for (const translation of Object.values(draft.translations ?? {})) for (const owner of owned) delete translation.content[owner];
+		});
+		return true;
+	}
+	/** index is the final position after removal, as reported by composition sortables. */
+	moveElement(elementId, layoutId, index, ruleTransfer = "reject") {
+		this.moveCompositionContent(elementId, this.identityPath(elementId, "element"), [...this.identityPath(layoutId, "layout"), "elements"], layoutId, index, ruleTransfer);
+	}
+	/** Reorders/moves vertical blocks; index is the final position after removal. */
+	moveBlock(blockId, bodyOwnerId, index, ruleTransfer = "reject") {
+		const identity = this.current.identities.get(blockId);
+		if (!identity || identity.kind !== "layout" && identity.kind !== "section") throw new Error("Only layouts and sections can move between bodies");
+		const body = this.current.bodies.get(bodyOwnerId);
+		if (!body) throw new Error(`Unknown body owner '${bodyOwnerId}'`);
+		this.moveCompositionContent(blockId, this.identityPath(blockId), [...body.path, "blocks"], bodyOwnerId, index, ruleTransfer);
+	}
+	moveCompositionContent(elementId, source, destination, targetOwnerId, index, ruleTransfer) {
+		if (inside(source, destination)) throw new Error("Content cannot move into its own descendant");
+		const fromItem = this.containingItem(elementId), toItem = this.containingItem(targetOwnerId);
+		const ownedSlots = new Set(this.current.slots.definitions.filter((slot) => {
+			const owner = this.current.owners.get(slot.elementId);
+			return owner && inside(source, owner.path);
+		}).map((slot) => slot.slotId));
+		this.transact({ label: "Move content" }, (draft) => {
+			const elements = arrayAt(draft, destination);
+			if (index !== void 0 && (!Number.isInteger(index) || index < 0 || index > elements.length)) throw new Error("Invalid content insertion index");
+			const parent = arrayAt(draft, source.slice(0, -1));
+			const position = source.at(-1);
+			if (typeof position !== "number") throw new Error("Content must belong to an ordered list");
+			if (fromItem !== toItem) {
+				const oldItem = draft.surveyItems.find((item) => item.id === fromItem), newItem = draft.surveyItems.find((item) => item.id === toItem);
+				if (oldItem?.itemType !== "content" || newItem?.itemType !== "content") throw new Error("Invalid content-item move");
+				const affected = oldItem.config.validationRules?.filter((rule) => rule.targets.some((id) => ownedSlots.has(id))) ?? [];
+				if (affected.length && (ruleTransfer !== "move-with-targets" || affected.some((rule) => rule.targets.some((id) => !ownedSlots.has(id))))) throw new Error("This move changes validation-rule ownership. Move all targets with explicit ruleTransfer or repair the rules first.");
+				if (affected.length) {
+					oldItem.config.validationRules = oldItem.config.validationRules?.filter((rule) => !affected.includes(rule));
+					newItem.config.validationRules = [...newItem.config.validationRules ?? [], ...affected];
+				}
+			}
+			const [element] = parent.splice(position, 1);
+			elements.splice(index ?? elements.length, 0, element);
+		});
+	}
+	/** Move selected roots into a new group under the first root's parent, as in the outline UI. */
+	groupItems(itemIds, meta = { label: "Group selected items" }) {
+		const requested = new Set(itemIds);
+		if (!requested.size || requested.has(this.current.rootId) || [...requested].some((id) => !this.current.getItem(id))) throw new Error("Select existing non-root items to group");
+		const roots = this.current.itemOutline.map((entry) => entry.itemId).filter((id) => requested.has(id) && ![...requested].some((other) => other !== id && this.current.isDescendantOf(id, other)));
+		const parent = this.current.getParentItem(roots[0]);
+		const id = generateId();
+		this.transact(meta, (draft) => {
+			const destination = draft.surveyItems.find((item) => item.id === parent.id);
+			if (destination?.itemType !== "group") throw new Error("Grouping requires a flow parent");
+			const index = destination.config.items.indexOf(roots[0]);
+			destination.config.items.splice(index, 0, id);
+			for (const item of draft.surveyItems) if (item.itemType === "group") item.config.items = item.config.items.filter((child) => !roots.includes(child));
+			draft.surveyItems.push({
+				id,
+				itemType: "group",
+				config: { items: roots }
+			});
+		});
+		return id;
+	}
+	copyItem(itemId) {
+		return copySurveyItem(this.current, itemId);
+	}
+	pasteItem(input, target) {
+		if (this.current.getItem(target.parentId)?.itemType !== "group") throw new Error("Paste target must be a group");
+		if (target.index !== void 0 && (!Number.isInteger(target.index) || target.index < 0)) throw new Error("Invalid paste index");
+		const payload = prepareItemPaste(this.current, input);
+		this.transact({ label: "Paste item" }, (draft) => {
+			const group = draft.surveyItems.find((item) => item.id === target.parentId);
+			if (group?.itemType !== "group") throw new Error("Paste target must be a group");
+			group.config.items.splice(Math.min(target.index ?? group.config.items.length, group.config.items.length), 0, payload.rootItemId);
+			draft.surveyItems.push(...payload.surveyItems);
+			for (const [locale, translation] of Object.entries(payload.translations ?? {})) {
+				if (!Object.values(translation.content).some((roles) => Object.keys(roles).length)) continue;
+				draft.translations ??= {};
+				const destination = ownValue(draft.translations, locale) ?? { content: {} };
+				setOwnValue(draft.translations, locale, destination);
+				for (const [ownerId, roles] of Object.entries(translation.content)) setOwnValue(destination.content, ownerId, roles);
+			}
+			if (Object.keys(payload.assets ?? {}).length) draft.assets = {
+				...draft.assets,
+				...payload.assets
+			};
+		});
+		return payload.rootItemId;
+	}
+	copyElement(elementId, layoutId) {
+		const sourcePath = this.identityPath(elementId, "element");
+		const source = this.current.elements.get(elementId);
+		const ids = new Map([...this.current.identities.values()].filter((declaration) => inside(sourcePath, declaration.path)).map((declaration) => [declaration.id, generateId()]));
+		const copy = allocateCopiedResponseNames(this.current.registry.elementSchema, remapAnnotated(this.current.registry.elementSchema, source.node, ids), this.current.registry, new Set(this.current.slots.definitions.map((slot) => slot.variableName)));
+		this.transact({ label: "Copy element" }, (draft) => {
+			arrayAt(draft, [...this.identityPath(layoutId, "layout"), "elements"]).push(copy);
+			for (const translation of Object.values(draft.translations ?? {})) for (const [oldId, newId] of ids) {
+				const content = ownValue(translation.content, oldId);
+				if (content) setOwnValue(translation.content, newId, structuredClone(content));
+			}
+		});
+		return copy.id;
 	}
 };
 //#endregion
-export { CommitSource, ItemCopyPaste, SurveyEditor, SurveyEditorUndoRedo };
+export { CommitSource, SURVEY_EDITOR_ITEM_COLORS, SurveyEditor, SurveyEditorUndoRedo, allocateCopiedResponseNames, copySurveyItem, createEditorSessionSchema, createItemClipboardSchema, getAnswerTypeChangeDiagnostics, prepareItemPaste, previewResponseNaming, previewResponseSettings };
 
 //# sourceMappingURL=editor.mjs.map