@templatical/core 0.52.0 → 0.53.0

package/dist/index.js

@@ -1,6 +1,262 @@
-import { OperationError, SdkError, applyOperations, applyOperationsInPlace, assertNoSlotInContent, assertNoWrapperInContent, cloneBlock, createBlock, createDefaultTemplateContent, deepEqual, generateId, getColumnCount, invertOperations, invertOperations as invertOperations$1, safeClone } from "@templatical/types";
-import { computed, getCurrentScope, onScopeDispose, reactive, readonly, ref, shallowRef, watch } from "@vue/reactivity";
+import { OperationError, SETTINGS_TRANSLATABLE_FIELDS, SdkError, applyOperations, applyOperationsInPlace, assertNoSlotInContent, assertNoWrapperInContent, cloneBlock, createBlock, createDefaultTemplateContent, createSetDefaultLocaleOperation, deepEqual, defaultLocaleOf, generateId, getColumnCount, invertOperations, invertOperations as invertOperations$1, isLocaleTag, isSafePath, isStructuralLocalePath, isTranslatablePath, localizeBlock, pruneLocaleOrphans, pruneSettingsLocaleOrphans, readPath, resolveLocale, safeClone, sourceHash, translatableFields } from "@templatical/types";
+import { computed, getCurrentScope, isRef, onScopeDispose, reactive, readonly, ref, shallowRef, toRef, watch } from "@vue/reactivity";
 import { computed as computed$1, onScopeDispose as onScopeDispose$1, ref as ref$1, watch as watch$1 } from "vue";
+// src/localized-edit.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isIdList = (value) => Array.isArray(value) && value.length > 0 && value.every((item) => isRecord(item) && typeof item.id === "string");
+const SKIP = /* @__PURE__ */ new Set([
+	"id",
+	"type",
+	"children",
+	"columns",
+	"l10n",
+	"renderedHtml"
+]);
+/** Restore requested fields in a projection, preserving sibling overrides. */
+function resetLocalizedFields(base, view, paths) {
+	const restoredAncestors = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		if (!isSafePath(path)) continue;
+		const segments = path.split(".");
+		const key = segments.pop();
+		const parentPath = segments.join(".");
+		const value = readPath(base, path);
+		let parent = view;
+		for (const [index, segment] of segments.entries()) {
+			const ancestorPath = segments.slice(0, index + 1).join(".");
+			if (value !== void 0 && isRecord(parent) && readPath(parent, segment) === void 0 && isRecord(readPath(base, ancestorPath))) {
+				parent[segment] = {};
+				restoredAncestors.add(ancestorPath);
+			}
+			parent = readPath(parent, segment);
+		}
+		if (Array.isArray(parent)) {
+			const index = parent.findIndex((item) => isRecord(item) && item.id === key);
+			if (index < 0) continue;
+			if (value === void 0) parent.splice(index, 1);
+			else parent[index] = safeClone(value);
+		} else if (isRecord(parent)) {
+			if (value === void 0) delete parent[key];
+			else parent[key] = safeClone(value);
+			if (parentPath && Object.keys(parent).length === 0 && readPath(base, parentPath) === void 0) resetLocalizedFields(base, view, [parentPath]);
+		}
+	}
+	return restoredAncestors;
+}
+/** Leaf paths that differ, walking records and lists addressed by element id. */
+function changedLeaves(base, next, prefix, out, walkIds = true, restoredAncestors = /* @__PURE__ */ new Set()) {
+	if (isRecord(base) && isRecord(next) && !restoredAncestors.has(prefix)) {
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(next)])) {
+			if (!prefix && SKIP.has(key)) continue;
+			changedLeaves(base[key], next[key], prefix ? `${prefix}.${key}` : key, out, walkIds, restoredAncestors);
+		}
+		return;
+	}
+	if (walkIds && isIdList(base) && isIdList(next)) {
+		for (const item of next) {
+			if (item.id.includes(".")) continue;
+			const match = base.find((candidate) => candidate.id === item.id);
+			if (match) changedLeaves(match, item, `${prefix}.${item.id}`, out, walkIds, restoredAncestors);
+		}
+		return;
+	}
+	if (!deepEqual(base, next)) out.set(prefix, next);
+}
+/**
+* Derive text and property overrides from a localized view. Unchanged values
+* keep their previous source hash; values equal to the base reset. Clearing a
+* property uses null, the layer's deletion marker. Hidden carries over.
+*/
+function deriveLayer(base, view, previous, definitions = [], restoredAncestors = /* @__PURE__ */ new Set()) {
+	const leaves = /* @__PURE__ */ new Map();
+	changedLeaves(base, view, "", leaves, base.type !== "custom", restoredAncestors);
+	const customText = new Set(base.type === "custom" ? translatableFields(base, definitions) : []);
+	const text = {};
+	const set = {};
+	for (const [path, value] of leaves) if ((base.type === "custom" ? customText.has(path) : isTranslatablePath(base.type, path)) && typeof value === "string" && readPath(base, path) !== void 0) {
+		const before = previous?.text?.[path];
+		text[path] = before && before.value === value ? before : {
+			value,
+			sourceHash: sourceHash(String(readPath(base, path) ?? ""))
+		};
+	} else set[path] = value === void 0 ? null : value;
+	const layer = {};
+	if (Object.keys(text).length) layer.text = text;
+	if (Object.keys(set).length) layer.set = set;
+	if (previous?.hidden) layer.hidden = true;
+	return layer;
+}
+/** Shared list/section structure changes preserve existing elements' base data. */
+function reconcileStructure(base, next, findBlock) {
+	let changed = false;
+	function reconcileList(target, view, key, childKey) {
+		const before = target[key];
+		const value = view[key];
+		const validList = (list) => Array.isArray(list) && list.every((item) => isRecord(item) && typeof item.id === "string");
+		if (!validList(before) || !validList(value)) return;
+		if (JSON.stringify(before.map((item) => item.id)) !== JSON.stringify(value.map((item) => item.id))) {
+			changed = true;
+			target[key] = value.map((item) => safeClone(before.find((old) => old.id === item.id) ?? item));
+		}
+		if (childKey) for (const item of value) {
+			const existing = target[key].find((old) => old.id === item.id);
+			if (existing) reconcileList(existing, item, childKey);
+		}
+	}
+	const target = base;
+	const view = next;
+	if (base.type === "menu") reconcileList(target, view, "items");
+	if (base.type === "table") reconcileList(target, view, "rows", "cells");
+	if (base.type === "social") reconcileList(target, view, "icons");
+	if (base.type === "section" && next.type === "section") {
+		const ids = (columns) => columns.map((column) => column.map((block) => block.id));
+		if (base.columns !== next.columns || JSON.stringify(ids(base.children)) !== JSON.stringify(ids(next.children))) {
+			changed = true;
+			base.columns = next.columns;
+			base.children = next.children.map((column) => column.map((block) => safeClone(findBlock(block.id) ?? block)));
+		}
+	}
+	return changed;
+}
+/** Settings follow the same leaf rules, with preheaderText as their text field. */
+function deriveSettingsLayer(base, view, previous) {
+	const strip = (settings) => {
+		const { locale: _locale, locales: _locales, l10n: _l10n, ...rest } = settings;
+		return rest;
+	};
+	const leaves = /* @__PURE__ */ new Map();
+	changedLeaves(strip(base), strip(view), "", leaves);
+	const layer = {};
+	for (const [path, value] of leaves) if (SETTINGS_TRANSLATABLE_FIELDS.includes(path) && typeof value === "string" && readPath(base, path) !== void 0) {
+		const before = previous?.text?.[path];
+		(layer.text ??= {})[path] = before?.value === value ? before : {
+			value,
+			sourceHash: sourceHash(String(readPath(base, path) ?? ""))
+		};
+	} else (layer.set ??= {})[path] = value === void 0 ? null : value;
+	return layer;
+}
+/** Merge net changed leaves, updating covering overrides without losing siblings. */
+function changedLayer(previous, before, after, base, view, resetPaths = []) {
+	const layer = safeClone(previous ?? {});
+	const paths = [.../* @__PURE__ */ new Set([...resetPaths, ...[.../* @__PURE__ */ new Set([
+		...Object.keys(before.text ?? {}),
+		...Object.keys(before.set ?? {}),
+		...Object.keys(after.text ?? {}),
+		...Object.keys(after.set ?? {})
+	])].filter((path) => !deepEqual(before.text?.[path], after.text?.[path]) || !deepEqual(before.set?.[path], after.set?.[path]))])];
+	const covering = Object.keys(previous?.set ?? {}).filter((ancestor) => paths.some((path) => path.startsWith(`${ancestor}.`)));
+	for (const ancestor of covering) {
+		const value = readPath(view, ancestor);
+		const resets = paths.filter((path) => path.startsWith(`${ancestor}.`) && deepEqual(readPath(base, path), readPath(view, path)));
+		if (deepEqual(value, readPath(base, ancestor))) delete layer.set[ancestor];
+		else if (resets.length && isRecord(readPath(base, ancestor)) && isRecord(value)) {
+			delete layer.set[ancestor];
+			const split = (path, previousValue, nextValue) => {
+				if (resets.some((reset) => path === reset || path.startsWith(`${reset}.`))) return;
+				if (isRecord(previousValue) && isRecord(nextValue)) {
+					for (const key of /* @__PURE__ */ new Set([...Object.keys(previousValue), ...Object.keys(nextValue)])) split(`${path}.${key}`, previousValue[key], nextValue[key]);
+					return;
+				}
+				if (isRecord(base) && base.type !== "custom" && isIdList(previousValue) && isIdList(nextValue)) {
+					for (const item of nextValue) split(`${path}.${item.id}`, previousValue.find((old) => old.id === item.id), item);
+					return;
+				}
+				if (isRecord(base) && typeof base.type === "string" && isStructuralLocalePath(base, path, nextValue)) return;
+				if (layer.text?.[path] && layer.text[path].value === nextValue) return;
+				(layer.set ??= {})[path] = nextValue === void 0 ? null : safeClone(nextValue);
+			};
+			split(ancestor, readPath(base, ancestor), value);
+		} else layer.set[ancestor] = value === void 0 ? null : safeClone(value);
+		for (const kind of ["text", "set"]) for (const stored of Object.keys(layer[kind] ?? {})) {
+			if (!stored.startsWith(`${ancestor}.`)) continue;
+			const storedValue = kind === "text" ? layer.text[stored].value : layer.set[stored] ?? void 0;
+			if (!deepEqual(storedValue, readPath(view, stored))) delete layer[kind][stored];
+		}
+	}
+	for (const path of paths) {
+		if (covering.includes(path)) continue;
+		for (const kind of ["text", "set"]) for (const stored of Object.keys(layer[kind] ?? {})) if (stored === path || stored.startsWith(`${path}.`)) delete layer[kind][stored];
+		if (after.text && Object.hasOwn(after.text, path)) (layer.text ??= {})[path] = after.text[path];
+		if (after.set && Object.hasOwn(after.set, path) && !covering.some((ancestor) => Object.hasOwn(layer.set ?? {}, ancestor) && path.startsWith(`${ancestor}.`))) (layer.set ??= {})[path] = after.set[path];
+	}
+	if (layer.text && !Object.keys(layer.text).length) delete layer.text;
+	if (layer.set && !Object.keys(layer.set).length) delete layer.set;
+	return layer;
+}
+// src/mutation-guard.ts
+function isStructuralMutation(method) {
+	return [
+		"addBlock",
+		"removeBlock",
+		"moveBlock",
+		"duplicateBlock"
+	].includes(method);
+}
+/** The eligibility shared by structural actions and their history preflight. */
+function canEditStructure(context, method, args) {
+	if (context.canEdit && !context.canEdit()) return false;
+	const adding = method === "addBlock";
+	const duplicating = method === "duplicateBlock";
+	const id = typeof args[0] === "string" ? args[0] : args[0].id;
+	const block = adding ? args[0] : context.findBlock?.(id);
+	if (!adding && context.findBlock && !block) return false;
+	const source = adding ? null : context.findBlockLocation?.(id);
+	if (!adding && context.findBlockLocation && !source) return false;
+	if (!adding && context.isBlockLocked(id, true)) return false;
+	if (source?.targetSectionId && context.isBlockLocked(source.targetSectionId, true)) return false;
+	if (adding && context.content) {
+		const candidate = {
+			...context.content(),
+			blocks: [block]
+		};
+		assertNoSlotInContent(candidate);
+		assertNoWrapperInContent(candidate);
+	}
+	if (method === "removeBlock") return true;
+	const implicitDuplicate = duplicating && args[1] === void 0 && args[2] === void 0;
+	const sectionId = implicitDuplicate ? source?.targetSectionId : args[method === "moveBlock" ? 2 : 1];
+	const columnIndex = (implicitDuplicate ? source?.columnIndex : args[method === "moveBlock" ? 3 : 2]) ?? 0;
+	if (sectionId) {
+		if (context.isBlockLocked(sectionId, true) || block?.type === "section") return false;
+		if (context.findBlock) {
+			const section = context.findBlock(sectionId);
+			if (section?.type !== "section" || columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) return false;
+		}
+	}
+	if (method === "moveBlock" && source?.targetSectionId === sectionId && (source?.columnIndex ?? 0) === columnIndex && source?.index === args[1]) return false;
+	return true;
+}
+const guards = /* @__PURE__ */ new WeakMap();
+function registerMutationGuard(editor, guard) {
+	guards.set(editor, guard);
+	for (const value of Object.values(editor)) if (typeof value === "function") guards.set(value, guard);
+}
+function inheritMutationGuard(source, target) {
+	const guard = guards.get(source);
+	if (guard) guards.set(target, guard);
+}
+function canMutate(editor, method, args) {
+	const ownMethod = Reflect.get(editor, method);
+	const guard = guards.get(editor) ?? (typeof ownMethod === "function" ? guards.get(ownMethod) : void 0);
+	if (guard) return guard(method, args);
+	if (!isStructuralMutation(method)) return true;
+	const isBlockLocked = Reflect.get(editor, "isBlockLocked");
+	if (typeof isBlockLocked !== "function") return true;
+	const context = { isBlockLocked: (id, structure) => isBlockLocked.call(editor, id, structure) };
+	const content = Reflect.get(editor, "content");
+	if (isRef(content)) context.content = () => content.value;
+	else if (typeof content === "function") context.content = () => content.call(editor);
+	for (const key of [
+		"canEdit",
+		"findBlock",
+		"findBlockLocation"
+	]) {
+		const member = Reflect.get(editor, key);
+		if (typeof member === "function") context[key] = member.bind(editor);
+	}
+	return canEditStructure(context, method, args);
+}
 // src/error-reporting.ts
 /**
 * Turn a thrown value into an `Error`.
@@ -38,6 +294,7 @@ function useEditor(options) {
 	const state = reactive({
 		template: null,
 		content: seedContent,
+		activeLocale: null,
 		selectedBlockId: null,
 		viewport: "desktop",
 		darkMode: false,
@@ -47,6 +304,105 @@ function useEditor(options) {
 		isLoading: false,
 		uiTheme: "auto"
 	});
+	const activeLocale = toRef(state, "activeLocale");
+	let definitions = [];
+	function setActiveLocale(locale) {
+		const fallback = defaultLocaleOf(state.content);
+		if (locale === fallback) locale = null;
+		if (locale !== null && !state.content.settings.locales?.includes(locale)) throw new SdkError(`This template has no "${locale}" version.`, void 0, "unknown_locale");
+		activeLocale.value = locale;
+	}
+	watch(() => activeLocale.value ?? defaultLocaleOf(state.content), (locale) => notifyHandler(options.onError, () => options.onLocaleChange?.(locale)));
+	watch(() => state.content.settings.locales?.includes(activeLocale.value ?? ""), () => {
+		if (activeLocale.value && !state.content.settings.locales?.includes(activeLocale.value)) setActiveLocale(null);
+	});
+	function canEditLocale() {
+		return activeLocale.value === null || options.localization === void 0 || options.localization.locales.includes(activeLocale.value);
+	}
+	function setCustomBlockDefinitions(defs) {
+		definitions = defs;
+	}
+	function createSetDefaultLocaleOperation$1(locale) {
+		return createSetDefaultLocaleOperation(state.content, locale, definitions);
+	}
+	function localeListDraft(method, locale) {
+		if (!canEditLocale()) return null;
+		if (method === "addLocale" && (!isLocaleTag(locale) || options.localization && !options.localization.locales.includes(locale))) throw new SdkError(`Locale "${locale}" is not enabled.`, void 0, "unknown_locale");
+		const draft = safeClone(state.content);
+		applyOperationsInPlace(draft, [{
+			op: method,
+			locale
+		}]);
+		return deepEqual(draft, state.content) ? null : draft;
+	}
+	function changeLocaleList(method, locale) {
+		const draft = localeListDraft(method, locale);
+		if (!draft) return;
+		state.content = draft;
+		touch();
+	}
+	function addLocale(locale) {
+		changeLocaleList("addLocale", locale);
+	}
+	function removeLocale(locale) {
+		changeLocaleList("removeLocale", locale);
+	}
+	function writeLayer(block, layer) {
+		const locale = activeLocale.value;
+		if (Object.keys(layer).length) block.l10n = {
+			...block.l10n,
+			[locale]: layer
+		};
+		else if (block.l10n) {
+			delete block.l10n[locale];
+			if (!Object.keys(block.l10n).length) delete block.l10n;
+		}
+	}
+	function prepareLayerEdit(method, args) {
+		const [blockId, value] = args;
+		if (!activeLocale.value || !canEditLocale() || isBlockLocked(blockId)) return null;
+		const block = findBlockById(state.content.blocks, blockId);
+		if (!block) return null;
+		const previous = block.l10n?.[activeLocale.value];
+		const view = localizeBlock(block, activeLocale.value, defaultLocaleOf(state.content));
+		const before = deriveLayer(block, view, previous, definitions);
+		const restoredAncestors = method === "resetLocaleFields" && Array.isArray(value) ? resetLocalizedFields(block, view, value) : void 0;
+		const layer = method === "resetLocaleFields" ? changedLayer(previous, before, deriveLayer(block, view, previous, definitions, restoredAncestors), block, view, Array.isArray(value) ? value : []) : safeClone(previous ?? {});
+		if (method === "setBlockHidden") {
+			if (value) layer.hidden = true;
+			else delete layer.hidden;
+		} else if (method === "resetLocaleFields") {
+			if (!value) {
+				delete layer.text;
+				delete layer.set;
+				delete layer.hidden;
+			}
+		} else for (const path of value) {
+			const text = layer.text?.[path];
+			if (text) text.sourceHash = sourceHash(String(readPath(block, path) ?? ""));
+		}
+		if (layer.text && !Object.keys(layer.text).length) delete layer.text;
+		if (layer.set && !Object.keys(layer.set).length) delete layer.set;
+		return deepEqual(previous ?? {}, layer) ? null : {
+			block,
+			layer
+		};
+	}
+	function editLayer(method, args) {
+		const prepared = prepareLayerEdit(method, args);
+		if (!prepared) return;
+		writeLayer(prepared.block, prepared.layer);
+		touch();
+	}
+	function setBlockHidden(blockId, hidden) {
+		editLayer("setBlockHidden", [blockId, hidden]);
+	}
+	function resetLocaleFields(blockId, paths) {
+		editLayer("resetLocaleFields", [blockId, paths]);
+	}
+	function keepTranslations(blockId, paths) {
+		editLayer("keepTranslations", [blockId, paths]);
+	}
 	const loadVersion = ref(0);
 	let loadingRequest = 0;
 	/**
@@ -100,8 +456,18 @@ function useEditor(options) {
 		}
 		return null;
 	}
-	function isBlockLocked(blockId) {
-		return options.lockedBlocks?.value.has(blockId) ?? false;
+	function isBlockLocked(blockId, structure = false) {
+		const locale = activeLocale.value ?? options.lockLocale?.value ?? null;
+		for (const [key, value] of options.lockedBlocks?.value ?? []) {
+			const lock = value;
+			if (lock?.blockId === void 0) {
+				if (key === blockId) return true;
+				continue;
+			}
+			if (lock.blockId !== blockId || lock.holder?.sessionId === options.lockSessionId) continue;
+			if (structure || locale === null || lock.locale == null || lock.locale === locale) return true;
+		}
+		return false;
 	}
 	function findBlockLocation(blockId) {
 		const parent = findBlockParent(state.content.blocks, blockId);
@@ -137,34 +503,97 @@ function useEditor(options) {
 		state.previewMode = previewMode;
 		if (previewMode) state.selectedBlockId = null;
 	}
+	function canUpdateBlock(blockId, updates) {
+		if (!canEditLocale()) return false;
+		const block = findBlockById(state.content.blocks, blockId);
+		if (!block) return false;
+		if ("l10n" in updates) throw new SdkError("l10n is immutable in updateBlock.", void 0, "invalid_operation");
+		const next = {
+			...block,
+			...updates
+		};
+		return !isBlockLocked(blockId, reconcileStructure(safeClone(block), next, (id) => findBlockById(state.content.blocks, id)));
+	}
 	function updateBlock(blockId, updates) {
-		if (isBlockLocked(blockId)) return;
+		if (!canUpdateBlock(blockId, updates)) return;
 		const block = findBlockById(state.content.blocks, blockId);
-		if (block) {
-			Object.assign(block, updates);
-			touch();
+		if (!block) return;
+		const locale = activeLocale.value;
+		if (!locale) {
+			if (isBlockLocked(blockId, "children" in updates || "columns" in updates)) return;
+			const pruned = pruneLocaleOrphans({
+				...block,
+				...updates
+			});
+			delete block.l10n;
+			Object.assign(block, pruned);
+		} else {
+			const view = localizeBlock(block, locale, defaultLocaleOf(state.content));
+			const next = {
+				...view,
+				...updates
+			};
+			const base = safeClone(block);
+			const structural = reconcileStructure(base, next, (id) => findBlockById(state.content.blocks, id));
+			if (isBlockLocked(blockId, structural)) return;
+			if (structural) options.onStructureChange?.();
+			const pruned = pruneLocaleOrphans(base);
+			delete block.l10n;
+			Object.assign(block, pruned);
+			writeLayer(block, changedLayer(block.l10n?.[locale], deriveLayer(block, view, block.l10n?.[locale], definitions), deriveLayer(block, next, block.l10n?.[locale], definitions), block, next));
 		}
+		touch();
+	}
+	function validateSettingsUpdate(updates) {
+		if ("locales" in updates || "l10n" in updates) throw new SdkError("locales and l10n are immutable in updateSettings.", void 0, "invalid_operation");
+		if ("locale" in updates && updates.locale !== defaultLocaleOf(state.content) && state.content.settings.locales?.length) throw new SdkError("The default locale can't change while language versions exist.", void 0, "invalid_operation");
 	}
 	function updateSettings(updates) {
-		state.content.settings = {
+		if (!canEditLocale()) return;
+		validateSettingsUpdate(updates);
+		const locale = activeLocale.value;
+		if (!locale) state.content.settings = pruneSettingsLocaleOrphans({
 			...state.content.settings,
 			...updates
-		};
+		});
+		else {
+			const settings = state.content.settings;
+			const view = resolveLocale(state.content, locale).settings;
+			const next = {
+				...view,
+				locale: settings.locale,
+				...updates
+			};
+			const previous = settings.l10n?.[locale];
+			const layer = changedLayer(previous, deriveSettingsLayer(settings, view, previous), deriveSettingsLayer(settings, next, previous), settings, next);
+			if (Object.keys(layer).length) settings.l10n = {
+				...settings.l10n,
+				[locale]: layer
+			};
+			else if (settings.l10n) {
+				delete settings.l10n[locale];
+				if (!Object.keys(settings.l10n).length) delete settings.l10n;
+			}
+		}
 		touch();
 	}
+	const structuralContext = {
+		canEdit: canEditLocale,
+		content: () => state.content,
+		findBlock: (id) => findBlockById(state.content.blocks, id),
+		findBlockLocation,
+		isBlockLocked
+	};
 	function addBlock(block, targetSectionId, columnIndex = 0, index) {
-		const candidate = {
-			settings: state.content.settings,
-			blocks: [block]
-		};
-		assertNoSlotInContent(candidate);
-		assertNoWrapperInContent(candidate);
-		if (targetSectionId && block.type === "section") return;
+		if (!canEditStructure(structuralContext, "addBlock", [
+			block,
+			targetSectionId,
+			columnIndex,
+			index
+		])) return;
 		if (targetSectionId) {
-			if (isBlockLocked(targetSectionId)) return;
 			const section = findBlockById(state.content.blocks, targetSectionId);
 			if (section && section.type === "section") {
-				if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) return;
 				section.children[columnIndex] = section.children[columnIndex] || [];
 				const targetArray = section.children[columnIndex];
 				if (index !== void 0 && index < targetArray.length) targetArray.splice(index, 0, block);
@@ -172,10 +601,11 @@ function useEditor(options) {
 			}
 		} else if (index !== void 0 && index < state.content.blocks.length) state.content.blocks.splice(index, 0, block);
 		else state.content.blocks.push(block);
+		if (activeLocale.value) options.onStructureChange?.();
 		touch();
 	}
 	function removeBlock(blockId) {
-		if (isBlockLocked(blockId)) return;
+		if (!canEditStructure(structuralContext, "removeBlock", [blockId])) return;
 		const parent = findBlockParent(state.content.blocks, blockId);
 		if (parent) {
 			const index = parent.blocks.findIndex((b) => b.id === blockId);
@@ -186,28 +616,29 @@ function useEditor(options) {
 					collectBlockIds(removed, removedIds);
 					if (removedIds.has(state.selectedBlockId)) state.selectedBlockId = null;
 				}
+				if (activeLocale.value) options.onStructureChange?.();
 				touch();
 			}
 		}
 	}
 	function moveBlock(blockId, newIndex, targetSectionId, columnIndex = 0) {
-		if (isBlockLocked(blockId)) return;
-		if (targetSectionId && isBlockLocked(targetSectionId)) return;
+		if (!canEditStructure(structuralContext, "moveBlock", [
+			blockId,
+			newIndex,
+			targetSectionId,
+			columnIndex
+		])) return;
 		const parent = findBlockParent(state.content.blocks, blockId);
-		if (!parent) return;
-		const oldIndex = parent.blocks.findIndex((b) => b.id === blockId);
-		if (oldIndex === -1) return;
-		if (targetSectionId && parent.blocks[oldIndex].type === "section") return;
+		const oldIndex = parent.blocks.findIndex((block) => block.id === blockId);
 		let targetArray;
 		if (targetSectionId) {
 			const section = findBlockById(state.content.blocks, targetSectionId);
-			if (!section || section.type !== "section") return;
-			if (columnIndex < 0 || columnIndex >= getColumnCount(section.columns)) return;
 			section.children[columnIndex] = section.children[columnIndex] || [];
 			targetArray = section.children[columnIndex];
 		} else targetArray = state.content.blocks;
 		const [block] = parent.blocks.splice(oldIndex, 1);
 		targetArray.splice(newIndex, 0, block);
+		if (activeLocale.value) options.onStructureChange?.();
 		touch();
 	}
 	function markDirty() {
@@ -332,11 +763,20 @@ function useEditor(options) {
 	function hasTemplate() {
 		return state.template?.id !== void 0;
 	}
-	return {
+	const editor = {
 		state: readonly(state),
 		loadVersion: readonly(loadVersion),
 		content,
 		selectedBlock,
+		activeLocale,
+		setActiveLocale,
+		addLocale,
+		removeLocale,
+		setBlockHidden,
+		resetLocaleFields,
+		keepTranslations,
+		setCustomBlockDefinitions,
+		createSetDefaultLocaleOperation: createSetDefaultLocaleOperation$1,
 		isBlockLocked,
 		setContent,
 		selectBlock,
@@ -357,6 +797,16 @@ function useEditor(options) {
 		save,
 		hasTemplate
 	};
+	registerMutationGuard(editor, (method, args) => {
+		if (isStructuralMutation(method)) return canEditStructure(structuralContext, method, args);
+		if (!canEditLocale()) return false;
+		if (method === "updateBlock") return canUpdateBlock(args[0], args[1]);
+		if (method === "updateSettings") validateSettingsUpdate(args[0]);
+		if (method === "addLocale" || method === "removeLocale") return localeListDraft(method, args[0]) !== null;
+		if (method === "setBlockHidden" || method === "resetLocaleFields" || method === "keepTranslations") return prepareLayerEdit(method, args) !== null;
+		return true;
+	});
+	return editor;
 }
 // src/history.ts
 const MAX_STACK_SIZE = 50;
@@ -452,7 +902,8 @@ function useHistory(options) {
 		record,
 		recordDebounced,
 		clear,
-		destroy
+		destroy,
+		flushDebounce: flushPendingDebounce
 	};
 }
 // src/block-actions.ts
@@ -467,6 +918,11 @@ function useBlockActions(options) {
 	}
 	function duplicateBlock(block, targetSectionId, columnIndex) {
 		const cloned = cloneBlock(block);
+		if (!canMutate(addBlock, "duplicateBlock", [
+			block,
+			targetSectionId,
+			columnIndex
+		])) return cloned;
 		if (targetSectionId !== void 0 || columnIndex !== void 0) addBlock(cloned, targetSectionId, columnIndex);
 		else {
 			const sourceLocation = findBlockLocation?.(block.id) ?? null;
@@ -620,51 +1076,88 @@ function useDataSourceFetch(options) {
 * changes by diffing the content and keeps its own undo history.
 */
 function useHistoryInterceptor(editor, history) {
+	if (editor.activeLocale) watch(editor.activeLocale, () => history.flushDebounce?.());
+	for (const key of [
+		"addLocale",
+		"removeLocale",
+		"setBlockHidden",
+		"resetLocaleFields",
+		"keepTranslations"
+	]) {
+		const original = editor[key];
+		if (!original) continue;
+		Object.assign(editor, { [key]: (...args) => {
+			if (!canMutate(editor, key, args)) return;
+			if (!["addLocale", "removeLocale"].includes(key) && editor.isBlockLocked(args[0])) return;
+			history.record();
+			original(...args);
+		} });
+		inheritMutationGuard(original, editor[key]);
+	}
 	const originalAddBlock = editor.addBlock;
 	const originalRemoveBlock = editor.removeBlock;
 	const originalMoveBlock = editor.moveBlock;
 	const originalUpdateBlock = editor.updateBlock;
 	const originalUpdateSettings = editor.updateSettings;
 	editor.addBlock = (block, targetSectionId, columnIndex, index) => {
-		if (targetSectionId && editor.isBlockLocked(targetSectionId)) return;
+		if (!canMutate(editor, "addBlock", [
+			block,
+			targetSectionId,
+			columnIndex,
+			index
+		])) return;
 		history.record();
 		originalAddBlock(block, targetSectionId, columnIndex, index);
 	};
 	editor.removeBlock = (blockId) => {
-		if (editor.isBlockLocked(blockId)) return;
+		if (!canMutate(editor, "removeBlock", [blockId])) return;
 		history.record();
 		originalRemoveBlock(blockId);
 	};
 	editor.moveBlock = (blockId, newIndex, targetSectionId, columnIndex) => {
-		if (editor.isBlockLocked(blockId)) return;
-		if (targetSectionId && editor.isBlockLocked(targetSectionId)) return;
+		if (!canMutate(editor, "moveBlock", [
+			blockId,
+			newIndex,
+			targetSectionId,
+			columnIndex
+		])) return;
 		history.record();
 		originalMoveBlock(blockId, newIndex, targetSectionId, columnIndex);
 	};
+	inheritMutationGuard(originalAddBlock, editor.addBlock);
+	inheritMutationGuard(originalRemoveBlock, editor.removeBlock);
+	inheritMutationGuard(originalMoveBlock, editor.moveBlock);
 	editor.updateBlock = (blockId, updates) => {
+		if (!canMutate(editor, "updateBlock", [blockId, updates])) return;
 		if (editor.isBlockLocked(blockId)) return;
 		history.recordDebounced(blockId);
 		originalUpdateBlock(blockId, updates);
 	};
 	editor.updateSettings = (updates) => {
+		if (!canMutate(editor, "updateSettings", [updates])) return;
 		history.record();
 		originalUpdateSettings(updates);
 	};
+	inheritMutationGuard(originalUpdateBlock, editor.updateBlock);
+	inheritMutationGuard(originalUpdateSettings, editor.updateSettings);
 }
 // src/diff-content.ts
 const ROOT_KEY = "root";
 const BLOCK_SKIP = /* @__PURE__ */ new Set([
 	"id",
 	"type",
-	"children"
+	"children",
+	"l10n"
 ]);
 const RESIZED_SECTION_SKIP = /* @__PURE__ */ new Set([
 	"id",
 	"type",
 	"children",
-	"columns"
+	"columns",
+	"l10n"
 ]);
 const NO_SKIP = /* @__PURE__ */ new Set();
+const SETTINGS_SKIP = /* @__PURE__ */ new Set(["locales", "l10n"]);
 function containerKey(parent) {
 	return parent === null ? ROOT_KEY : JSON.stringify([parent.sectionId, parent.column]);
 }
@@ -673,7 +1166,7 @@ function columnsOf(block) {
 	return block.type === "section" && Array.isArray(children) ? children : [];
 }
 /** Every block by id, with its container. The first occurrence of an id wins. */
-function indexBlocks(blocks) {
+function indexBlocks$1(blocks) {
 	const placements = /* @__PURE__ */ new Map();
 	const walk = (list, parent) => {
 		list.forEach((block, index) => {
@@ -736,6 +1229,18 @@ function keyChanges(before, after, skip) {
 		unset
 	};
 }
+/** Changed paths within one language's layer; removed paths reset to the base. */
+function layerChanges(before = {}, after = {}) {
+	const text = keyChanges(before.text ?? {}, after.text ?? {}, NO_SKIP);
+	const set = keyChanges(before.set ?? {}, after.set ?? {}, NO_SKIP);
+	const unset = [.../* @__PURE__ */ new Set([...text.unset, ...set.unset])];
+	return {
+		...Object.keys(text.set).length > 0 ? { text: text.set } : {},
+		...Object.keys(set.set).length > 0 ? { set: set.set } : {},
+		...unset.length > 0 ? { unset } : {},
+		...before.hidden !== after.hidden ? { hidden: after.hidden === true } : {}
+	};
+}
 /**
 * The operations that turn `before` into `after`. Blocks are matched by id, so
 * a drag comes out as a `moveBlock` and a layout change as a `columns` change
@@ -753,13 +1258,18 @@ function keyChanges(before, after, skip) {
 * 5. `columns` shrinkage, once the dropped columns are empty.
 * 6. Deletion of sections whose surviving blocks have moved out.
 * 7. Key changes on blocks, then on settings.
+* 8. Added locales, block and settings layers, then removed locales.
 *
 * No operation carries `expect`: an ordinary edit applies over anything that
 * doesn't conflict with it, and locks keep two people off one block.
 */
 function diffContent(before, after) {
-	const was = indexBlocks(before.blocks);
-	const now = indexBlocks(after.blocks);
+	if (before.settings.locale !== after.settings.locale && (before.settings.locales?.length || after.settings.locales?.length)) return [{
+		op: "setContent",
+		content: safeClone(after)
+	}];
+	const was = indexBlocks$1(before.blocks);
+	const now = indexBlocks$1(after.blocks);
 	const ops = [];
 	const typeChanged = (id) => {
 		const next = now.get(id);
@@ -878,14 +1388,249 @@ function diffContent(before, after) {
 			...unset.length > 0 ? { unset } : {}
 		});
 	}
-	const settings = keyChanges(before.settings, after.settings, NO_SKIP);
+	const settings = keyChanges(before.settings, after.settings, SETTINGS_SKIP);
 	if (Object.keys(settings.set).length > 0 || settings.unset.length > 0) ops.push({
 		op: "updateSettings",
 		...Object.keys(settings.set).length > 0 ? { set: settings.set } : {},
 		...settings.unset.length > 0 ? { unset: settings.unset } : {}
 	});
+	const previousLocales = new Set(before.settings.locales ?? []);
+	const nextLocales = new Set(after.settings.locales ?? []);
+	for (const locale of nextLocales) if (!previousLocales.has(locale)) ops.push({
+		op: "addLocale",
+		locale
+	});
+	for (const [id, placement] of now) {
+		if (!exists(id)) continue;
+		const previous = was.get(id).block.l10n ?? {};
+		const next = placement.block.l10n ?? {};
+		for (const locale of /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])) {
+			if (!nextLocales.has(locale)) continue;
+			const changes = layerChanges(previous[locale], next[locale]);
+			if (Object.keys(changes).length > 0) ops.push({
+				op: "updateBlockLocale",
+				blockId: id,
+				locale,
+				...changes
+			});
+		}
+	}
+	const previous = before.settings.l10n ?? {};
+	const next = after.settings.l10n ?? {};
+	for (const locale of /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(next)])) {
+		if (!nextLocales.has(locale)) continue;
+		const changes = layerChanges(previous[locale], next[locale]);
+		if (Object.keys(changes).length > 0) ops.push({
+			op: "updateSettingsLocale",
+			locale,
+			...changes
+		});
+	}
+	for (const locale of previousLocales) if (!nextLocales.has(locale)) ops.push({
+		op: "removeLocale",
+		locale
+	});
 	return ops;
 }
+// src/localized-operations.ts
+function indexBlocks(blocks) {
+	const result = /* @__PURE__ */ new Map();
+	const visit = (block) => {
+		result.set(block.id, block);
+		if (block.type === "section") block.children.flat().forEach(visit);
+	};
+	blocks.forEach(visit);
+	return result;
+}
+function container(content, parent) {
+	if (parent === null) return content.blocks;
+	const section = indexBlocks(content.blocks).get(parent.sectionId);
+	return section.type === "section" ? section.children[parent.column] : [];
+}
+function placement(content, id) {
+	const find = (blocks, parent) => {
+		const index = blocks.findIndex((block) => block.id === id);
+		if (index >= 0) return {
+			parent,
+			after: blocks[index - 1]?.id ?? null
+		};
+		for (const block of blocks) {
+			if (block.type !== "section") continue;
+			for (const [column, children] of block.children.entries()) {
+				const result = find(children, {
+					sectionId: block.id,
+					column
+				});
+				if (result) return result;
+			}
+		}
+	};
+	return find(content.blocks, null);
+}
+/** Keep leading hidden siblings before an insertion at the first visible slot. */
+function sharedAfter(shared, view, parent, after, moving) {
+	if (after !== null) return after;
+	const visible = container(view, parent).find((block) => block.id !== moving);
+	const siblings = container(shared, parent).filter((block) => block.id !== moving);
+	return siblings[(visible ? siblings.findIndex((block) => block.id === visible.id) : siblings.length) - 1]?.id ?? null;
+}
+function writeLayer(target, locale, layer) {
+	if (Object.keys(layer).length) (target.l10n ??= {})[locale] = layer;
+	else if (target.l10n) {
+		delete target.l10n[locale];
+		if (!Object.keys(target.l10n).length) delete target.l10n;
+	}
+}
+function stripLayers(block) {
+	const result = safeClone(block);
+	delete result.l10n;
+	if (result.type === "section") result.children = result.children.map((column) => column.map(stripLayers));
+	return result;
+}
+/**
+* Turn operations written against `resolveLocale(base, locale)` into
+* operations on `base`: changed translatable text becomes `text` (stamped
+* with the base value's hash), other changed properties become `set`,
+* structure changes go to the shared tree (a new block's values become
+* default values, as a paste in that view does). Throws the engine's
+* OperationError when `ops` don't apply to the projection or include a
+* whole-template `setContent` replacement.
+*/
+function mapLocalizedOperations(base, locale, ops, definitions) {
+	let view = resolveLocale(base, locale);
+	let shared = safeClone(base);
+	const initialSettings = safeClone(view.settings);
+	let settingsChanged = false;
+	const lifetimes = /* @__PURE__ */ new Map();
+	const register = (blocks, added) => {
+		for (const [id, block] of indexBlocks(blocks)) lifetimes.set(id, {
+			initial: localizeBlock(block, locale, defaultLocaleOf(base)),
+			added,
+			changed: false
+		});
+	};
+	register(view.blocks, false);
+	const mapped = [];
+	const applyAt = (content, operations, index) => {
+		if (operations.some((operation) => operation?.op === "setDefaultLocale")) throw new OperationError("invalid_operation", index, "Changing the default language isn't possible in a language view; switch to the default language.");
+		if (operations.some((operation) => operation?.op === "setContent")) throw new OperationError("invalid_operation", index, "Replacing the whole template isn't possible in a language view; switch to the default language.");
+		try {
+			return applyOperations(content, operations);
+		} catch (error) {
+			if (error instanceof OperationError) throw new OperationError(error.code, index, error.message, error.blockId);
+			throw error;
+		}
+	};
+	const emit = (operations, index) => {
+		shared = applyAt(shared, operations, index);
+		mapped.push(...operations);
+	};
+	const flush = (id, index) => {
+		const lifetime = lifetimes.get(id);
+		if (!lifetime?.changed) return;
+		const block = indexBlocks(shared.blocks).get(id);
+		const final = indexBlocks(view.blocks).get(id);
+		const next = safeClone(shared);
+		const siblings = container(next, placement(next, id).parent);
+		let target = safeClone(block);
+		if (lifetime.added) {
+			target = stripLayers(final);
+			if (target.type === "section" && block.type === "section") {
+				target.children = block.children;
+				target.columns = block.columns;
+			}
+		} else {
+			const structuralView = target.type === "section" ? {
+				...final,
+				children: target.children,
+				columns: target.columns
+			} : final;
+			reconcileStructure(target, structuralView, (blockId) => indexBlocks(shared.blocks).get(blockId) ?? null);
+			target = pruneLocaleOrphans(target);
+			const previous = target.l10n?.[locale];
+			writeLayer(target, locale, changedLayer(previous, deriveLayer(target, lifetime.initial, previous, definitions), deriveLayer(target, final, previous, definitions), target, final));
+		}
+		siblings[siblings.findIndex((candidate) => candidate.id === id)] = target;
+		emit(diffContent(shared, next), index);
+		lifetime.changed = false;
+	};
+	const resize = (op, after, index) => {
+		const section = indexBlocks(shared.blocks).get(op.blockId);
+		const projected = indexBlocks(after.blocks).get(op.blockId);
+		if (section.type !== "section" || projected.type !== "section" || section.columns === projected.columns) return;
+		const count = projected.children.length;
+		const kept = section.children.slice(0, count);
+		const overflow = section.children.slice(count).flat();
+		const target = [...kept[count - 1] ?? [], ...overflow];
+		for (const [offset, block] of overflow.entries()) emit([{
+			op: "moveBlock",
+			blockId: block.id,
+			parent: {
+				sectionId: section.id,
+				column: count - 1
+			},
+			after: target[target.length - overflow.length + offset - 1]?.id ?? null
+		}], index);
+		const current = indexBlocks(shared.blocks).get(op.blockId);
+		emit([{
+			op: "updateBlock",
+			blockId: op.blockId,
+			set: { columns: projected.columns },
+			...op.expect ? { expect: Object.fromEntries(Object.keys(op.expect).map((key) => [key, readPath(current, key) ?? null])) } : {}
+		}], index);
+	};
+	const mapOne = (op, index) => {
+		if (op?.op === "updateSettings" && (Object.hasOwn(op.set ?? {}, "locale") || Array.isArray(op.unset) && op.unset.includes("locale"))) applyAt(shared, [op], index);
+		const after = applyAt(view, [op], index);
+		switch (op.op) {
+			case "addBlock": {
+				const block = stripLayers(op.block);
+				emit([{
+					...op,
+					block,
+					after: sharedAfter(shared, view, op.parent, op.after)
+				}], index);
+				register([block], true);
+				break;
+			}
+			case "moveBlock":
+				emit([{
+					...op,
+					after: sharedAfter(shared, view, op.parent, op.after, op.blockId),
+					...op.expect ? { expect: placement(shared, op.blockId) } : {}
+				}], index);
+				break;
+			case "deleteBlock": {
+				const ids = [...indexBlocks([indexBlocks(shared.blocks).get(op.blockId)]).keys()];
+				for (const id of ids) flush(id, index);
+				emit([{
+					op: "deleteBlock",
+					blockId: op.blockId
+				}], index);
+				for (const id of ids) lifetimes.delete(id);
+				break;
+			}
+			case "updateBlock":
+				resize(op, after, index);
+				lifetimes.get(op.blockId).changed = true;
+				break;
+			case "updateSettings":
+				settingsChanged = true;
+				break;
+			default: emit([op], index);
+		}
+		view = after;
+	};
+	ops.forEach(mapOne);
+	for (const id of lifetimes.keys()) flush(id, ops.length - 1);
+	if (settingsChanged) {
+		const next = safeClone(shared);
+		const previous = next.settings.l10n?.[locale];
+		writeLayer(next.settings, locale, changedLayer(previous, deriveSettingsLayer(next.settings, initialSettings, previous), deriveSettingsLayer(next.settings, view.settings, previous), next.settings, view.settings));
+		emit(diffContent(shared, next), ops.length - 1);
+	}
+	return mapped;
+}
 /** A revision that hasn't arrived after this long is fetched. */
 const COLLABORATION_GAP_TIMEOUT_MS = 1e3;
 /** A held lock is renewed this often; the backend lets it lapse after 30 s. */
@@ -913,6 +1658,12 @@ const REFUSAL_CODES = /* @__PURE__ */ new Set([
 	"lock_lost",
 	"content_too_large"
 ]);
+/** `entry` guarded for `view` when it restores a snapshot. */
+function guarded(entry, view) {
+	if (entry.ops.some((op) => op.op === "setContent")) entry.view = view;
+	else delete entry.view;
+	return entry;
+}
 function refusalCode(error) {
 	const code = error?.code;
 	return typeof code === "string" && REFUSAL_CODES.has(code) ? code : null;
@@ -938,7 +1689,7 @@ function containsBlock(blocks, blockId) {
 function isCoalescible(ops) {
 	if (ops.length === 1 && ops[0].op === "updateSettings") return true;
 	const first = ops[0];
-	return first.op === "updateBlock" && ops.every((op) => op.op === "updateBlock" && op.blockId === first.blockId);
+	return first.op === "updateBlock" && ops.every((op) => op.op === "updateBlock" && op.blockId === first.blockId) || first.op === "updateBlockLocale" && ops.every((op) => op.op === "updateBlockLocale" && op.blockId === first.blockId && op.locale === first.locale);
 }
 /**
 * A remote batch without its preconditions. The backend checked them against
@@ -981,6 +1732,10 @@ function useCollaboration(options) {
 	const locking = typeof provider.acquireLock === "function" && typeof provider.renewLock === "function" && typeof provider.releaseLock === "function";
 	const members = shallowRef([]);
 	const locks = shallowRef(/* @__PURE__ */ new Map());
+	const provisionalLocks = /* @__PURE__ */ new WeakSet();
+	const liveLockVersions = /* @__PURE__ */ new WeakMap();
+	let liveLockVersion = 0;
+	const lockLocale = ref(null);
 	const connection = ref(null);
 	const revision = ref(0);
 	const historyVersion = ref(0);
@@ -988,6 +1743,8 @@ function useCollaboration(options) {
 	let active = null;
 	let suspended = false;
 	let writing = false;
+	/** True while `rebuild` replays: `pump` holds batches until it ends. */
+	let rebuilding = false;
 	let captureQueued = false;
 	let typingTimer = null;
 	let typingSince = 0;
@@ -1017,7 +1774,8 @@ function useCollaboration(options) {
 		return {
 			locks: [...locks.value.values()].map((lock) => ({
 				blockId: lock.blockId,
-				sessionId: lock.holder.sessionId
+				sessionId: lock.holder.sessionId,
+				locale: lock.locale
 			})),
 			session: sessionId
 		};
@@ -1103,7 +1861,10 @@ function useCollaboration(options) {
 		} catch (error) {
 			if (!(error instanceof OperationError)) throw error;
 			renderView(session.view);
-			const holder = error.blockId === void 0 ? void 0 : locks.value.get(error.blockId)?.holder;
+			const holder = error.blockId === void 0 ? void 0 : locksOf(error.blockId).find((lock) => {
+				const op = proposed[error.opIndex];
+				return op.op !== "updateBlockLocale" || lock.locale == null || lock.locale === op.locale;
+			})?.holder;
 			notify({
 				type: "editRefused",
 				code: error.code,
@@ -1131,32 +1892,42 @@ function useCollaboration(options) {
 				return;
 			}
 		}
-		const entry = { ops: invertOperations$1(session.view, ops) };
+		const entry = guarded({ ops: invertOperations$1(session.view, ops) }, next);
 		pushCapped(session.undo, entry);
 		session.redo = [];
 		bumpHistory();
+		const base = session.view;
 		session.view = next;
-		enqueue(session, ops, "edit", entry);
+		enqueue(session, ops, "edit", entry, base);
 	}
-	function enqueue(session, ops, origin, entry) {
+	/** Queue `ops`, built on `base`, as one or more batches and send them. */
+	function enqueue(session, ops, origin, entry, base) {
 		const group = { dropped: false };
 		let offset = 0;
+		let chunkBase = base;
 		do {
+			const chunk = ops.slice(offset, offset + MAX_BATCH_OPS);
 			session.pending.push({
 				batchId: crypto.randomUUID(),
-				ops: ops.slice(offset, offset + MAX_BATCH_OPS),
+				ops: chunk,
 				origin,
 				entry,
 				group,
 				sent: false,
-				revision: null
+				revision: null,
+				...chunkBase && chunk.some((op) => op.op === "setContent") ? { base: chunkBase } : {}
 			});
 			offset += MAX_BATCH_OPS;
+			if (chunkBase && ops.slice(offset).some((op) => op.op === "setContent")) try {
+				chunkBase = applyOperations(chunkBase, chunk);
+			} catch {
+				chunkBase = null;
+			}
 		} while (offset < ops.length);
 		pump(session);
 	}
 	function pump(session) {
-		if (session.inFlight) return;
+		if (session.inFlight || rebuilding) return;
 		const next = session.pending.find((batch) => !batch.sent);
 		if (!next) {
 			settleWaiters(session);
@@ -1169,7 +1940,7 @@ function useCollaboration(options) {
 	function send(session, batch, attempt) {
 		provider.submit(session.templateId, {
 			batchId: batch.batchId,
-			baseRevision: session.revision,
+			baseRevision: batch.baseRevision ??= session.revision,
 			ops: batch.ops,
 			...batch.origin === "ai" ? { origin: "ai" } : {}
 		}).then(({ revision: confirmedAt }) => {
@@ -1319,7 +2090,8 @@ function useCollaboration(options) {
 		for (const batch of applied) try {
 			options.onRemoteChange?.({
 				actor: batch.actor,
-				ops: batch.ops
+				ops: batch.ops,
+				locale: batch.ops.find((op) => op.op !== "setDefaultLocale" && "locale" in op)?.locale ?? null
 			});
 		} catch (error) {
 			reportError(error);
@@ -1327,27 +2099,39 @@ function useCollaboration(options) {
 	}
 	/** Recompute the view from `confirmed`, replaying what is still pending. */
 	function rebuild(session) {
+		const outer = !rebuilding;
+		rebuilding = true;
+		try {
+			replay(session);
+		} finally {
+			if (outer) rebuilding = false;
+		}
+		if (outer) pump(session);
+	}
+	/** `rebuild`'s work, with sending held until it ends. */
+	function replay(session) {
 		if (session === active) flush();
 		let view = session.confirmed;
 		for (let index = 0; index < session.pending.length; index++) {
 			const batch = session.pending[index];
-			try {
+			let code;
+			if (batch.base && !deepEqual(batch.base, view)) code = "precondition_failed";
+			else try {
 				view = applyOperations(view, batch.ops);
+				continue;
 			} catch (error) {
-				if (batch.sent) continue;
-				if (dropRefusedGroup(session, batch)) {
-					const code = error instanceof OperationError ? error.code : "invalid_operation";
-					notify(batch.origin === "edit" || batch.origin === "ai" ? {
-						type: "editRefused",
-						code
-					} : {
-						type: "undoSkipped",
-						code
-					}, session);
-				}
-				view = session.confirmed;
-				index = -1;
+				code = error instanceof OperationError ? error.code : "invalid_operation";
 			}
+			if (batch.sent) continue;
+			if (dropRefusedGroup(session, batch)) notify(batch.origin === "edit" || batch.origin === "ai" ? {
+				type: "editRefused",
+				code
+			} : {
+				type: "undoSkipped",
+				code
+			}, session);
+			view = session.confirmed;
+			index = -1;
 		}
 		session.view = view;
 		settleWaiters(session);
@@ -1430,8 +2214,8 @@ function useCollaboration(options) {
 			onLock: (lock) => {
 				if (live()) setLock(lock);
 			},
-			onUnlock: (blockId, holderSession) => {
-				if (live()) removeLock(blockId, holderSession);
+			onUnlock: (blockId, holderSession, locale) => {
+				if (live()) removeLock(blockId, holderSession, locale);
 			},
 			onMembers: (next) => {
 				if (live()) setMembers(next);
@@ -1442,13 +2226,14 @@ function useCollaboration(options) {
 		};
 	}
 	function join(session, refresh) {
+		const locksAtJoin = liveLockVersion;
 		provider.join(session.templateId, { sessionId }, handlersFor(session)).then((joined) => {
 			if (session.retired || session !== active) {
 				if (!refresh) joined.leave();
 				return;
 			}
 			session.leave = joined.leave;
-			replaceLocks(joined.locks, !refresh);
+			replaceLocks(joined.locks, !refresh, locksAtJoin);
 			setMembers(joined.members);
 			if (joined.members.length > 0) connection.value = "connected";
 			if (joined.revision > session.revision) catchUp();
@@ -1509,12 +2294,29 @@ function useCollaboration(options) {
 		bumpHistory();
 		if (template) start(template);
 	}
-	function setLock(lock) {
+	function lockKey(blockId, locale) {
+		return `${blockId}\u0000${locale ?? ""}`;
+	}
+	function lockConflicts(lock, blockId, locale) {
+		return lock.blockId === blockId && (locale == null || lock.locale == null || lock.locale === locale);
+	}
+	function locksOf(blockId) {
+		return [...locks.value.values()].filter((lock) => lock.blockId === blockId);
+	}
+	function setLockLocale(locale) {
+		if (locale === lockLocale.value) return;
+		flush();
+		lockLocale.value = locale;
+		onSelection(editor?.state.selectedBlockId ?? null);
+	}
+	function setLock(lock, provisional = false) {
 		if (lock.holder.sessionId === sessionId) return;
+		if (provisional) provisionalLocks.add(lock);
+		else liveLockVersions.set(lock, ++liveLockVersion);
 		const next = new Map([...locks.value].filter(([, existing]) => existing.holder.sessionId !== lock.holder.sessionId));
-		next.set(lock.blockId, lock);
+		next.set(lockKey(lock.blockId, lock.locale), lock);
 		locks.value = next;
-		if (editor?.state.selectedBlockId === lock.blockId) {
+		if (editor?.state.selectedBlockId === lock.blockId && (lockLocale.value === null || lock.locale == null || lock.locale === lockLocale.value)) {
 			editor.selectBlock(null);
 			notify({
 				type: "selectionRefused",
@@ -1523,18 +2325,19 @@ function useCollaboration(options) {
 			});
 		}
 	}
-	function removeLock(blockId, holderSession) {
-		if (locks.value.get(blockId)?.holder.sessionId !== holderSession) return;
-		const next = new Map(locks.value);
-		next.delete(blockId);
-		locks.value = next;
+	function removeLock(blockId, holderSession, locale) {
+		const key = lockKey(blockId, locale);
+		const next = new Map([...locks.value].filter(([existingKey, lock]) => lock.holder.sessionId !== holderSession || existingKey !== key && !(lock.blockId === blockId && provisionalLocks.has(lock))));
+		if (next.size !== locks.value.size) locks.value = next;
 	}
-	function replaceLocks(list, merge) {
-		const next = merge ? new Map(locks.value) : /* @__PURE__ */ new Map();
+	function replaceLocks(list, merge, locksAtJoin) {
+		const next = new Map([...locks.value].filter(([, lock]) => !provisionalLocks.has(lock) && (merge || (liveLockVersions.get(lock) ?? 0) > locksAtJoin)));
+		const live = [...next.values()];
 		for (const lock of list) {
 			if (lock.holder.sessionId === sessionId) continue;
-			if (merge && next.has(lock.blockId)) continue;
-			next.set(lock.blockId, lock);
+			if (live.some((existing) => existing.holder.sessionId === lock.holder.sessionId || lockConflicts(existing, lock.blockId, lock.locale))) continue;
+			for (const [key, existing] of next) if (existing.holder.sessionId === lock.holder.sessionId) next.delete(key);
+			next.set(lockKey(lock.blockId, lock.locale), lock);
 		}
 		locks.value = next;
 	}
@@ -1553,36 +2356,34 @@ function useCollaboration(options) {
 	function reconcileLock() {
 		if (!locking) return;
 		queueLock(async () => {
-			if (held && (wanted === null || held.templateId !== wanted.templateId)) {
+			if (held && (wanted === null || held.templateId !== wanted.templateId || held.locale !== wanted.locale)) {
 				const releasing = held;
 				held = null;
 				stopRenewing();
-				await provider.releaseLock(releasing.templateId, releasing.blockId);
+				await provider.releaseLock(releasing.templateId, releasing.blockId, releasing.locale);
 			}
 			const target = wanted;
-			if (!target || held?.templateId === target.templateId && held.blockId === target.blockId) return;
+			if (!target || held?.templateId === target.templateId && held.blockId === target.blockId && held.locale === target.locale) return;
 			try {
-				await provider.acquireLock(target.templateId, target.blockId);
+				const granted = await provider.acquireLock(target.templateId, target.blockId, target.locale);
 				held = target;
 				startRenewing();
-				forgetLock(target.blockId);
+				forgetLock(granted.blockId, granted.locale ?? null);
 			} catch (error) {
 				if (held?.templateId === target.templateId) {
 					const releasing = held;
 					held = null;
 					stopRenewing();
-					await provider.releaseLock(releasing.templateId, releasing.blockId).catch(() => {});
+					await provider.releaseLock(releasing.templateId, releasing.blockId, releasing.locale).catch(() => {});
 				}
 				if (wanted !== target) return;
 				refuseSelection(target.blockId, error);
 			}
 		});
 	}
-	function forgetLock(blockId) {
-		if (!locks.value.has(blockId)) return;
-		const next = new Map(locks.value);
-		next.delete(blockId);
-		locks.value = next;
+	function forgetLock(blockId, locale) {
+		const next = new Map([...locks.value].filter(([, lock]) => !lockConflicts(lock, blockId, locale)));
+		if (next.size !== locks.value.size) locks.value = next;
 	}
 	function refuseSelection(blockId, error) {
 		const code = refusalCode(error);
@@ -1593,7 +2394,7 @@ function useCollaboration(options) {
 				blockId,
 				holder,
 				expiresAt: ""
-			});
+			}, true);
 			else if (editor?.state.selectedBlockId === blockId) editor.selectBlock(null);
 			return;
 		}
@@ -1609,7 +2410,7 @@ function useCollaboration(options) {
 				const current = held;
 				if (!current) return;
 				try {
-					await provider.renewLock(current.templateId, current.blockId);
+					await provider.renewLock(current.templateId, current.blockId, current.locale);
 				} catch (error) {
 					if (refusalCode(error) === "lock_lost") {
 						held = null;
@@ -1633,7 +2434,8 @@ function useCollaboration(options) {
 		if (!active) return;
 		wanted = blockId ? {
 			templateId: active.templateId,
-			blockId
+			blockId,
+			locale: lockLocale.value
 		} : null;
 		reconcileLock();
 	}
@@ -1641,7 +2443,7 @@ function useCollaboration(options) {
 	function onPageHide() {
 		flush();
 		if (held && locking) {
-			provider.releaseLock(held.templateId, held.blockId).catch(() => {});
+			provider.releaseLock(held.templateId, held.blockId, held.locale).catch(() => {});
 			held = null;
 			stopRenewing();
 		}
@@ -1655,6 +2457,13 @@ function useCollaboration(options) {
 		const entry = (direction === "undo" ? session.undo : session.redo).pop();
 		if (!entry) return;
 		bumpHistory();
+		if (entry.view && !deepEqual(entry.view, session.view)) {
+			notify({
+				type: "undoSkipped",
+				code: "precondition_failed"
+			});
+			return;
+		}
 		let next;
 		try {
 			next = applyOperations(session.view, entry.ops, lockContext());
@@ -1666,12 +2475,13 @@ function useCollaboration(options) {
 			});
 			return;
 		}
-		const counter = { ops: invertOperations$1(session.view, entry.ops) };
+		const counter = guarded({ ops: invertOperations$1(session.view, entry.ops) }, next);
 		pushCapped(direction === "undo" ? session.redo : session.undo, counter);
+		const base = session.view;
 		session.view = next;
 		renderView(next);
 		editor?.markDirty();
-		enqueue(session, entry.ops, direction, counter);
+		enqueue(session, entry.ops, direction, counter, base);
 	}
 	function applyFromTurn(ops, options) {
 		const session = active;
@@ -1679,6 +2489,15 @@ function useCollaboration(options) {
 			applied: false,
 			error: new OperationError("invalid_operation", 0, "No template is open for editing.")
 		};
+		if (options.origin === void 0) try {
+			applyOperations(editor.content.value, ops, lockContext());
+		} catch (error) {
+			if (error instanceof OperationError) return {
+				applied: false,
+				error
+			};
+			throw error;
+		}
 		flush();
 		let next;
 		let inverse;
@@ -1694,22 +2513,24 @@ function useCollaboration(options) {
 		}
 		const top = session.undo.at(-1);
 		let entry;
-		if (top && top.turn === options.turn) {
+		if (options.origin === "ai" && options.turn !== void 0 && top && top.turn === options.turn) {
+			const overtaken = top.view !== void 0 && !deepEqual(top.view, session.view);
 			top.ops = [...inverse, ...top.ops];
-			entry = top;
+			entry = overtaken ? top : guarded(top, next);
 		} else {
-			entry = {
+			entry = guarded({
 				ops: inverse,
-				turn: options.turn
-			};
+				...options.origin === "ai" && options.turn !== void 0 ? { turn: options.turn } : {}
+			}, next);
 			pushCapped(session.undo, entry);
 		}
 		session.redo = [];
 		bumpHistory();
+		const base = session.view;
 		session.view = next;
 		renderView(next);
 		editor.markDirty();
-		enqueue(session, ops, options.origin, entry);
+		enqueue(session, ops, options.origin ?? "edit", entry, base);
 		return {
 			applied: true,
 			inverse
@@ -1717,6 +2538,35 @@ function useCollaboration(options) {
 	}
 	function attach(target) {
 		editor = target;
+		const structural = target;
+		if (structural.moveBlock && structural.findBlockLocation) {
+			const original = structural.moveBlock;
+			const move = (...args) => {
+				const session = active;
+				const capturing = session && !suspended && !writing && !target.state.isLoading && target.state.template?.id === session.templateId;
+				if (capturing) capture(true);
+				original(...args);
+				if (!capturing || deepEqual(session.view, target.content.value)) return;
+				const location = structural.findBlockLocation(args[0]);
+				if (!location) return;
+				const parent = location.targetSectionId ? {
+					sectionId: location.targetSectionId,
+					column: location.columnIndex ?? 0
+				} : null;
+				const section = parent ? target.content.value.blocks.find((block) => block.id === parent.sectionId) : void 0;
+				const list = parent && section?.type === "section" ? section.children[parent.column] : target.content.value.blocks;
+				commit(session, [{
+					op: "moveBlock",
+					blockId: args[0],
+					parent,
+					after: list[location.index - 1]?.id ?? null
+				}]);
+			};
+			structural.moveBlock = move;
+			stopWatching.push(() => {
+				if (structural.moveBlock === move) structural.moveBlock = original;
+			});
+		}
 		stopWatching.push(watch(() => target.state.template, (template) => switchTo(template), { immediate: true }), watch(() => target.content.value, scheduleCapture, { deep: true }), watch(() => target.state.selectedBlockId, onSelection), watch(() => target.state.isLoading, (loading) => loading ? capture(true, true) : scheduleCapture()));
 		if (typeof window !== "undefined") {
 			window.addEventListener("pagehide", onPageHide);
@@ -1760,6 +2610,9 @@ function useCollaboration(options) {
 		sessionId,
 		members,
 		locks,
+		locksOf,
+		lockLocale,
+		setLockLocale,
 		connection,
 		revision,
 		canUndo,
@@ -2525,6 +3378,6 @@ function useCommentListener(options) {
 	}, { immediate: true });
 	onScopeDispose$1(stop);
 }
-export { DEFAULT_AUTO_SAVE_DEBOUNCE_MS, createLocalStorageMediaProvider, createLocalStorageSavedBlocksProvider, diffContent, invertOperations, useAutoSave, useBlockActions, useCollaboration, useCommentListener, useComments, useConditionPreview, useDataSourceFetch, useEditor, useHistory, useHistoryInterceptor, useSavedBlocks, useVersionHistory };
+export { DEFAULT_AUTO_SAVE_DEBOUNCE_MS, createLocalStorageMediaProvider, createLocalStorageSavedBlocksProvider, diffContent, invertOperations, mapLocalizedOperations, useAutoSave, useBlockActions, useCollaboration, useCommentListener, useComments, useConditionPreview, useDataSourceFetch, useEditor, useHistory, useHistoryInterceptor, useSavedBlocks, useVersionHistory };
 
 //# sourceMappingURL=index.js.map