@case-framework/survey-core 0.6.2 → 0.8.0

package/build/editor.mjs

@@ -1,6 +1,186 @@
-import { $ as generateId, nt as structuredCloneMethod, t as Survey, u as SurveyItemTranslations, v as GroupItemCore } from "./survey-BKblV5rN.mjs";
+import { C as SurveyItemTranslations, G as generateId, Jn as allocateResponseVariableName, M as GroupItemCore, Y as structuredCloneMethod, Yn as isValidResponseVariableName, cr as ValueType, i as projectSlot, m as Survey, n as getDefaultProjectionIssues, zn as ExpressionType } from "./projection-Bl6qCinx.mjs";
+//#region src/editor/response-naming.ts
+function readPath(config, path) {
+	let current = config;
+	for (const key of path) current = current?.[key];
+	return current;
+}
+function writePath(config, path, value) {
+	if (!path.length || path.some((key) => key === "__proto__" || key === "constructor" || key === "prototype")) throw new Error("Invalid response naming path");
+	const parent = readPath(config, path.slice(0, -1));
+	if (!parent || typeof parent !== "object") throw new Error("Response naming declaration does not match its config");
+	parent[path.at(-1)] = 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.getResponseSlotRegistry();
+	const raw = structuredClone(survey.serialize());
+	const config = (slot) => raw.surveyItems.find((item) => item.id === slot.itemId).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.primitiveId === edit.primitiveId && slot.naming?.kind === "matrix");
+		if (!slots.length) throw new Error(`Unknown matrix primitive "${edit.primitiveId}"`);
+		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.fromJson(raw, survey.getPluginRegistry());
+	const nextRegistry = next.getResponseSlotRegistry();
+	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.fromJson(preview.survey, survey.getPluginRegistry()));
+	return preview;
+}
+/** Allocate whole matrix prefixes and individual names in deterministic declaration order. */
+function allocateCopiedResponseNames(survey, items) {
+	const existingIds = new Set(survey.getResponseSlotDefinitions().flatMap(({ slots }) => slots.map((slot) => slot.slotId)));
+	for (const item of items) for (const slot of item.getResponseSlotDefinitions()) {
+		if (existingIds.has(slot.slotId)) throw new Error(`Inserted input must allocate a fresh slot identity: ${slot.slotId}`);
+		existingIds.add(slot.slotId);
+	}
+	const used = new Set(survey.getResponseSlotRegistry().definitions.map((slot) => slot.variableName));
+	const usedPrefixes = new Set(survey.getResponseSlotRegistry().definitions.flatMap((slot) => slot.naming?.kind === "matrix" ? [String(readPath(survey.surveyItems.get(slot.itemId).config, slot.naming.prefixPath))] : []));
+	const changes = [];
+	for (const item of items) {
+		const initial = item.getResponseSlotDefinitions();
+		const groups = /* @__PURE__ */ new Map();
+		for (const slot of initial) {
+			const key = slot.naming?.kind === "matrix" ? JSON.stringify(slot.naming.prefixPath) : slot.slotId;
+			groups.set(key, [...groups.get(key) ?? [], slot]);
+		}
+		for (const group of groups.values()) {
+			const first = group[0], naming = first.naming;
+			const raw = structuredClone(item.rawItem);
+			if (naming?.kind === "matrix") {
+				const prefix = String(readPath(raw.config, naming.prefixPath));
+				assertName(prefix);
+				const tails = group.map((slot) => slot.variableName.slice(prefix.length));
+				if (new Set(tails).size !== tails.length) throw new Error("Matrix coding components produce duplicate variable names");
+				let candidate = prefix;
+				const blocked = /* @__PURE__ */ new Set();
+				while (usedPrefixes.has(candidate) || tails.some((tail) => used.has(`${candidate}${tail}`))) {
+					blocked.add(candidate);
+					const longestTail = Math.max(...tails.map((tail) => tail.length));
+					try {
+						candidate = allocateResponseVariableName(prefix, blocked, 32 - longestTail);
+					} catch {
+						const longest = group[tails.findIndex((tail) => tail.length === longestTail)];
+						throw new Error(`Cannot allocate a unique matrix prefix for "${longest.variableName}". Shorten its row or column coding name to leave room for a unique prefix within 32 characters.`);
+					}
+				}
+				usedPrefixes.add(candidate);
+				if (candidate !== prefix) {
+					writePath(raw.config, naming.prefixPath, candidate);
+					item.updateRawItem(raw);
+				}
+			} else {
+				assertName(first.variableName);
+				const name = allocateResponseVariableName(first.variableName, used);
+				if (name !== first.variableName) {
+					if (!naming) throw new Error(`Cannot allocate a unique name for plugin variable "${first.variableName}"`);
+					writePath(raw.config, naming.path, name);
+					item.updateRawItem(raw);
+				}
+			}
+			for (const slot of item.getResponseSlotDefinitions().filter((slot) => group.some((original) => original.slotId === slot.slotId))) {
+				assertName(slot.variableName);
+				used.add(slot.variableName);
+				const before = initial.find((original) => original.slotId === slot.slotId).variableName;
+				if (before !== slot.variableName) changes.push({
+					slotId: slot.slotId,
+					itemId: item.id,
+					before,
+					after: slot.variableName
+				});
+			}
+		}
+	}
+	return changes;
+}
+/** 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.getResponseSlotRegistry();
+	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 item = raw.surveyItems.find((item) => item.id === slot.itemId);
+		for (const [id, code] of Object.entries(edit.optionCodes ?? {})) {
+			const path = 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.itemId, 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(item.config, path, code);
+		}
+		if (edit.exportSettings) item.responseSettings = {
+			...item.responseSettings,
+			[slot.slotId]: structuredClone(edit.exportSettings)
+		};
+	}
+	const next = Survey.fromJson(raw, survey.getPluginRegistry());
+	for (const slot of next.getResponseSlotRegistry().definitions.filter((slot) => settings.some((edit) => edit.slotId === slot.slotId))) projectSlot(slot, {
+		mode: "default",
+		...slot.exportSettings
+	});
+	assertProjectionChanges(survey, next);
+	return {
+		...preview,
+		survey: next.serialize()
+	};
+}
+//#endregion
 //#region src/editor/item-copy-paste.ts
 var ItemCopyPaste = class ItemCopyPaste {
+	lastResponseNameChanges = [];
 	survey;
 	constructor(survey) {
 		this.survey = survey;
@@ -22,12 +202,12 @@ var ItemCopyPaste = class ItemCopyPaste {
 				itemData: item.rawItem
 			};
 		});
-		const translations = {};
+		const translations = Object.create(null);
 		itemsToCopy.forEach((id) => {
 			try {
 				const itemTranslations = this.survey.getItemTranslations(id);
 				if (itemTranslations?.locales?.length) {
-					const serializedTranslations = {};
+					const serializedTranslations = Object.create(null);
 					itemTranslations.locales.forEach((locale) => {
 						const localeContent = itemTranslations.getAllForLocale(locale);
 						if (localeContent) serializedTranslations[locale] = localeContent;
@@ -75,27 +255,6 @@ var ItemCopyPaste = class ItemCopyPaste {
 		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);
 	}
@@ -108,21 +267,49 @@ var ItemCopyPaste = class ItemCopyPaste {
 	*/
 	pasteItem(clipboardData, target) {
 		if (!ItemCopyPaste.isValidClipboardData(clipboardData)) throw new Error("Invalid clipboard data format");
-		const idMapping = {};
+		const itemIds = /* @__PURE__ */ new Set();
+		for (const { itemId, itemData } of clipboardData.items) {
+			if (itemIds.has(itemId) || itemId !== itemData.id) throw new Error(`Ambiguous clipboard item identity: ${itemId}`);
+			itemIds.add(itemId);
+		}
+		if (!itemIds.has(clipboardData.rootItemId)) throw new Error("Clipboard root item is missing");
+		if (!(this.survey.surveyItems.get(target.parentId) instanceof GroupItemCore)) throw new Error(`Paste target '${target.parentId}' must be a group item`);
+		const idMapping = Object.create(null);
 		clipboardData.items.forEach(({ itemId }) => {
 			idMapping[itemId] = generateId();
 		});
-		clipboardData.items.forEach(({ itemId, itemData }) => {
+		const componentMapping = Object.create(null);
+		const copiedSlotIds = /* @__PURE__ */ new Set();
+		clipboardData.items.forEach(({ itemData }) => {
+			const item = this.survey.createItemFromRaw(itemData);
+			for (const slot of item.getResponseSlotDefinitions()) {
+				if (copiedSlotIds.has(slot.slotId)) throw new Error(`Duplicate copied slot ID: ${slot.slotId}`);
+				copiedSlotIds.add(slot.slotId);
+			}
+			const declaredIds = item.getResponseSlotDefinitions().flatMap((slot) => [
+				slot.slotId,
+				slot.primitiveId,
+				slot.rowId,
+				slot.columnId
+			].filter((id) => !!id));
+			for (const id of new Set([...item.getOwnedComponentIds(), ...declaredIds].filter((id) => id !== item.id))) {
+				if (componentMapping[id]) throw new Error(`Duplicate owned component ID: ${id}`);
+				componentMapping[id] = generateId();
+			}
+		});
+		const stagedItems = clipboardData.items.map(({ itemId, itemData }) => {
 			const newId = idMapping[itemId];
 			if (newId) {
-				const updatedItemData = this.updateItemIdsInData(itemData, idMapping);
+				const updatedItemData = this.updateItemIdsInData(itemData, idMapping, componentMapping);
 				updatedItemData.id = newId;
-				const newItem = this.survey.createItemFromRaw(updatedItemData);
-				this.survey.surveyItems.set(newItem.id, newItem);
-				if (itemId === clipboardData.rootItemId) this.addItemToParentGroup(target, newItem);
+				return this.survey.createItemFromRaw(updatedItemData);
 			}
+			throw new Error(`Missing copied identity for '${itemId}'`);
 		});
-		const updatedTranslations = this.updateTranslations(clipboardData.translations, idMapping);
+		this.lastResponseNameChanges = allocateCopiedResponseNames(this.survey, stagedItems);
+		for (const item of stagedItems) this.survey.surveyItems.set(item.id, item);
+		this.addItemToParentGroup(target, stagedItems.find((item) => item.id === idMapping[clipboardData.rootItemId]));
+		const updatedTranslations = this.updateTranslations(clipboardData.translations, idMapping, componentMapping);
 		Object.keys(updatedTranslations).forEach((itemId) => {
 			const itemTranslations = new SurveyItemTranslations();
 			const serializedData = updatedTranslations[itemId];
@@ -136,12 +323,47 @@ var ItemCopyPaste = class ItemCopyPaste {
 	/**
 	* Update all item ids in the raw item data recursively
 	*/
-	updateItemIdsInData(itemData, idMapping) {
+	updateItemIdsInData(itemData, idMapping, componentMapping) {
 		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);
 		}
+		const remap = (value, key) => {
+			if (typeof value === "string") {
+				if ([
+					"key",
+					"prefix",
+					"variableName",
+					"rowName",
+					"columnName",
+					"code",
+					"label",
+					"description",
+					"errorMessage",
+					"placeholder",
+					"unit"
+				].includes(key ?? "")) return value;
+				if ((key === "id" || key === "slotId") && idMapping[value]) return idMapping[value];
+				return componentMapping[value] ?? value;
+			}
+			if (Array.isArray(value)) return value.map((entry) => remap(entry));
+			if (value && typeof value === "object" && value.type === "previousResponse") return structuredClone(value);
+			if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([name, entry]) => [componentMapping[name] ?? idMapping[name] ?? name, name === "value" && (typeof entry === "string" || Array.isArray(entry)) && value.type !== ValueType.reference && value.type !== ValueType.referenceArray ? entry : remap(entry, name)]));
+			return value;
+		};
+		updatedData.config = remap(updatedData.config);
+		if (updatedData.responseSettings) updatedData.responseSettings = Object.fromEntries(Object.entries(updatedData.responseSettings).map(([slotId, settings]) => {
+			const value = structuredClone(settings);
+			for (const name of ["optionCodes", "optionLabels"]) if (value[name]) value[name] = Object.fromEntries(Object.entries(value[name]).map(([id, code]) => [componentMapping[id] ?? id, code]));
+			return [componentMapping[slotId] ?? idMapping[slotId] ?? slotId, value];
+		}));
+		if (Object.keys(componentMapping).length) {
+			updatedData.displayConditions = remap(updatedData.displayConditions);
+			updatedData.disabledConditions = remap(updatedData.disabledConditions);
+			updatedData.validations = remap(updatedData.validations);
+			updatedData.prefills = remap(updatedData.prefills);
+		}
 		this.updateExpressionsInItemData(updatedData, idMapping);
 		return updatedData;
 	}
@@ -149,6 +371,12 @@ var ItemCopyPaste = class ItemCopyPaste {
 	* Update expressions in item data that reference the old ids
 	*/
 	updateExpressionsInItemData(itemData, idMapping) {
+		const visitBounds = (value) => {
+			if (!value || typeof value !== "object") return;
+			for (const [key, child] of Object.entries(value)) if (key === "valueExpression" && child && typeof child === "object") this.updateExpressionReferences(child, idMapping);
+			else visitBounds(child);
+		};
+		visitBounds(itemData.config);
 		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);
@@ -162,7 +390,6 @@ var ItemCopyPaste = class ItemCopyPaste {
 		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;
 		});
 	}
 	/**
@@ -171,6 +398,10 @@ var ItemCopyPaste = class ItemCopyPaste {
 	updateExpressionReferences(expression, idMapping) {
 		if (!expression || typeof expression !== "object") return;
 		const expr = expression;
+		if (expr.type === ExpressionType.ResponseVariable && expr.variableRef && typeof expr.variableRef === "object") {
+			const reference = expr.variableRef;
+			if (reference.slotId && Object.prototype.hasOwnProperty.call(idMapping, reference.slotId)) reference.slotId = idMapping[reference.slotId];
+		}
 		if (Array.isArray(expr.data)) expr.data.forEach((arg) => {
 			if (arg && typeof arg === "object" && arg !== null && "str" in arg) {
 				const argObj = arg;
@@ -186,12 +417,12 @@ var ItemCopyPaste = class ItemCopyPaste {
 	/**
 	* Update translation keys for the pasted item
 	*/
-	updateTranslations(translations, idMapping) {
-		const newTranslations = {};
+	updateTranslations(translations, idMapping, componentMapping) {
+		const newTranslations = Object.create(null);
 		Object.keys(translations).forEach((itemId) => {
 			const itemTranslations = translations[itemId];
 			const newItemId = idMapping[itemId];
-			newTranslations[newItemId] = itemTranslations;
+			newTranslations[newItemId] = Object.fromEntries(Object.entries(itemTranslations).map(([locale, content]) => [locale, Object.fromEntries(Object.entries(content).map(([key, value]) => [key.split(".").map((part) => componentMapping[part] ?? part).join("."), value]))]));
 		});
 		return newTranslations;
 	}
@@ -243,6 +474,7 @@ function normalizeHistoryEntry(entry) {
 		if (entry.kind === "survey-snapshot") return {
 			kind: "survey-snapshot",
 			survey: structuredCloneMethod(entry.survey),
+			id: entry.id ?? generateId(),
 			timestamp: entry.timestamp,
 			meta: entry.meta,
 			memorySize: entry.memorySize
@@ -250,6 +482,7 @@ function normalizeHistoryEntry(entry) {
 		return {
 			kind: "asset-change",
 			changes: structuredCloneMethod(entry.changes),
+			id: entry.id ?? generateId(),
 			timestamp: entry.timestamp,
 			meta: entry.meta,
 			memorySize: entry.memorySize
@@ -258,6 +491,7 @@ function normalizeHistoryEntry(entry) {
 	return {
 		kind: "survey-snapshot",
 		survey: structuredCloneMethod(entry.survey),
+		id: entry.id ?? generateId(),
 		timestamp: entry.timestamp,
 		meta: entry.meta,
 		memorySize: entry.memorySize
@@ -267,6 +501,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	history = [];
 	currentIndex = -1;
 	_config;
+	baseAssetSize;
 	_initialAssets;
 	constructor(initialSurvey, config = {}, meta = {
 		label: "Initial state",
@@ -293,6 +528,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 +538,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 +557,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 +567,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,7 +585,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		throw new Error("Invalid history state");
 	}
 	applyAssetPatch(assets, patch) {
-		const nextAssets = structuredCloneMethod(assets);
+		const nextAssets = assets;
 		if (patch.next) nextAssets[patch.assetId] = structuredCloneMethod(patch.next);
 		else delete nextAssets[patch.assetId];
 		return nextAssets;
@@ -362,6 +600,12 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 		}
 		return Object.keys(assets).length > 0 ? assets : void 0;
 	}
+	getEntryId(index) {
+		return this.history[index]?.id;
+	}
+	findEntryIndex(id) {
+		return this.history.findIndex((entry) => entry.id === id);
+	}
 	commit(survey, meta) {
 		this.saveSnapshot(survey, meta);
 	}
@@ -407,7 +651,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 	}
 	getMemoryUsage() {
 		return {
-			totalMB: this.getTotalMemoryUsage() / (1024 * 1024),
+			totalMB: this.getTotalMemoryUsage() / 1048576,
 			entries: this.history.length
 		};
 	}
@@ -422,6 +666,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 +685,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 +730,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 				if (entry.kind === "survey-snapshot") return {
 					kind: "survey-snapshot",
 					survey: entry.survey,
+					id: entry.id ?? generateId(),
 					timestamp: entry.timestamp,
 					meta: entry.meta,
 					memorySize: entry.memorySize
@@ -491,6 +738,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 +760,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);
@@ -524,8 +773,7 @@ var SurveyEditorUndoRedo = class SurveyEditorUndoRedo {
 //#endregion
 //#region src/editor/survey-editor.ts
 function stripAssetsFromSurveySnapshot(survey) {
-	const snapshot = structuredCloneMethod(survey);
-	delete snapshot.assets;
+	const { assets: _assets, ...snapshot } = survey;
 	return snapshot;
 }
 function mergeSurveySnapshotWithAssets(snapshot, assets) {
@@ -535,45 +783,123 @@ function mergeSurveySnapshotWithAssets(snapshot, assets) {
 	return merged;
 }
 var SurveyEditor = class SurveyEditor {
+	lastResponseNameChanges = [];
+	renameResponseVariables(edits) {
+		const preview = previewResponseNaming(this._survey, edits);
+		if (!preview.changes.length) return [];
+		const next = Survey.fromJson(preview.survey, this._survey.getPluginRegistry());
+		this._survey = next;
+		for (const id of new Set(preview.changes.map((change) => change.itemId))) this.touchItemModifiedMetadata(id, this.createEditorTimestamp());
+		this.lastResponseNameChanges = preview.changes;
+		this.markAsModified();
+		return preview.changes;
+	}
+	updateResponseSettings(naming, settings) {
+		const preview = previewResponseSettings(this._survey, naming, settings);
+		this._survey = Survey.fromJson(preview.survey, this._survey.getPluginRegistry());
+		const changedItems = /* @__PURE__ */ new Set([...preview.changes.map((change) => change.itemId), ...settings.map((edit) => this._survey.getResponseSlotRegistry().get(edit.slotId).itemId)]);
+		for (const itemId of changedItems) this.touchItemModifiedMetadata(itemId, this.createEditorTimestamp());
+		this.lastResponseNameChanges = preview.changes;
+		this.markAsModified();
+		return preview.changes;
+	}
 	_survey;
 	_undoRedo;
 	_hasUncommittedChanges = false;
+	mutationEpoch = 0;
+	pendingAssets = /* @__PURE__ */ new Map();
 	_pluginRegistry;
 	constructor(survey, config = {}, meta) {
 		this._survey = survey;
 		const { pluginRegistry, ...undoRedoConfig } = config;
-		this._pluginRegistry = pluginRegistry;
+		this._pluginRegistry = pluginRegistry ?? survey.getPluginRegistry();
 		const serialized = survey.serialize();
 		this._undoRedo = new SurveyEditorUndoRedo(stripAssetsFromSurveySnapshot(serialized), undoRedoConfig, meta, serialized.assets);
 	}
+	/**
+	* An isolated field edit owns only its field value (held by the caller) and
+	* affected item metadata. Any intervening core action invalidates this handle.
+	* The caller must finish pre-existing work before opening a handle.
+	*/
+	beginFieldEdit(itemId) {
+		if (this.hasUncommittedChanges) throw new Error("Finish pending changes before editing a field");
+		let expectedEpoch = this.mutationEpoch;
+		const history = this._undoRedo;
+		const index = history.getCurrentIndex();
+		const locales = this._survey.translations.locales;
+		const metadata = itemId ? structuredCloneMethod(this._survey.surveyItems.get(itemId)?.rawItem.editorMetadata) : void 0;
+		const owns = () => this.mutationEpoch === expectedEpoch && this._undoRedo === history && history.getCurrentIndex() === index;
+		return {
+			run: (write) => {
+				if (!owns()) throw new Error("Field edit was superseded by another action");
+				const result = write();
+				expectedEpoch = this.mutationEpoch;
+				return result;
+			},
+			reconcile: (restoreValue) => {
+				if (!owns()) return false;
+				restoreValue?.();
+				if (itemId) {
+					const item = this._survey.surveyItems.get(itemId);
+					if (!item) return false;
+					this._survey.surveyItems.set(itemId, this._survey.createItemFromRaw({
+						...item.rawItem,
+						editorMetadata: structuredCloneMethod(metadata)
+					}));
+				}
+				for (const locale of this._survey.translations.locales) if (!locales.includes(locale)) {
+					const data = this._survey.translations.serialize()?.[locale];
+					if (data && !data.surveyCardContent && !data.navigationContent && !data.validationMessages && Object.keys(data.itemTranslations ?? {}).length === 0) this._survey.translations.removeLocale(locale);
+				}
+				this._hasUncommittedChanges = false;
+				this.mutationEpoch++;
+				expectedEpoch = this.mutationEpoch;
+				return true;
+			}
+		};
+	}
+	get hasCommittedChanges() {
+		return this._undoRedo.getCurrentIndex() > 0;
+	}
 	/** Returns an immutable copy of the current survey state. */
 	get survey() {
-		const serialized = this._survey.serialize();
+		const serialized = structuredCloneMethod(this._survey.serialize());
 		const registry = this._pluginRegistry ?? this._survey.getPluginRegistry();
 		return Survey.fromJson(serialized, registry);
 	}
 	get hasUncommittedChanges() {
-		return this._hasUncommittedChanges;
+		return this._hasUncommittedChanges || this.pendingAssets.size > 0;
 	}
 	get undoRedo() {
 		return this._undoRedo;
 	}
 	commit(meta) {
-		if (!this._hasUncommittedChanges) return;
-		this._undoRedo.commit(stripAssetsFromSurveySnapshot(this._survey.serialize()), meta);
+		if (!this.hasUncommittedChanges) return;
+		this.mutationEpoch++;
+		if (this._hasUncommittedChanges) this._undoRedo.commit(stripAssetsFromSurveySnapshot(this._survey.serialize()), meta);
+		if (this.pendingAssets.size) {
+			this._undoRedo.commitAssetChange([...this.pendingAssets].map(([assetId, patch]) => ({
+				assetId,
+				...patch
+			})), meta);
+			this.pendingAssets.clear();
+		}
 		this._hasUncommittedChanges = false;
 	}
 	restoreHistoryState(snapshot, assets) {
+		this.mutationEpoch++;
+		this.lastResponseNameChanges = [];
+		this.pendingAssets.clear();
 		this._survey = Survey.fromJson(mergeSurveySnapshotWithAssets(snapshot, assets), this._pluginRegistry);
 	}
 	commitIfNeeded() {
-		if (this._hasUncommittedChanges) this.commit({
+		if (this.hasUncommittedChanges) this.commit({
 			label: "Latest content changes",
 			source: CommitSource.SYSTEM
 		});
 	}
 	undo() {
-		if (this._hasUncommittedChanges) {
+		if (this.hasUncommittedChanges) {
 			this.restoreHistoryState(this._undoRedo.getCurrentState(), this._undoRedo.getCurrentAssets());
 			this._hasUncommittedChanges = false;
 			return true;
@@ -588,7 +914,7 @@ var SurveyEditor = class SurveyEditor {
 		}
 	}
 	redo() {
-		if (this._hasUncommittedChanges) return false;
+		if (this.hasUncommittedChanges) return false;
 		const nextState = this._undoRedo.redo();
 		if (nextState) {
 			this.restoreHistoryState(nextState, this._undoRedo.getCurrentAssets());
@@ -601,7 +927,7 @@ var SurveyEditor = class SurveyEditor {
 	* Jump to a specific index in the history (can go forward or backward)
 	*/
 	jumpToIndex(targetIndex) {
-		if (this._hasUncommittedChanges) return false;
+		if (this.hasUncommittedChanges) return false;
 		const targetState = this._undoRedo.jumpToIndex(targetIndex);
 		if (targetState) {
 			this.restoreHistoryState(targetState, this._undoRedo.getCurrentAssets());
@@ -611,20 +937,20 @@ var SurveyEditor = class SurveyEditor {
 		return false;
 	}
 	canUndo() {
-		return this._hasUncommittedChanges || this._undoRedo.canUndo();
+		return this.hasUncommittedChanges || this._undoRedo.canUndo();
 	}
 	canRedo() {
-		return !this._hasUncommittedChanges && this._undoRedo.canRedo();
+		return !this.hasUncommittedChanges && this._undoRedo.canRedo();
 	}
 	getUndoMeta() {
-		if (this._hasUncommittedChanges) return {
+		if (this.hasUncommittedChanges) return {
 			label: "Latest content changes",
 			source: CommitSource.SYSTEM
 		};
 		return this._undoRedo.getUndoMeta();
 	}
 	getRedoMeta() {
-		if (this._hasUncommittedChanges) return null;
+		if (this.hasUncommittedChanges) return null;
 		return this._undoRedo.getRedoMeta();
 	}
 	getMemoryUsage() {
@@ -646,9 +972,9 @@ var SurveyEditor = class SurveyEditor {
 	toJson() {
 		return {
 			version: "1.0.0",
-			survey: this._survey.serialize(),
+			survey: structuredCloneMethod(this._survey.serialize()),
 			undoRedo: this._undoRedo.serialize(),
-			hasUncommittedChanges: this._hasUncommittedChanges
+			hasUncommittedChanges: this.hasUncommittedChanges
 		};
 	}
 	/**
@@ -662,7 +988,8 @@ var SurveyEditor = class SurveyEditor {
 		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 });
+		const survey = Survey.fromJson(jsonData.survey, pluginRegistry);
+		const editor = new SurveyEditor(survey, { pluginRegistry });
 		editor._undoRedo = SurveyEditorUndoRedo.deserialize({
 			...jsonData.undoRedo,
 			history: jsonData.undoRedo.history.map((entry) => "survey" in entry ? {
@@ -671,9 +998,16 @@ var SurveyEditor = class SurveyEditor {
 			} : entry)
 		}, jsonData.survey.assets);
 		editor._hasUncommittedChanges = JSON.stringify(stripAssetsFromSurveySnapshot(jsonData.survey)) !== JSON.stringify(editor._undoRedo.getCurrentState());
+		const baselineAssets = editor._undoRedo.getCurrentAssets() ?? {};
+		const liveAssets = jsonData.survey.assets ?? {};
+		for (const assetId of /* @__PURE__ */ new Set([...Object.keys(baselineAssets), ...Object.keys(liveAssets)])) if (JSON.stringify(baselineAssets[assetId]) !== JSON.stringify(liveAssets[assetId])) editor.pendingAssets.set(assetId, {
+			prev: structuredCloneMethod(baselineAssets[assetId]),
+			next: structuredCloneMethod(liveAssets[assetId])
+		});
 		return editor;
 	}
 	markAsModified() {
+		this.mutationEpoch++;
 		this._hasUncommittedChanges = true;
 	}
 	createEditorTimestamp() {
@@ -686,7 +1020,6 @@ var SurveyEditor = class SurveyEditor {
 	}
 	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) {
@@ -701,21 +1034,11 @@ var SurveyEditor = class SurveyEditor {
 			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++;
-		}
 		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
-		});
+		this.lastResponseNameChanges = allocateCopiedResponseNames(this._survey, [item]);
+		this.markAsModified();
 		item.setCreatedAt(timestamp);
 		item.setModifiedAt(timestamp);
 		this._survey.surveyItems.set(item.id, item);
@@ -742,8 +1065,7 @@ var SurveyEditor = class SurveyEditor {
 	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`);
+		if (!this._survey.surveyItems.get(itemId)) 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})`);
@@ -756,17 +1078,6 @@ var SurveyEditor = class SurveyEditor {
 			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
-		});
 		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);
@@ -813,17 +1124,7 @@ var SurveyEditor = class SurveyEditor {
 			parent.removeChild(item.id);
 			this.touchItemModifiedMetadata(parent.id, timestamp);
 		}
-		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);
 		});
@@ -865,12 +1166,20 @@ var SurveyEditor = class SurveyEditor {
 			...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}'`);
+		if (merged.responseSettings) {
+			merged.responseSettings = { ...merged.responseSettings };
+			const nextSlotIds = new Set(this._survey.createItemFromRaw(merged).getResponseSlotDefinitions().map((slot) => slot.slotId));
+			for (const slot of existingItem.getResponseSlotDefinitions()) if (!nextSlotIds.has(slot.slotId)) delete merged.responseSettings[slot.slotId];
 		}
+		const stagedRaw = this._survey.serialize();
+		stagedRaw.surveyItems = stagedRaw.surveyItems.map((item) => item.id === itemId ? merged : item);
+		const beforeIssues = new Set(this._survey.getResponseSlotRegistry().diagnostics.map((issue) => JSON.stringify(issue)));
+		const stagedSurvey = Survey.fromJson(stagedRaw, this._survey.getPluginRegistry());
+		const introduced = stagedSurvey.getResponseSlotRegistry().diagnostics.filter((issue) => !beforeIssues.has(JSON.stringify(issue)));
+		if (introduced.length) throw new Error(introduced.map((issue) => issue.message).join("\n"));
+		const previousProjectionIssues = new Set(getDefaultProjectionIssues(this._survey));
+		const projectionIssues = getDefaultProjectionIssues(stagedSurvey).filter((issue) => !previousProjectionIssues.has(issue));
+		if (projectionIssues.length) throw new Error(projectionIssues.join("\n"));
 		const newItem = this._survey.createItemFromRaw({
 			...merged,
 			editorMetadata: existingItem.rawItem.editorMetadata
@@ -879,6 +1188,19 @@ var SurveyEditor = class SurveyEditor {
 		this._survey.surveyItems.set(itemId, newItem);
 		this.markAsModified();
 	}
+	/** Detached field read; does not construct a Survey or visit other locales. */
+	getItemTranslationContent(itemId, locale, contentKey, fallbackLocale) {
+		return this._survey.translations.getItemTranslationContent(itemId, locale, contentKey, fallbackLocale);
+	}
+	/** Publish accepted content without committing history. Equivalent writes are no-ops. */
+	setItemTranslationContent(itemId, locale, contentKey, content) {
+		const item = this._survey.surveyItems.get(itemId);
+		if (!item) return false;
+		if (!this._survey.translations.setItemTranslationContent(itemId, locale, contentKey, content)) return false;
+		item.setModifiedAt(this.createEditorTimestamp());
+		this.markAsModified();
+		return true;
+	}
 	updateItemTranslations(itemId, updatedContent) {
 		const item = this._survey.surveyItems.get(itemId);
 		if (!item) return false;
@@ -987,7 +1309,21 @@ var SurveyEditor = class SurveyEditor {
 	/**
 	* Add or replace a survey asset.
 	*/
+	/** Stage one live asset delta. Default setAsset/removeAsset remain immediate. */
+	stageAsset(assetId, asset) {
+		const previous = this.pendingAssets.get(assetId)?.prev ?? this._survey.getAsset(assetId);
+		const baseline = this.pendingAssets.has(assetId) ? this.pendingAssets.get(assetId).prev : previous;
+		if (asset) this._survey.setAsset(assetId, structuredCloneMethod(asset));
+		else this._survey.deleteAsset(assetId);
+		if (JSON.stringify(baseline) === JSON.stringify(asset)) this.pendingAssets.delete(assetId);
+		else this.pendingAssets.set(assetId, {
+			prev: baseline,
+			next: structuredCloneMethod(asset)
+		});
+		this.mutationEpoch++;
+	}
 	setAsset(assetId, asset) {
+		this.mutationEpoch++;
 		const previousAsset = this._survey.getAsset(assetId);
 		this._survey.setAsset(assetId, structuredCloneMethod(asset));
 		this._undoRedo.commitAssetChange([{
@@ -1003,6 +1339,7 @@ var SurveyEditor = class SurveyEditor {
 	* Remove a survey asset.
 	*/
 	removeAsset(assetId) {
+		this.mutationEpoch++;
 		const previousAsset = this._survey.getAsset(assetId);
 		if (!previousAsset) return;
 		this._survey.deleteAsset(assetId);
@@ -1029,10 +1366,12 @@ var SurveyEditor = class SurveyEditor {
 	* @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 copyPaste = new ItemCopyPaste(this._survey);
+		const newItemId = copyPaste.pasteItem(clipboardData, target);
+		this.lastResponseNameChanges = copyPaste.lastResponseNameChanges;
+		this.markAsModified();
 		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);
@@ -1046,6 +1385,6 @@ var SurveyEditor = class SurveyEditor {
 	}
 };
 //#endregion
-export { CommitSource, ItemCopyPaste, SurveyEditor, SurveyEditorUndoRedo };
+export { CommitSource, ItemCopyPaste, SurveyEditor, SurveyEditorUndoRedo, allocateCopiedResponseNames, previewResponseNaming, previewResponseSettings };
 
 //# sourceMappingURL=editor.mjs.map