@dragcraft/core 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2281 @@
+import { readonly, ref, shallowRef } from "vue";
+import { EventEmitter, cloneDeep, generateShortId } from "@dragcraft/utils";
+//#region src/behavior.ts
+/**
+* Resolves a behavior field that may be a static boolean or a predicate function.
+*
+* - `undefined` → returns `defaultValue` (preserves opt-in defaults)
+* - `boolean`   → returns the boolean directly
+* - `function`  → invokes the function with the provided context
+*
+* @param field - The behavior field from WidgetMeta (may be undefined)
+* @param ctx   - The context to pass if field is a function
+* @param defaultValue - Value when field is undefined (default: true)
+*/
+function resolveBehavior(field, ctx, defaultValue = true) {
+	if (field === void 0) return defaultValue;
+	if (typeof field === "function") return field(ctx);
+	return field;
+}
+function normalizeCreatableDecision(value, defaultValue) {
+	if (value === void 0) return { allowed: defaultValue };
+	if (typeof value === "boolean") return { allowed: value };
+	return value;
+}
+function resolveCreatable(field, ctx, defaultValue = true) {
+	return normalizeCreatableDecision(typeof field === "function" ? field(ctx) : field, defaultValue);
+}
+//#endregion
+//#region src/constants.ts
+const CommandType = {
+	ADD_NODE: "ADD_NODE",
+	MOVE_NODE: "MOVE_NODE",
+	REMOVE_NODE: "REMOVE_NODE",
+	DUPLICATE_NODE: "DUPLICATE_NODE",
+	CHANGE_CONTAINER_VARIANT: "CHANGE_CONTAINER_VARIANT",
+	UPDATE_PROPS: "UPDATE_PROPS",
+	SET_GLOBAL_CONFIG: "SET_GLOBAL_CONFIG"
+};
+const EventName = {
+	SCHEMA_CHANGED: "schema:changed",
+	SELECTION_CHANGED: "selection:changed",
+	DRAG_ENTER: "drag:enter",
+	DRAG_OVER: "drag:over",
+	DRAG_LEAVE: "drag:leave",
+	DRAG_DROP: "drag:drop",
+	HISTORY_CHANGED: "history:changed",
+	NODE_ADDED: "node:added",
+	NODE_REMOVED: "node:removed",
+	NODE_DUPLICATED: "node:duplicated",
+	NODE_MOVED: "node:moved",
+	CONTAINER_VARIANT_CHANGED: "container:variant-changed",
+	NODE_UPDATED: "node:updated",
+	GLOBAL_CONFIG_CHANGED: "global-config:changed"
+};
+const DEFAULT_SCHEMA_VERSION = "1.0.0";
+const DEFAULT_MAX_HISTORY_SIZE = 50;
+//#endregion
+//#region src/schema-utils.ts
+function cloneSchema(schema) {
+	return cloneDeep(schema);
+}
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const child of Object.values(value)) deepFreeze(child);
+	}
+	return value;
+}
+//#endregion
+//#region src/history-manager.ts
+const ownedSnapshotPushers = /* @__PURE__ */ new WeakMap();
+function pushOwnedHistorySnapshot(history, label, before) {
+	const pushOwned = ownedSnapshotPushers.get(history);
+	if (pushOwned) pushOwned(label, before);
+	else history.pushSnapshot(label, before);
+}
+function createHistoryManager(store, eventHub, maxSize = 50) {
+	const undoStack = [];
+	const redoStack = [];
+	const state = ref({
+		canUndo: false,
+		canRedo: false,
+		undoCount: 0,
+		redoCount: 0
+	});
+	let inTransaction = false;
+	let transactionLabel = "";
+	let transactionSnapshot = null;
+	function resetTransaction() {
+		inTransaction = false;
+		transactionLabel = "";
+		transactionSnapshot = null;
+	}
+	function trimUndoStack() {
+		if (undoStack.length > maxSize) undoStack.splice(0, undoStack.length - maxSize);
+	}
+	function pushUndo(label, snapshot) {
+		undoStack.push({
+			label,
+			snapshot
+		});
+		trimUndoStack();
+		redoStack.length = 0;
+	}
+	function emitChange() {
+		const nextState = {
+			canUndo: canUndo(),
+			canRedo: canRedo(),
+			undoCount: undoStack.length,
+			redoCount: redoStack.length
+		};
+		state.value = nextState;
+		eventHub.emit(EventName.HISTORY_CHANGED, nextState);
+	}
+	function pushOwnedSnapshot(label, before) {
+		if (inTransaction) return;
+		pushUndo(label, before);
+		emitChange();
+	}
+	function pushSnapshot(label, before) {
+		if (inTransaction) return;
+		pushOwnedSnapshot(label, deepFreeze(cloneSchema(before)));
+	}
+	function undo() {
+		if (!canUndo()) return;
+		const entry = undoStack.pop();
+		const currentSnapshot = store.getSnapshot();
+		redoStack.push({
+			label: entry.label,
+			snapshot: currentSnapshot
+		});
+		store.restoreSnapshot(entry.snapshot);
+		emitChange();
+		eventHub.emit(EventName.SCHEMA_CHANGED, store.getSnapshot());
+	}
+	function redo() {
+		if (!canRedo()) return;
+		const entry = redoStack.pop();
+		const currentSnapshot = store.getSnapshot();
+		undoStack.push({
+			label: entry.label,
+			snapshot: currentSnapshot
+		});
+		trimUndoStack();
+		store.restoreSnapshot(entry.snapshot);
+		emitChange();
+		eventHub.emit(EventName.SCHEMA_CHANGED, store.getSnapshot());
+	}
+	function canUndo() {
+		return undoStack.length > 0;
+	}
+	function canRedo() {
+		return redoStack.length > 0;
+	}
+	function beginTransaction(label) {
+		if (inTransaction) {
+			console.warn("[dragcraft/core] Transaction already in progress, ignoring beginTransaction");
+			return;
+		}
+		inTransaction = true;
+		transactionLabel = label ?? "transaction";
+		transactionSnapshot = store.getSnapshot();
+	}
+	function commitTransaction() {
+		if (!inTransaction) {
+			console.warn("[dragcraft/core] No transaction in progress, ignoring commitTransaction");
+			return;
+		}
+		if (transactionSnapshot && transactionSnapshot !== store.getSnapshot()) pushUndo(transactionLabel, transactionSnapshot);
+		resetTransaction();
+		emitChange();
+	}
+	function discardTransaction() {
+		if (!inTransaction) {
+			console.warn("[dragcraft/core] No transaction in progress, ignoring discardTransaction");
+			return;
+		}
+		const restored = transactionSnapshot !== null && transactionSnapshot !== store.getSnapshot();
+		if (restored) store.restoreSnapshot(transactionSnapshot);
+		resetTransaction();
+		emitChange();
+		if (restored) eventHub.emit(EventName.SCHEMA_CHANGED, store.getSnapshot());
+	}
+	function isInTransaction() {
+		return inTransaction;
+	}
+	function clear() {
+		undoStack.length = 0;
+		redoStack.length = 0;
+		resetTransaction();
+		emitChange();
+	}
+	const history = {
+		state,
+		pushSnapshot,
+		undo,
+		redo,
+		canUndo,
+		canRedo,
+		beginTransaction,
+		commitTransaction,
+		discardTransaction,
+		isInTransaction,
+		clear
+	};
+	ownedSnapshotPushers.set(history, pushOwnedSnapshot);
+	return history;
+}
+//#endregion
+//#region src/command-bus.ts
+const COMMAND_EVENT_MAP = {
+	[CommandType.ADD_NODE]: EventName.NODE_ADDED,
+	[CommandType.MOVE_NODE]: EventName.NODE_MOVED,
+	[CommandType.REMOVE_NODE]: EventName.NODE_REMOVED,
+	[CommandType.DUPLICATE_NODE]: EventName.NODE_DUPLICATED,
+	[CommandType.CHANGE_CONTAINER_VARIANT]: EventName.CONTAINER_VARIANT_CHANGED,
+	[CommandType.UPDATE_PROPS]: EventName.NODE_UPDATED,
+	[CommandType.SET_GLOBAL_CONFIG]: EventName.GLOBAL_CONFIG_CHANGED
+};
+function normalizeHandlerResult(result) {
+	if (result === false) return {
+		ok: false,
+		code: "COMMAND_REJECTED"
+	};
+	if (!result) return {
+		ok: true,
+		changed: true
+	};
+	if (!result.ok) return result;
+	return {
+		...result,
+		changed: result.changed ?? true
+	};
+}
+function createCommandBus(store, registry, eventHub, history) {
+	const handlers = /* @__PURE__ */ new Map();
+	let executing = false;
+	const interactionStore = {
+		selectedNodeId: readonly(store.selectedNodeId),
+		hoveredNodeId: readonly(store.hoveredNodeId),
+		selectNode: store.selectNode,
+		hoverNode: store.hoverNode
+	};
+	function registerHandler(type, handler) {
+		handlers.set(type, handler);
+	}
+	function execute(command) {
+		if (executing) return {
+			ok: false,
+			code: "COMMAND_REENTRANT"
+		};
+		executing = true;
+		try {
+			const handler = handlers.get(command.type);
+			if (!handler) {
+				console.warn(`[dragcraft/core] No handler registered for command type: "${command.type}"`);
+				return {
+					ok: false,
+					code: "COMMAND_HANDLER_MISSING"
+				};
+			}
+			const beforeSnapshot = store.getSnapshot();
+			const draft = cloneSchema(beforeSnapshot);
+			const ctx = {
+				schema: beforeSnapshot,
+				draft,
+				store: interactionStore,
+				registry
+			};
+			let result;
+			try {
+				result = handler(ctx, command.payload);
+			} catch (error) {
+				console.error(`[dragcraft/core] Command "${command.type}" failed, discarding draft:`, error);
+				return {
+					ok: false,
+					code: "COMMAND_HANDLER_FAILED",
+					message: error instanceof Error ? error.message : String(error)
+				};
+			}
+			const normalized = normalizeHandlerResult(result);
+			if (!normalized.ok) return normalized;
+			if (!normalized.changed) return normalized;
+			const snapshot = store.commitSchema(draft);
+			pushOwnedHistorySnapshot(history, command.type, beforeSnapshot);
+			const specificEvent = COMMAND_EVENT_MAP[command.type];
+			if (specificEvent) eventHub.emit(specificEvent, normalized.eventPayload ?? command.payload);
+			eventHub.emit(EventName.SCHEMA_CHANGED, snapshot);
+			return normalized;
+		} finally {
+			executing = false;
+		}
+	}
+	return {
+		execute,
+		registerHandler
+	};
+}
+//#endregion
+//#region src/schema-index.ts
+function buildSchemaIndex(schema) {
+	const index = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const add = (node, location) => {
+		if (node.id === schema.root.id) diagnostics.push({
+			code: "SCHEMA_NODE_ID_DUPLICATE",
+			severity: "error",
+			nodeId: node.id,
+			...location.owner === "root" ? {} : {
+				ownerId: location.owner,
+				regionId: location.regionId
+			}
+		});
+		if (index.has(node.id)) diagnostics.push({
+			code: "SCHEMA_NODE_ID_DUPLICATE",
+			severity: "error",
+			nodeId: node.id
+		});
+		else index.set(node.id, {
+			node,
+			...location
+		});
+	};
+	for (const [rootIndex, node] of (schema.root.children ?? []).entries()) {
+		add(node, {
+			owner: "root",
+			index: rootIndex,
+			depth: 1
+		});
+		for (const [regionId, children] of Object.entries(node.container?.regions ?? {})) for (const [childIndex, child] of children.entries()) {
+			add(child, {
+				owner: node.id,
+				regionId,
+				index: childIndex,
+				depth: 2
+			});
+			if (child.container) diagnostics.push({
+				code: "SCHEMA_CONTAINER_NESTED",
+				severity: "error",
+				nodeId: child.id,
+				ownerId: node.id,
+				regionId
+			});
+		}
+	}
+	return {
+		index,
+		diagnostics
+	};
+}
+function findIndexedNode(result, nodeId) {
+	return result.index.get(nodeId);
+}
+//#endregion
+//#region src/schema-validation.ts
+function isRecord$2(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function collectSchemaStructuralDiagnostics(input) {
+	const diagnostics = [];
+	if (!isRecord$2(input) || typeof input.version !== "string" || input.version.length === 0 || !Object.hasOwn(input, "root") || !input.root) {
+		diagnostics.push({
+			code: "SCHEMA_ENVELOPE_INVALID",
+			severity: "error"
+		});
+		return diagnostics;
+	}
+	if (!isRecord$2(input.globalConfig)) {
+		diagnostics.push({
+			code: "SCHEMA_GLOBAL_CONFIG_INVALID",
+			severity: "error",
+			path: "globalConfig"
+		});
+		return diagnostics;
+	}
+	const root = input.root;
+	if (!isRecord$2(root) || typeof root.id !== "string" || typeof root.type !== "string" || !isRecord$2(root.props)) {
+		diagnostics.push({
+			code: "SCHEMA_ROOT_INVALID",
+			severity: "error",
+			path: "root"
+		});
+		return diagnostics;
+	}
+	const inspectNode = (value, path, ownerId, regionId) => {
+		if (!isRecord$2(value) || typeof value.id !== "string" || typeof value.type !== "string" || !isRecord$2(value.props)) {
+			diagnostics.push({
+				code: "SCHEMA_NODE_INVALID",
+				severity: "error",
+				path,
+				nodeId: isRecord$2(value) && typeof value.id === "string" ? value.id : void 0,
+				ownerId,
+				regionId
+			});
+			return;
+		}
+		const nodeId = value.id;
+		if (value.container === void 0) return;
+		if (!isRecord$2(value.container) || typeof value.container.variant !== "string") {
+			diagnostics.push({
+				code: "CONTAINER_STATE_INVALID",
+				severity: "error",
+				nodeId,
+				path: `${path}.container`
+			});
+			return;
+		}
+		if (!isRecord$2(value.container.regions)) {
+			diagnostics.push({
+				code: "CONTAINER_REGIONS_INVALID",
+				severity: "error",
+				nodeId,
+				path: `${path}.container.regions`
+			});
+			return;
+		}
+		for (const [childRegionId, children] of Object.entries(value.container.regions)) {
+			if (!Array.isArray(children)) {
+				diagnostics.push({
+					code: "CONTAINER_REGION_CHILDREN_INVALID",
+					severity: "error",
+					nodeId,
+					regionId: childRegionId,
+					path: `${path}.container.regions.${childRegionId}`
+				});
+				continue;
+			}
+			children.forEach((child, index) => inspectNode(child, `${path}.container.regions.${childRegionId}.${index}`, nodeId, childRegionId));
+		}
+	};
+	if (root.children !== void 0 && !Array.isArray(root.children)) {
+		diagnostics.push({
+			code: "SCHEMA_CHILDREN_INVALID",
+			severity: "error",
+			path: "root.children"
+		});
+		return diagnostics;
+	}
+	for (const [index, node] of (root.children ?? []).entries()) inspectNode(node, `root.children.${index}`);
+	return diagnostics;
+}
+function validateSchema(input, registry) {
+	const schema = cloneSchema(input);
+	const structuralDiagnostics = collectSchemaStructuralDiagnostics(schema);
+	if (structuralDiagnostics.length > 0) return {
+		valid: false,
+		schema,
+		diagnostics: structuralDiagnostics
+	};
+	const diagnostics = [...buildSchemaIndex(schema).diagnostics];
+	for (const node of schema.root.children ?? []) {
+		for (const [regionId, children] of Object.entries(node.container?.regions ?? {})) for (const child of children) {
+			if (registry.getWidget(child.type)?.container && !child.container) diagnostics.push({
+				code: "SCHEMA_CONTAINER_NESTED",
+				severity: "error",
+				nodeId: child.id,
+				ownerId: node.id,
+				regionId
+			});
+			if (child.layout?.placement !== void 0 || child.layout?.order !== void 0) diagnostics.push({
+				code: "CONTAINER_CHILD_PAGE_LAYOUT_FORBIDDEN",
+				severity: "error",
+				nodeId: child.id,
+				ownerId: node.id,
+				regionId
+			});
+		}
+		const meta = registry.getWidget(node.type);
+		if (node.container && !meta) {
+			diagnostics.push({
+				code: "UNRESOLVED_CONTAINER_TYPE",
+				severity: "warning",
+				nodeId: node.id
+			});
+			continue;
+		}
+		if (node.container && !meta?.container) {
+			diagnostics.push({
+				code: "CONTAINER_CAPABILITY_MISMATCH",
+				severity: "error",
+				nodeId: node.id
+			});
+			continue;
+		}
+		if (!node.container && meta?.container) {
+			diagnostics.push({
+				code: "CONTAINER_STATE_MISSING",
+				severity: "error",
+				nodeId: node.id
+			});
+			continue;
+		}
+		if (!node.container || !meta?.container) continue;
+		const variant = meta.container.variants[node.container.variant];
+		if (!variant) {
+			diagnostics.push({
+				code: "CONTAINER_VARIANT_UNKNOWN",
+				severity: "error",
+				nodeId: node.id
+			});
+			continue;
+		}
+		const knownRegionIds = new Set(variant.regions.map((region) => region.id));
+		for (const regionId of Object.keys(node.container.regions)) if (!knownRegionIds.has(regionId)) diagnostics.push({
+			code: "CONTAINER_REGION_UNKNOWN",
+			severity: "error",
+			nodeId: node.id,
+			regionId
+		});
+		for (const region of variant.regions) node.container.regions[region.id] ??= [];
+		for (const region of variant.regions) {
+			const children = node.container.regions[region.id];
+			const { minItems = 0, maxItems = Number.POSITIVE_INFINITY } = region.constraints ?? {};
+			if (children.length < minItems) diagnostics.push({
+				code: "CONTAINER_REGION_MIN_ITEMS",
+				severity: "error",
+				nodeId: node.id,
+				regionId: region.id,
+				details: {
+					actual: children.length,
+					minItems
+				}
+			});
+			if (children.length > maxItems) diagnostics.push({
+				code: "CONTAINER_REGION_MAX_ITEMS",
+				severity: "error",
+				nodeId: node.id,
+				regionId: region.id,
+				details: {
+					actual: children.length,
+					maxItems
+				}
+			});
+			for (const child of children) {
+				if (region.constraints?.includeTypes && !region.constraints.includeTypes.includes(child.type)) diagnostics.push({
+					code: "CONTAINER_TYPE_NOT_INCLUDED",
+					severity: "error",
+					nodeId: child.id,
+					ownerId: node.id,
+					regionId: region.id
+				});
+				if (region.constraints?.excludeTypes?.includes(child.type)) diagnostics.push({
+					code: "CONTAINER_TYPE_EXCLUDED",
+					severity: "error",
+					nodeId: child.id,
+					ownerId: node.id,
+					regionId: region.id
+				});
+			}
+		}
+	}
+	return {
+		valid: diagnostics.every((item) => item.severity !== "error"),
+		schema,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/container-placement.ts
+function placementFailureDetails(ctx) {
+	return {
+		nodeId: ctx.child.id,
+		containerId: ctx.callbackContext.container.id,
+		regionId: ctx.region.id
+	};
+}
+function resolvePlacementDecision(ctx) {
+	if (ctx.child.container || ctx.childHasContainerCapability) return {
+		allowed: false,
+		code: "CONTAINER_NESTING_FORBIDDEN"
+	};
+	const constraints = ctx.region.constraints ?? {};
+	if (constraints.includeTypes && !constraints.includeTypes.includes(ctx.child.type)) return {
+		allowed: false,
+		code: "CONTAINER_TYPE_NOT_INCLUDED"
+	};
+	if (constraints.excludeTypes?.includes(ctx.child.type)) return {
+		allowed: false,
+		code: "CONTAINER_TYPE_EXCLUDED"
+	};
+	if (ctx.targetCount + 1 > (constraints.maxItems ?? Number.POSITIVE_INFINITY)) return {
+		allowed: false,
+		code: "CONTAINER_REGION_MAX_ITEMS"
+	};
+	try {
+		const decision = cloneDeep(ctx.definition.canPlace?.(cloneDeep(ctx.callbackContext)) ?? { allowed: true });
+		if (!decision || typeof decision.allowed !== "boolean") return {
+			allowed: false,
+			code: "CONTAINER_PLACEMENT_PREDICATE_INVALID",
+			details: placementFailureDetails(ctx)
+		};
+		return decision;
+	} catch (error) {
+		return {
+			allowed: false,
+			code: "CONTAINER_PLACEMENT_PREDICATE_FAILED",
+			message: error instanceof Error ? error.message : String(error),
+			details: placementFailureDetails(ctx)
+		};
+	}
+}
+function isContainerState$1(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.variant === "string" && Boolean(candidate.regions) && typeof candidate.regions === "object" && !Array.isArray(candidate.regions) && Object.values(candidate.regions).every(Array.isArray);
+}
+function buildCandidateIndex(schema, candidateNode) {
+	return buildSchemaIndex({
+		version: schema.version,
+		globalConfig: {},
+		root: {
+			id: schema.root.id,
+			type: schema.root.type,
+			props: {},
+			children: [candidateNode]
+		}
+	});
+}
+function createContainerState(node, schema, registry, createNode) {
+	const definition = registry.getWidget(node.type)?.container;
+	if (!definition) return {
+		ok: false,
+		code: "CONTAINER_DEFINITION_MISSING"
+	};
+	const variant = definition.variants[definition.defaultVariant];
+	if (!variant) return {
+		ok: false,
+		code: "CONTAINER_DEFAULT_VARIANT_MISSING"
+	};
+	const emptyState = {
+		variant: definition.defaultVariant,
+		regions: Object.fromEntries(variant.regions.map((region) => [region.id, []]))
+	};
+	let state = emptyState;
+	try {
+		state = cloneDeep(definition.createInitialState ? definition.createInitialState({
+			containerNode: cloneDeep(node),
+			schema: cloneSchema(schema),
+			createNode
+		}) : emptyState);
+	} catch (error) {
+		return {
+			ok: false,
+			code: "CONTAINER_INITIAL_STATE_FAILED",
+			message: error instanceof Error ? error.message : String(error),
+			details: {
+				nodeId: node.id,
+				containerId: node.id
+			}
+		};
+	}
+	if (!isContainerState$1(state)) return {
+		ok: false,
+		code: "CONTAINER_INITIAL_STATE_INVALID",
+		details: {
+			nodeId: node.id,
+			containerId: node.id,
+			diagnostics: []
+		}
+	};
+	const candidateNode = cloneDeep(node);
+	candidateNode.container = state;
+	try {
+		const candidateIndex = buildCandidateIndex(schema, candidateNode);
+		const candidateNodeIds = new Set(candidateIndex.index.keys());
+		const candidateSchema = cloneSchema(schema);
+		candidateSchema.root.children ??= [];
+		candidateSchema.root.children.push(candidateNode);
+		const ownDiagnostics = validateSchema(candidateSchema, registry).diagnostics.filter((diagnostic) => diagnostic.nodeId === node.id || diagnostic.ownerId === node.id || diagnostic.nodeId !== void 0 && candidateNodeIds.has(diagnostic.nodeId));
+		if (ownDiagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+			ok: false,
+			code: "CONTAINER_INITIAL_STATE_INVALID",
+			details: {
+				nodeId: node.id,
+				containerId: node.id,
+				diagnostics: ownDiagnostics
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			code: "CONTAINER_INITIAL_STATE_INVALID",
+			message: error instanceof Error ? error.message : String(error),
+			details: {
+				nodeId: node.id,
+				containerId: node.id,
+				diagnostics: []
+			}
+		};
+	}
+	return {
+		ok: true,
+		state: cloneDeep(state)
+	};
+}
+function createRegisteredNode(registry, createId = generateShortId) {
+	return (type, overrides = {}) => {
+		const meta = registry.getWidget(type);
+		if (!meta) throw new Error(`Cannot initialize unregistered widget type: ${type}`);
+		const layout = overrides.layout !== void 0 ? cloneDeep(overrides.layout) : cloneDeep(meta.defaultLayout);
+		if (layout) {
+			delete layout.placement;
+			delete layout.order;
+		}
+		return {
+			id: createId(),
+			type,
+			props: {
+				...cloneDeep(meta.defaultProps),
+				...cloneDeep(overrides.props ?? {})
+			},
+			style: overrides.style !== void 0 ? cloneDeep(overrides.style) : cloneDeep(meta.defaultStyle),
+			layout
+		};
+	};
+}
+//#endregion
+//#region src/helpers.ts
+function cloneNodeSubtree(node, createId) {
+	const clone = cloneDeep(node);
+	clone.id = createId();
+	for (const children of Object.values(clone.container?.regions ?? {})) for (let index = 0; index < children.length; index++) children[index] = cloneNodeSubtree(children[index], createId);
+	return clone;
+}
+function collectSubtreeIds(node) {
+	const ids = /* @__PURE__ */ new Set([node.id]);
+	for (const children of Object.values(node.container?.regions ?? {})) for (const child of children) for (const id of collectSubtreeIds(child)) ids.add(id);
+	return ids;
+}
+/**
+* Find a node by ID in the shallow ownership structure.
+*/
+function findNodeById(root, id) {
+	if (root.id === id) return root;
+	return buildSchemaIndex({
+		version: "",
+		globalConfig: {},
+		root
+	}).index.get(id)?.node ?? null;
+}
+/**
+* Find the parent node of a given node ID.
+* Returns the owning root or container location, or null if not found.
+*/
+function findParentNode(root, targetId) {
+	const indexed = buildSchemaIndex({
+		version: "",
+		globalConfig: {},
+		root
+	});
+	const location = indexed.index.get(targetId);
+	if (!location) return null;
+	if (location.owner === "root") return {
+		parent: root,
+		index: location.index
+	};
+	const parent = indexed.index.get(location.owner)?.node;
+	return parent && location.regionId ? {
+		parent,
+		regionId: location.regionId,
+		index: location.index
+	} : null;
+}
+/**
+* Remove a node from the tree by ID.
+* Returns the removed node or null if not found.
+*/
+function removeNodeFromTree(root, nodeId) {
+	const result = findParentNode(root, nodeId);
+	if (!result || result.regionId) return null;
+	const { parent, index } = result;
+	return parent.children.splice(index, 1)[0];
+}
+/**
+* Insert a node into a parent's children array at a given index.
+* If index is undefined, appends to the end.
+*/
+function insertNodeIntoTree(parent, node, index) {
+	if (!parent.children) parent.children = [];
+	if (index !== void 0 && index >= 0 && index <= parent.children.length) parent.children.splice(index, 0, node);
+	else parent.children.push(node);
+}
+/**
+* Walk root and its direct children (one level), calling visitor for each node.
+* If visitor returns false, stop traversal.
+*
+* Note: This does NOT recurse into grandchildren — the schema is a flat
+* two-level structure (root → widgets).
+*/
+function walkFlatChildren(root, visitor) {
+	if (visitor(root) === false) return;
+	if (root.children) {
+		for (const child of root.children) if (visitor(child) === false) return;
+	}
+}
+//#endregion
+//#region src/layout.ts
+const DEFAULT_LAYOUT_REGION = "content";
+const DEFAULT_SORT_SCOPE = "content";
+const DEFAULT_LAYER = "float";
+function resolveFlowPlacement(placement) {
+	const region = placement?.region ?? "content";
+	return {
+		kind: "flow",
+		region,
+		sortScope: placement?.sortScope === void 0 ? region === "content" ? DEFAULT_SORT_SCOPE : false : placement.sortScope
+	};
+}
+function resolveChromePlacement(placement) {
+	return {
+		kind: "chrome",
+		edge: placement.edge,
+		position: placement.position ?? "fixed",
+		reserve: {
+			mode: placement.reserve?.mode ?? "measure",
+			size: placement.reserve?.size
+		},
+		avoidContent: placement.avoidContent ?? true
+	};
+}
+function resolveLayerPlacement(placement) {
+	const hasAnchor = placement.anchor !== void 0;
+	return {
+		kind: "layer",
+		layer: placement.layer ?? "float",
+		mode: placement.mode ?? (hasAnchor ? "framework" : "self"),
+		anchor: placement.anchor ?? {
+			block: "end",
+			inline: "end"
+		},
+		offset: placement.offset,
+		avoid: placement.avoid ?? ["safe-area", "chrome"]
+	};
+}
+function resolvePlacement(placement) {
+	if (!placement || placement.kind === "flow") return resolveFlowPlacement(placement);
+	if (placement.kind === "chrome") return resolveChromePlacement(placement);
+	return resolveLayerPlacement(placement);
+}
+function resolveNodeLayout(node, registry, schema) {
+	const layout = {
+		...registry.getWidget(node.type)?.defaultLayout ?? {},
+		...node.layout ?? {}
+	};
+	const placement = resolvePlacement(layout.placement);
+	const rawVisible = layout.visible ?? true;
+	const visible = typeof rawVisible === "function" ? schema !== void 0 && rawVisible({
+		node,
+		schema
+	}) : rawVisible;
+	return {
+		placement,
+		region: placement.kind === "flow" ? placement.region : void 0,
+		sortScope: placement.kind === "flow" ? placement.sortScope : false,
+		order: layout.order,
+		visible
+	};
+}
+function sortEntries(entries) {
+	entries.sort((a, b) => {
+		const orderA = a.layout.order ?? a.arrayIndex;
+		const orderB = b.layout.order ?? b.arrayIndex;
+		if (orderA !== orderB) return orderA - orderB;
+		return a.arrayIndex - b.arrayIndex;
+	});
+}
+function pushEntry(map, key, entry) {
+	const entries = map.get(key);
+	if (entries) entries.push(entry);
+	else map.set(key, [entry]);
+}
+function edgeOrder(edge) {
+	switch (edge) {
+		case "block-start": return 0;
+		case "inline-start": return 1;
+		case "inline-end": return 2;
+		case "block-end": return 3;
+	}
+}
+function createLayoutPlan(schema, registry) {
+	const children = schema.root.children ?? [];
+	const entries = [];
+	const regions = /* @__PURE__ */ new Map();
+	const chrome = [];
+	const layers = /* @__PURE__ */ new Map();
+	const sortScopes = /* @__PURE__ */ new Map();
+	for (let arrayIndex = 0; arrayIndex < children.length; arrayIndex++) {
+		const node = children[arrayIndex];
+		const layout = resolveNodeLayout(node, registry, schema);
+		const entry = {
+			node,
+			arrayIndex,
+			layout
+		};
+		entries.push(entry);
+		const placement = layout.placement;
+		if (placement.kind === "flow") {
+			pushEntry(regions, placement.region, entry);
+			if (placement.sortScope !== false) pushEntry(sortScopes, placement.sortScope, entry);
+		} else if (placement.kind === "chrome") chrome.push(entry);
+		else pushEntry(layers, placement.layer, entry);
+	}
+	sortEntries(entries);
+	for (const regionEntries of regions.values()) sortEntries(regionEntries);
+	for (const scopeEntries of sortScopes.values()) sortEntries(scopeEntries);
+	for (const layerEntries of layers.values()) sortEntries(layerEntries);
+	chrome.sort((a, b) => {
+		const placementA = a.layout.placement;
+		const placementB = b.layout.placement;
+		const edgeDelta = edgeOrder(placementA.edge) - edgeOrder(placementB.edge);
+		if (edgeDelta !== 0) return edgeDelta;
+		const orderA = a.layout.order ?? a.arrayIndex;
+		const orderB = b.layout.order ?? b.arrayIndex;
+		if (orderA !== orderB) return orderA - orderB;
+		return a.arrayIndex - b.arrayIndex;
+	});
+	return {
+		entries,
+		regions,
+		chrome,
+		layers,
+		sortScopes,
+		insets: { contributors: chrome.map((entry) => {
+			const placement = entry.layout.placement;
+			return placement.avoidContent ? {
+				edge: placement.edge,
+				sourceNodeId: entry.node.id,
+				reserve: placement.reserve
+			} : null;
+		}).filter((item) => item !== null) }
+	};
+}
+function getLayoutRegionEntries(plan, region = DEFAULT_LAYOUT_REGION) {
+	return plan.regions.get(region) ?? [];
+}
+function getSortScopeEntries(plan, sortScope = DEFAULT_SORT_SCOPE) {
+	return plan.sortScopes.get(sortScope) ?? [];
+}
+function getSortScopeNodes(plan, sortScope = DEFAULT_SORT_SCOPE) {
+	return getSortScopeEntries(plan, sortScope).map((entry) => entry.node);
+}
+function getSortableArrayIndexForInsert(scopeEntries, allChildren, visualIndex) {
+	if (scopeEntries.length === 0) return allChildren.length;
+	if (visualIndex <= 0) return scopeEntries[0].arrayIndex;
+	if (visualIndex >= scopeEntries.length) return scopeEntries[scopeEntries.length - 1].arrayIndex + 1;
+	return scopeEntries[visualIndex].arrayIndex;
+}
+function resolveNodeSource(schema, indexed, nodeId) {
+	const location = indexed.index.get(nodeId);
+	if (!location) return {
+		ok: false,
+		code: "NODE_NOT_FOUND"
+	};
+	if (location.owner === "root") return {
+		ok: true,
+		value: {
+			location,
+			children: schema.root.children ?? [],
+			index: location.index,
+			destination: {
+				kind: "root",
+				index: location.index
+			}
+		}
+	};
+	const owner = indexed.index.get(location.owner)?.node;
+	const regionId = location.regionId;
+	const children = regionId ? owner?.container?.regions[regionId] : void 0;
+	if (!owner || !regionId || !children) return {
+		ok: false,
+		code: "CONTAINER_OWNER_INVALID"
+	};
+	return {
+		ok: true,
+		value: {
+			location,
+			children,
+			index: location.index,
+			destination: {
+				kind: "container",
+				containerId: owner.id,
+				regionId,
+				index: location.index
+			}
+		}
+	};
+}
+function resolveDestination(schema, registry, destination) {
+	if (destination.kind === "root") {
+		schema.root.children ??= [];
+		return {
+			ok: true,
+			value: {
+				children: schema.root.children,
+				destination
+			}
+		};
+	}
+	const location = buildSchemaIndex(schema).index.get(destination.containerId);
+	const container = location?.owner === "root" ? location.node : void 0;
+	const definition = container && registry.getWidget(container.type)?.container;
+	const variant = container?.container && definition?.variants[container.container.variant];
+	const region = variant?.regions.find((item) => item.id === destination.regionId);
+	const children = container?.container?.regions[destination.regionId];
+	if (!container || !definition || !variant) return {
+		ok: false,
+		code: "CONTAINER_UNRESOLVED"
+	};
+	if (!region || !children) return {
+		ok: false,
+		code: "CONTAINER_REGION_UNKNOWN"
+	};
+	return {
+		ok: true,
+		value: {
+			children,
+			destination,
+			container,
+			definition,
+			variant,
+			region
+		}
+	};
+}
+function clampInsertIndex(index, length) {
+	return Math.max(0, Math.min(index ?? length, length));
+}
+function stripPageLayout(node) {
+	const clone = cloneDeep(node);
+	if (clone.layout) {
+		delete clone.layout.placement;
+		delete clone.layout.order;
+	}
+	return clone;
+}
+//#endregion
+//#region src/sortable.ts
+/**
+* Collect the indices of all widgets whose `sortable` behavior resolves to false.
+* These widgets must stay at their current array index (absolute index locking).
+*
+* @param _children - The flat widget list (`root.children`)
+* @param registry - Widget meta registry for resolving behavior predicates
+* @param schema   - Current designer schema (for predicate evaluation context)
+* @param sortScope - Sort scope to evaluate
+*/
+function getLockedIndices(_children, registry, schema, sortScope = DEFAULT_SORT_SCOPE) {
+	return getLockedIndicesFromEntries(getSortScopeEntries(createLayoutPlan(schema, registry), sortScope), registry, schema);
+}
+function getLockedIndicesFromEntries(scopeEntries, registry, schema) {
+	return getLockedIndicesFromNodes(scopeEntries.map((entry) => entry.node), registry, schema);
+}
+function getLockedIndicesFromNodes(nodes, registry, schema) {
+	const locked = /* @__PURE__ */ new Set();
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const meta = registry.getWidget(node.type);
+		if (!meta) continue;
+		if (!resolveBehavior(meta.sortable, {
+			node,
+			schema
+		})) locked.add(i);
+	}
+	return locked;
+}
+/**
+* Can a new node be inserted at `insertIndex` without shifting any locked widget?
+*
+* Inserting at index `i` shifts all widgets at index >= `i` rightward by 1.
+* If any locked widget has index >= `insertIndex`, it would be displaced.
+*/
+function isInsertAllowed(insertIndex, lockedIndices) {
+	for (const L of lockedIndices) if (L >= insertIndex) return false;
+	return true;
+}
+/**
+* Can a node be moved from `srcIdx` to `targetIdx` (post-removal insertion index)
+* without altering any locked widget's absolute position?
+*
+* Mathematical analysis for each locked widget at index L (L !== srcIdx):
+* - srcIdx < L: Removal shifts L to L-1. Insertion must be at targetIdx <= L-1 to restore it.
+* - srcIdx > L: L is unaffected by removal. Insertion must satisfy targetIdx > L to keep it at L.
+*/
+function isMoveAllowed(srcIdx, targetIdx, lockedIndices) {
+	if (lockedIndices.has(srcIdx)) return false;
+	for (const L of lockedIndices) {
+		if (L === srcIdx) continue;
+		if (srcIdx < L) {
+			if (targetIdx > L - 1) return false;
+		} else if (targetIdx <= L) return false;
+	}
+	return true;
+}
+/**
+* Can a node at `removeIndex` be removed without shifting any locked widget?
+*
+* Removing at index `i` shifts all widgets at index > `i` leftward by 1.
+* If any locked widget has index > `removeIndex`, it would be displaced.
+*/
+function isRemoveAllowed(removeIndex, lockedIndices) {
+	for (const L of lockedIndices) if (L > removeIndex) return false;
+	return true;
+}
+/**
+* Compute the set of valid visual drop indices (0..children.length) for a drag operation.
+*
+* For new-widget drops (sourceNodeId === null): checks isInsertAllowed for each position.
+* For existing-widget moves: converts visual gap index to post-removal target index
+* and checks isMoveAllowed.
+*
+* @param children     - The flat widget list
+* @param lockedIndices - Pre-computed locked indices from getLockedIndices()
+* @param sourceNodeId  - ID of the dragged widget (null if dragging from material panel)
+*/
+function getValidDropIndices(children, lockedIndices, sourceNodeId) {
+	const valid = /* @__PURE__ */ new Set();
+	const n = children.length;
+	if (lockedIndices.size === 0) {
+		for (let i = 0; i <= n; i++) valid.add(i);
+		return valid;
+	}
+	if (sourceNodeId === null) {
+		for (let i = 0; i <= n; i++) if (isInsertAllowed(i, lockedIndices)) valid.add(i);
+	} else {
+		const srcIdx = children.findIndex((c) => "node" in c ? c.node.id === sourceNodeId : c.id === sourceNodeId);
+		if (srcIdx === -1) return valid;
+		for (let visualIdx = 0; visualIdx <= n; visualIdx++) {
+			let targetIdx = visualIdx;
+			if (targetIdx > srcIdx) targetIdx = targetIdx - 1;
+			if (targetIdx === srcIdx) {
+				valid.add(visualIdx);
+				continue;
+			}
+			if (isMoveAllowed(srcIdx, targetIdx, lockedIndices)) valid.add(visualIdx);
+		}
+	}
+	return valid;
+}
+/**
+* Given a raw visual index and a set of valid indices, find the nearest valid one.
+* Returns null if no valid index exists.
+*/
+function findNearestValidIndex(rawIndex, validIndices) {
+	if (validIndices.size === 0) return null;
+	if (validIndices.has(rawIndex)) return rawIndex;
+	let best = null;
+	let bestDist = Infinity;
+	for (const v of validIndices) {
+		const dist = Math.abs(v - rawIndex);
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = v;
+		}
+	}
+	return best;
+}
+//#endregion
+//#region src/commands/add-node.ts
+function addNodeHandler(ctx, payload) {
+	const { draft: rawSchema, registry } = ctx;
+	const safeSchema = ctx.schema;
+	const meta = registry.getWidget(payload.node.type);
+	const destination = payload.destination ?? { kind: "root" };
+	const createDecision = meta ? resolveCreatable(meta.creatable, {
+		widgetType: payload.node.type,
+		schema: ctx.schema
+	}, true) : { allowed: true };
+	if (!createDecision.allowed) {
+		const reason = createDecision.message ?? createDecision.messageKey ?? createDecision.code;
+		console.warn(`[dragcraft/core] ADD_NODE: blocked by creatable constraint for widget type "${payload.node.type}"${reason ? ` (${reason})` : ""}`);
+		return {
+			ok: false,
+			code: createDecision.code ?? "NODE_NOT_CREATABLE",
+			messageKey: createDecision.messageKey,
+			message: createDecision.message
+		};
+	}
+	const node = cloneDeep(payload.node);
+	const candidateNodeIds = collectSubtreeIds(node);
+	if (node.container && !meta) return {
+		ok: false,
+		code: "UNRESOLVED_CONTAINER_READ_ONLY"
+	};
+	if (node.container && !meta?.container) return {
+		ok: false,
+		code: "CONTAINER_CAPABILITY_MISMATCH"
+	};
+	if (destination.kind === "container" && meta?.container) return {
+		ok: false,
+		code: "CONTAINER_NESTING_FORBIDDEN"
+	};
+	if (meta?.container && !node.container) {
+		const initialized = createContainerState(node, safeSchema, registry, createRegisteredNode(registry));
+		if (!initialized.ok) return initialized;
+		node.container = initialized.state;
+	}
+	const idCandidate = cloneSchema(safeSchema);
+	idCandidate.root.children ??= [];
+	idCandidate.root.children.push(cloneDeep(node));
+	const idDiagnostics = buildSchemaIndex(idCandidate).diagnostics.filter((diagnostic) => diagnostic.code === "SCHEMA_NODE_ID_DUPLICATE");
+	if (idDiagnostics.length > 0) return {
+		ok: false,
+		code: "SCHEMA_NODE_ID_DUPLICATE",
+		details: { diagnostics: idDiagnostics }
+	};
+	if (node.container) {
+		const candidate = cloneSchema(safeSchema);
+		candidate.root.children ??= [];
+		candidate.root.children.push(cloneDeep(node));
+		const candidateDiagnostics = validateSchema(candidate, registry).diagnostics.filter((diagnostic) => diagnostic.nodeId !== void 0 && candidateNodeIds.has(diagnostic.nodeId) || diagnostic.ownerId !== void 0 && candidateNodeIds.has(diagnostic.ownerId));
+		if (candidateDiagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+			ok: false,
+			code: "CONTAINER_STATE_INVALID",
+			details: { diagnostics: candidateDiagnostics }
+		};
+	}
+	if (destination.kind === "container") {
+		const targetResult = resolveDestination(safeSchema, registry, destination);
+		if (!targetResult.ok) return targetResult;
+		const target = targetResult.value;
+		if (!target.container || !target.definition || !target.variant || !target.region) return {
+			ok: false,
+			code: "CONTAINER_DESTINATION_REQUIRED"
+		};
+		const index = clampInsertIndex(destination.index, target.children.length);
+		if (!isInsertAllowed(index, getLockedIndicesFromNodes(target.children, registry, safeSchema))) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+		const decision = resolvePlacementDecision({
+			definition: target.definition,
+			region: target.region,
+			child: node,
+			childHasContainerCapability: Boolean(meta?.container),
+			targetCount: target.children.length,
+			callbackContext: {
+				operation: "add",
+				schema: safeSchema,
+				container: target.container,
+				variant: target.variant,
+				region: target.region,
+				child: node,
+				targetIndex: index
+			}
+		});
+		if (!decision.allowed) return {
+			ok: false,
+			code: decision.code ?? "CONTAINER_PLACEMENT_DENIED",
+			messageKey: decision.messageKey,
+			message: decision.message,
+			details: decision.details
+		};
+		const candidate = cloneSchema(safeSchema);
+		const candidateTarget = resolveDestination(candidate, registry, destination);
+		if (!candidateTarget.ok) return candidateTarget;
+		candidateTarget.value.children.splice(index, 0, stripPageLayout(cloneDeep(node)));
+		const candidateDiagnostics = validateSchema(candidate, registry).diagnostics.filter((diagnostic) => diagnostic.nodeId !== void 0 && candidateNodeIds.has(diagnostic.nodeId) || diagnostic.ownerId !== void 0 && candidateNodeIds.has(diagnostic.ownerId));
+		if (candidateDiagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+			ok: false,
+			code: "SCHEMA_CANDIDATE_INVALID",
+			details: { diagnostics: candidateDiagnostics }
+		};
+		const draftTarget = resolveDestination(rawSchema, registry, destination);
+		if (!draftTarget.ok) return draftTarget;
+		draftTarget.value.children.splice(index, 0, stripPageLayout(node));
+		return {
+			ok: true,
+			eventPayload: {
+				nodeId: node.id,
+				destination: {
+					...destination,
+					index
+				}
+			}
+		};
+	}
+	rawSchema.root.children ??= [];
+	const rootChildren = rawSchema.root.children;
+	const nodeLayout = resolveNodeLayout(node, registry);
+	const resolvedScope = destination.sortScope ?? (nodeLayout.sortScope === false ? void 0 : nodeLayout.sortScope);
+	let resolvedArrayIndex = rootChildren.length;
+	if (destination.index !== void 0 && resolvedScope !== void 0) {
+		const scopeEntries = getSortScopeEntries(createLayoutPlan(safeSchema, registry), resolvedScope);
+		const lockedIndices = getLockedIndicesFromEntries(scopeEntries, registry, safeSchema);
+		if (!isInsertAllowed(destination.index, lockedIndices)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+		resolvedArrayIndex = getSortableArrayIndexForInsert(scopeEntries, rootChildren, destination.index);
+	} else if (destination.index !== void 0) resolvedArrayIndex = clampInsertIndex(destination.index, rootChildren.length);
+	const candidate = cloneSchema(safeSchema);
+	candidate.root.children ??= [];
+	candidate.root.children.splice(resolvedArrayIndex, 0, cloneDeep(node));
+	const candidateDiagnostics = validateSchema(candidate, registry).diagnostics.filter((diagnostic) => diagnostic.nodeId !== void 0 && candidateNodeIds.has(diagnostic.nodeId) || diagnostic.ownerId !== void 0 && candidateNodeIds.has(diagnostic.ownerId));
+	if (candidateDiagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+		ok: false,
+		code: "SCHEMA_CANDIDATE_INVALID",
+		details: { diagnostics: candidateDiagnostics }
+	};
+	rootChildren.splice(resolvedArrayIndex, 0, node);
+	return {
+		ok: true,
+		eventPayload: {
+			nodeId: node.id,
+			destination: {
+				kind: "root",
+				sortScope: resolvedScope,
+				index: resolvedArrayIndex
+			}
+		}
+	};
+}
+//#endregion
+//#region src/commands/change-container-variant.ts
+function sameRegionIds(left, right) {
+	const leftIds = left.regions.map((region) => region.id).sort();
+	const rightIds = right.regions.map((region) => region.id).sort();
+	return leftIds.length === rightIds.length && leftIds.every((id, index) => id === rightIds[index]);
+}
+function isPlainRecord$1(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isSchemaNode(value) {
+	return isPlainRecord$1(value) && typeof value.id === "string" && typeof value.type === "string" && isPlainRecord$1(value.props);
+}
+function isContainerState(value) {
+	if (!isPlainRecord$1(value) || typeof value.variant !== "string" || !isPlainRecord$1(value.regions)) return false;
+	return Object.values(value.regions).every((children) => Array.isArray(children) && children.every(isSchemaNode));
+}
+function isOptionalString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function invalidMigrationResult(containerId) {
+	return {
+		allowed: false,
+		code: "CONTAINER_VARIANT_MIGRATION_INVALID"
+	};
+}
+function safelyMigrateVariant(definition, ctx) {
+	if (!definition.migrateVariant) return {
+		allowed: false,
+		code: "CONTAINER_VARIANT_MIGRATION_REQUIRED"
+	};
+	try {
+		const result = cloneDeep(definition.migrateVariant(cloneDeep(ctx)));
+		if (!isPlainRecord$1(result) || typeof result.allowed !== "boolean") return invalidMigrationResult(ctx.container.id);
+		if (result.allowed) {
+			if (!isContainerState(result.state)) return invalidMigrationResult(ctx.container.id);
+			return {
+				allowed: true,
+				state: result.state
+			};
+		}
+		if (!isOptionalString(result.code) || !isOptionalString(result.messageKey) || !isOptionalString(result.message) || result.details !== void 0 && !isPlainRecord$1(result.details)) return invalidMigrationResult(ctx.container.id);
+		return {
+			allowed: false,
+			code: result.code,
+			messageKey: result.messageKey,
+			message: result.message,
+			details: result.details
+		};
+	} catch (error) {
+		return {
+			allowed: false,
+			code: "CONTAINER_VARIANT_MIGRATION_FAILED",
+			message: error instanceof Error ? error.message : String(error),
+			details: {
+				nodeId: ctx.container.id,
+				containerId: ctx.container.id,
+				fromVariantId: ctx.fromVariantId,
+				toVariantId: ctx.toVariantId
+			}
+		};
+	}
+}
+function changeContainerVariantHandler(ctx, payload) {
+	const rawSchema = ctx.draft;
+	const indexed = buildSchemaIndex(rawSchema).index.get(payload.containerId);
+	const definition = indexed && ctx.registry.getWidget(indexed.node.type)?.container;
+	if (!indexed?.node.container || !definition) return {
+		ok: false,
+		code: "CONTAINER_UNRESOLVED"
+	};
+	const fromVariantId = indexed.node.container.variant;
+	const from = definition.variants[fromVariantId];
+	const to = definition.variants[payload.variant];
+	if (!from || !to) return {
+		ok: false,
+		code: "CONTAINER_VARIANT_UNKNOWN"
+	};
+	const result = definition.migrateVariant ? safelyMigrateVariant(definition, {
+		schema: rawSchema,
+		container: indexed.node,
+		fromVariantId,
+		toVariantId: payload.variant,
+		fromVariant: from,
+		toVariant: to,
+		state: indexed.node.container
+	}) : sameRegionIds(from, to) ? {
+		allowed: true,
+		state: {
+			...cloneDeep(indexed.node.container),
+			variant: payload.variant
+		}
+	} : safelyMigrateVariant(definition, {
+		schema: rawSchema,
+		container: indexed.node,
+		fromVariantId,
+		toVariantId: payload.variant,
+		fromVariant: from,
+		toVariant: to,
+		state: indexed.node.container
+	});
+	if (!result.allowed) return {
+		ok: false,
+		code: result.code ?? "CONTAINER_VARIANT_MIGRATION_REJECTED",
+		...result.messageKey === void 0 ? {} : { messageKey: result.messageKey },
+		...result.message === void 0 ? {} : { message: result.message },
+		...result.details === void 0 ? {} : { details: result.details }
+	};
+	if (result.state.variant !== payload.variant) return {
+		ok: false,
+		code: "CONTAINER_VARIANT_MIGRATION_TARGET_MISMATCH"
+	};
+	const candidate = cloneSchema(rawSchema);
+	const candidateNode = buildSchemaIndex(candidate).index.get(indexed.node.id)?.node;
+	if (!candidateNode) return {
+		ok: false,
+		code: "CONTAINER_NOT_FOUND"
+	};
+	candidateNode.container = cloneDeep(result.state);
+	const validation = validateSchema(candidate, ctx.registry);
+	if (!validation.valid) return {
+		ok: false,
+		code: "CONTAINER_VARIANT_MIGRATION_INVALID",
+		details: { diagnostics: validation.diagnostics }
+	};
+	const validatedState = buildSchemaIndex(validation.schema).index.get(indexed.node.id)?.node.container;
+	if (!validatedState) return {
+		ok: false,
+		code: "CONTAINER_VARIANT_MIGRATION_INVALID"
+	};
+	indexed.node.container = cloneDeep(validatedState);
+	return {
+		ok: true,
+		eventPayload: {
+			containerId: indexed.node.id,
+			fromVariant: fromVariantId,
+			toVariant: payload.variant
+		}
+	};
+}
+//#endregion
+//#region src/commands/duplicate-node.ts
+function duplicateNodeHandler(ctx, payload) {
+	const schema = ctx.schema;
+	const indexed = buildSchemaIndex(schema);
+	const sourceResult = resolveNodeSource(schema, indexed, payload.nodeId);
+	if (!sourceResult.ok) return sourceResult;
+	const source = sourceResult.value;
+	const sourceNode = source.location.node;
+	if (sourceNode.container && !ctx.registry.getWidget(sourceNode.type)?.container) return {
+		ok: false,
+		code: "UNRESOLVED_CONTAINER_READ_ONLY"
+	};
+	if (source.destination.kind === "container") {
+		const sourceDestination = source.destination;
+		const owner = indexed.index.get(sourceDestination.containerId)?.node;
+		const definition = owner && ctx.registry.getWidget(owner.type)?.container;
+		const variant = owner?.container && definition?.variants[owner.container.variant];
+		const region = variant?.regions.find((item) => item.id === sourceDestination.regionId);
+		if (!definition || !variant || !region) return {
+			ok: false,
+			code: "UNRESOLVED_CONTAINER_READ_ONLY"
+		};
+	}
+	const clone = cloneNodeSubtree(sourceNode, generateShortId);
+	let destination = {
+		...source.destination,
+		index: source.index + 1
+	};
+	if (source.destination.kind === "root") {
+		const sortScope = resolveNodeLayout(sourceNode, ctx.registry).sortScope;
+		if (sortScope !== false) {
+			const scopeIndex = getSortScopeEntries(createLayoutPlan(schema, ctx.registry), sortScope).findIndex((entry) => entry.node.id === sourceNode.id);
+			if (scopeIndex !== -1) destination = {
+				...source.destination,
+				index: scopeIndex + 1
+			};
+		}
+	}
+	const added = addNodeHandler(ctx, {
+		node: clone,
+		destination
+	});
+	if (!added) return {
+		ok: false,
+		code: "DUPLICATE_ADD_REJECTED"
+	};
+	if (!added.ok) return added;
+	const addedEvent = added.eventPayload;
+	return {
+		ok: true,
+		eventPayload: {
+			sourceNodeId: payload.nodeId,
+			nodeId: clone.id,
+			destination: addedEvent?.destination ?? destination
+		}
+	};
+}
+//#endregion
+//#region src/commands/move-node.ts
+function moveNodeHandler(ctx, payload) {
+	const { draft: rawSchema, registry } = ctx;
+	const safeSchema = ctx.schema;
+	const indexed = buildSchemaIndex(safeSchema);
+	const sourceResult = resolveNodeSource(safeSchema, indexed, payload.nodeId);
+	if (!sourceResult.ok) return sourceResult;
+	const targetResult = resolveDestination(safeSchema, registry, payload.destination);
+	if (!targetResult.ok) return targetResult;
+	const source = sourceResult.value;
+	const target = targetResult.value;
+	const node = source.location.node;
+	if (node.container && !registry.getWidget(node.type)?.container) return {
+		ok: false,
+		code: "UNRESOLVED_CONTAINER_READ_ONLY"
+	};
+	const sourceMeta = registry.getWidget(node.type);
+	const behaviorContext = {
+		node,
+		schema: safeSchema
+	};
+	if (!resolveBehavior(sourceMeta?.draggable, behaviorContext) || !resolveBehavior(sourceMeta?.sortable, behaviorContext)) return {
+		ok: false,
+		code: "NODE_NOT_MOVABLE"
+	};
+	if (source.destination.kind === "container") {
+		const sourceRegionId = source.destination.regionId;
+		const owner = indexed.index.get(source.destination.containerId)?.node;
+		const definition = owner && registry.getWidget(owner.type)?.container;
+		if (!definition) return {
+			ok: false,
+			code: "UNRESOLVED_CONTAINER_READ_ONLY"
+		};
+		const variant = owner?.container && definition.variants[owner.container.variant];
+		const region = variant?.regions.find((item) => item.id === sourceRegionId);
+		if (!variant || !region) return {
+			ok: false,
+			code: "UNRESOLVED_CONTAINER_READ_ONLY"
+		};
+		const sameRegion = target.children === source.children;
+		const minItems = region.constraints?.minItems ?? 0;
+		if (!sameRegion && source.children.length - 1 < minItems) return {
+			ok: false,
+			code: "CONTAINER_REGION_MIN_ITEMS"
+		};
+	}
+	let requestedIndex = payload.destination.kind === "container" ? clampInsertIndex(payload.destination.index, target.children.length) : Math.max(0, payload.destination.index ?? Number.MAX_SAFE_INTEGER);
+	const sameRegion = payload.destination.kind === "container" && source.destination.kind === "container" && target.children === source.children;
+	if (sameRegion && source.index < requestedIndex) requestedIndex -= 1;
+	if (sameRegion && source.index === requestedIndex) return {
+		ok: true,
+		changed: false
+	};
+	if (source.destination.kind === "container") {
+		const sourceLocks = getLockedIndicesFromNodes(source.children, registry, safeSchema);
+		if (sameRegion) {
+			if (!isMoveAllowed(source.index, requestedIndex, sourceLocks)) return {
+				ok: false,
+				code: "SORTABLE_LOCK_VIOLATION"
+			};
+		} else if (!isRemoveAllowed(source.index, sourceLocks)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+	}
+	if (payload.destination.kind === "container" && !sameRegion) {
+		const targetLocks = getLockedIndicesFromNodes(target.children, registry, safeSchema);
+		if (!isInsertAllowed(requestedIndex, targetLocks)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+	}
+	if (target.container && target.definition && target.variant && target.region) {
+		const targetCount = target.children.length - (target.children === source.children ? 1 : 0);
+		const decision = resolvePlacementDecision({
+			definition: target.definition,
+			region: target.region,
+			child: node,
+			childHasContainerCapability: Boolean(sourceMeta?.container),
+			targetCount,
+			callbackContext: {
+				operation: "move",
+				schema: safeSchema,
+				container: target.container,
+				variant: target.variant,
+				region: target.region,
+				child: node,
+				targetIndex: requestedIndex
+			}
+		});
+		if (!decision.allowed) return {
+			ok: false,
+			code: decision.code ?? "CONTAINER_PLACEMENT_DENIED",
+			messageKey: decision.messageKey,
+			message: decision.message,
+			details: decision.details
+		};
+	}
+	const sourceScope = source.destination.kind === "root" ? resolveNodeLayout(node, registry).sortScope : void 0;
+	const targetScope = payload.destination.kind === "root" ? payload.destination.sortScope ?? sourceScope ?? resolveNodeLayout(node, registry).sortScope : void 0;
+	const targetUsesSortScope = typeof targetScope === "string";
+	const targetEntriesBefore = payload.destination.kind === "root" && targetUsesSortScope ? getSortScopeEntries(createLayoutPlan(safeSchema, registry), targetScope) : [];
+	if (payload.destination.kind === "root") requestedIndex = clampInsertIndex(payload.destination.index, targetUsesSortScope ? targetEntriesBefore.length : target.children.length);
+	if (source.destination.kind === "root") {
+		if (sourceScope === false && payload.destination.kind === "root") return {
+			ok: false,
+			code: "NODE_NOT_SORTABLE"
+		};
+		const sourceEntries = sourceScope === false ? [] : getSortScopeEntries(createLayoutPlan(safeSchema, registry), sourceScope);
+		const sourceScopeIndex = sourceEntries.findIndex((entry) => entry.node.id === node.id);
+		const sourceLocks = getLockedIndicesFromEntries(sourceEntries, registry, safeSchema);
+		if (payload.destination.kind === "root" && targetScope === sourceScope) {
+			if (sourceScopeIndex < requestedIndex) requestedIndex -= 1;
+			if (sourceScopeIndex === requestedIndex) return {
+				ok: true,
+				changed: false
+			};
+			if (!isMoveAllowed(sourceScopeIndex, requestedIndex, sourceLocks)) return {
+				ok: false,
+				code: "SORTABLE_LOCK_VIOLATION"
+			};
+		} else if (sourceScope !== false && !isRemoveAllowed(sourceScopeIndex, sourceLocks)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+	}
+	if (payload.destination.kind === "root" && targetUsesSortScope && targetScope !== sourceScope) {
+		const targetLocks = getLockedIndicesFromEntries(targetEntriesBefore, registry, safeSchema);
+		if (!isInsertAllowed(requestedIndex, targetLocks)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+	}
+	const draftSourceResult = resolveNodeSource(rawSchema, buildSchemaIndex(rawSchema), payload.nodeId);
+	if (!draftSourceResult.ok) return draftSourceResult;
+	const draftTargetResult = resolveDestination(rawSchema, registry, payload.destination);
+	if (!draftTargetResult.ok) return draftTargetResult;
+	const draftSource = draftSourceResult.value;
+	const draftTarget = draftTargetResult.value;
+	const sameOwnerArray = draftTarget.children === draftSource.children;
+	const sourceBefore = cloneDeep(draftSource.children);
+	const targetBefore = sameOwnerArray ? null : cloneDeep(draftTarget.children);
+	const [removed] = draftSource.children.splice(draftSource.index, 1);
+	const inserted = payload.destination.kind === "container" ? stripPageLayout(removed) : cloneDeep(removed);
+	const insertedIndex = payload.destination.kind === "root" ? targetUsesSortScope ? getSortableArrayIndexForInsert(getSortScopeEntries(createLayoutPlan(deepFreeze(cloneSchema(rawSchema)), registry), targetScope), draftTarget.children, requestedIndex) : clampInsertIndex(requestedIndex, draftTarget.children.length) : clampInsertIndex(requestedIndex, draftTarget.children.length);
+	draftTarget.children.splice(insertedIndex, 0, inserted);
+	const validation = validateSchema(rawSchema, registry);
+	const movedNodeIds = collectSubtreeIds(inserted);
+	const candidateDiagnostics = validation.diagnostics.filter((diagnostic) => diagnostic.nodeId !== void 0 && movedNodeIds.has(diagnostic.nodeId) || diagnostic.ownerId !== void 0 && movedNodeIds.has(diagnostic.ownerId));
+	if (candidateDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+		draftSource.children.splice(0, draftSource.children.length, ...sourceBefore);
+		if (targetBefore) draftTarget.children.splice(0, draftTarget.children.length, ...targetBefore);
+		return {
+			ok: false,
+			code: "SCHEMA_CANDIDATE_INVALID",
+			details: { diagnostics: candidateDiagnostics }
+		};
+	}
+	return {
+		ok: true,
+		eventPayload: {
+			nodeId: payload.nodeId,
+			source: source.destination,
+			destination: {
+				...payload.destination,
+				index: insertedIndex
+			}
+		}
+	};
+}
+//#endregion
+//#region src/commands/remove-node.ts
+function removeNodeHandler(ctx, payload) {
+	const { store, registry } = ctx;
+	const rawSchema = ctx.schema;
+	if (payload.nodeId === rawSchema.root.id) {
+		console.warn("[dragcraft/core] REMOVE_NODE: cannot remove root node");
+		return false;
+	}
+	const indexed = buildSchemaIndex(rawSchema);
+	const sourceResult = resolveNodeSource(rawSchema, indexed, payload.nodeId);
+	if (!sourceResult.ok) {
+		console.warn(`[dragcraft/core] REMOVE_NODE: node "${payload.nodeId}" not found`);
+		return sourceResult;
+	}
+	const source = sourceResult.value;
+	const node = source.location.node;
+	const meta = registry.getWidget(node.type);
+	if (!resolveBehavior(meta?.deletable, {
+		node,
+		schema: rawSchema
+	})) return {
+		ok: false,
+		code: "NODE_NOT_DELETABLE"
+	};
+	if (node.container && !meta?.container) return {
+		ok: false,
+		code: "UNRESOLVED_CONTAINER_READ_ONLY"
+	};
+	if (source.destination.kind === "container") {
+		const sourceDestination = source.destination;
+		const owner = indexed.index.get(sourceDestination.containerId)?.node;
+		const definition = owner && registry.getWidget(owner.type)?.container;
+		if (!definition) return {
+			ok: false,
+			code: "UNRESOLVED_CONTAINER_READ_ONLY"
+		};
+		const variant = owner?.container && definition.variants[owner.container.variant];
+		const region = variant?.regions.find((item) => item.id === sourceDestination.regionId);
+		if (!variant || !region) return {
+			ok: false,
+			code: "UNRESOLVED_CONTAINER_READ_ONLY"
+		};
+		if (source.children.length - 1 < (region.constraints?.minItems ?? 0)) return {
+			ok: false,
+			code: "CONTAINER_REGION_MIN_ITEMS"
+		};
+		const lockedIndices = getLockedIndicesFromNodes(source.children, registry, rawSchema);
+		if (!isRemoveAllowed(source.index, lockedIndices)) return {
+			ok: false,
+			code: "SORTABLE_LOCK_VIOLATION"
+		};
+	}
+	if (source.destination.kind === "root") {
+		const layout = node ? resolveNodeLayout(node, registry) : null;
+		if (node && layout && layout.sortScope !== false) {
+			const scopeEntries = getSortScopeEntries(createLayoutPlan(rawSchema, registry), layout.sortScope);
+			const removeIndex = scopeEntries.findIndex((entry) => entry.node.id === payload.nodeId);
+			if (removeIndex !== -1) {
+				const lockedIndices = getLockedIndicesFromEntries(scopeEntries, registry, rawSchema);
+				if (lockedIndices.size > 0 && !isRemoveAllowed(removeIndex, lockedIndices)) {
+					console.warn(`[dragcraft/core] REMOVE_NODE: blocked by sortable constraint (removing index ${removeIndex} would shift locked widgets)`);
+					return false;
+				}
+			}
+		}
+	}
+	const removedIds = collectSubtreeIds(node);
+	const draftIndex = buildSchemaIndex(ctx.draft);
+	const draftSource = resolveNodeSource(ctx.draft, draftIndex, payload.nodeId);
+	if (!draftSource.ok) return draftSource;
+	draftSource.value.children.splice(draftSource.value.index, 1);
+	if (store.selectedNodeId.value && removedIds.has(store.selectedNodeId.value)) store.selectNode(null);
+	if (store.hoveredNodeId.value && removedIds.has(store.hoveredNodeId.value)) store.hoverNode(null);
+	return {
+		ok: true,
+		eventPayload: {
+			nodeId: payload.nodeId,
+			source: source.destination
+		}
+	};
+}
+//#endregion
+//#region src/merge-record.ts
+const BLOCKED_RECORD_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function isPlainRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function mergeRecord(target, patch) {
+	let changed = false;
+	for (const [key, value] of Object.entries(patch)) {
+		if (BLOCKED_RECORD_KEYS.has(key)) continue;
+		const current = target[key];
+		if (Object.hasOwn(target, key) && isPlainRecord(current) && isPlainRecord(value)) changed = mergeRecord(current, value) || changed;
+		else if (!Object.hasOwn(target, key) || !Object.is(current, value)) {
+			target[key] = value;
+			changed = true;
+		}
+	}
+	return changed;
+}
+//#endregion
+//#region src/commands/set-global-config.ts
+function setGlobalConfigHandler(ctx, payload) {
+	return {
+		ok: true,
+		changed: mergeRecord(ctx.draft.globalConfig, payload.config)
+	};
+}
+//#endregion
+//#region src/commands/update-props.ts
+function updatePropsHandler(ctx, payload) {
+	const rawSchema = ctx.draft;
+	const node = findNodeById(rawSchema.root, payload.nodeId);
+	if (!node) {
+		console.warn(`[dragcraft/core] UPDATE_PROPS: node "${payload.nodeId}" not found`);
+		return false;
+	}
+	let changed = mergeRecord(node.props, payload.props);
+	if (payload.style) {
+		const style = node.style ?? {};
+		const styleChanged = mergeRecord(style, payload.style);
+		if (!node.style && styleChanged) node.style = style;
+		changed = styleChanged || changed;
+	}
+	return {
+		ok: true,
+		changed
+	};
+}
+//#endregion
+//#region src/container-definition.ts
+const RESERVED_IDS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function isRecord$1(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function validateContainerDefinition(definition) {
+	const errors = [];
+	if (!isRecord$1(definition)) return {
+		valid: false,
+		errors: [{
+			code: "CONTAINER_DEFINITION_INVALID",
+			path: ""
+		}]
+	};
+	const variants = definition.variants;
+	if (!isRecord$1(variants)) return {
+		valid: false,
+		errors: [{
+			code: "CONTAINER_VARIANTS_INVALID",
+			path: "variants"
+		}]
+	};
+	if (typeof definition.defaultVariant !== "string" || !Object.hasOwn(variants, definition.defaultVariant)) errors.push({
+		code: "CONTAINER_DEFAULT_VARIANT_MISSING",
+		path: "defaultVariant"
+	});
+	for (const [variantId, variantValue] of Object.entries(variants)) {
+		const variantPath = `variants.${variantId}`;
+		if (!variantId || RESERVED_IDS.has(variantId)) errors.push({
+			code: "CONTAINER_VARIANT_ID_RESERVED",
+			path: variantPath
+		});
+		if (!isRecord$1(variantValue)) {
+			errors.push({
+				code: "CONTAINER_VARIANT_INVALID",
+				path: variantPath
+			});
+			continue;
+		}
+		if (!Array.isArray(variantValue.regions)) {
+			errors.push({
+				code: "CONTAINER_REGIONS_INVALID",
+				path: `${variantPath}.regions`
+			});
+			continue;
+		}
+		const seen = /* @__PURE__ */ new Set();
+		for (const [index, regionValue] of variantValue.regions.entries()) {
+			const path = `${variantPath}.regions.${index}`;
+			if (!isRecord$1(regionValue)) {
+				errors.push({
+					code: "CONTAINER_REGION_INVALID",
+					path
+				});
+				continue;
+			}
+			const regionId = regionValue.id;
+			if (typeof regionId !== "string" || !regionId || RESERVED_IDS.has(regionId)) errors.push({
+				code: "CONTAINER_REGION_ID_RESERVED",
+				path
+			});
+			if (typeof regionId === "string" && seen.has(regionId)) errors.push({
+				code: "CONTAINER_REGION_ID_DUPLICATE",
+				path
+			});
+			if (typeof regionId === "string") seen.add(regionId);
+			const constraints = regionValue.constraints;
+			if (constraints !== void 0 && !isRecord$1(constraints)) {
+				errors.push({
+					code: "CONTAINER_CONSTRAINTS_INVALID",
+					path: `${path}.constraints`
+				});
+				continue;
+			}
+			const minItems = constraints?.minItems ?? 0;
+			const maxItems = constraints?.maxItems ?? Number.POSITIVE_INFINITY;
+			const maxItemsInvalid = constraints?.maxItems !== void 0 && (!Number.isInteger(maxItems) || maxItems < 0);
+			if (!Number.isInteger(minItems) || minItems < 0 || maxItemsInvalid || minItems > maxItems) errors.push({
+				code: "CONTAINER_CARDINALITY_INVALID",
+				path: `${path}.constraints`
+			});
+			for (const listName of ["includeTypes", "excludeTypes"]) {
+				const typeIds = constraints?.[listName];
+				if (typeIds !== void 0 && (!Array.isArray(typeIds) || typeIds.some((typeId) => typeof typeId !== "string" || typeId.length === 0))) errors.push({
+					code: "CONTAINER_TYPE_ID_INVALID",
+					path: `${path}.constraints.${listName}`
+				});
+			}
+		}
+	}
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region src/container-plan.ts
+function createContainerPlan(node, registry) {
+	const definition = registry.getWidget(node.type)?.container;
+	if (!node.container || !definition) return {
+		ok: false,
+		code: "CONTAINER_UNRESOLVED",
+		containerId: node.id
+	};
+	const variant = definition.variants[node.container.variant];
+	if (!variant) return {
+		ok: false,
+		code: "CONTAINER_VARIANT_UNKNOWN",
+		containerId: node.id
+	};
+	return {
+		ok: true,
+		plan: {
+			containerId: node.id,
+			variant,
+			regions: variant.regions.map((region) => {
+				const nodes = node.container.regions[region.id] ?? [];
+				return {
+					definition: region,
+					nodes,
+					isEmpty: nodes.length === 0
+				};
+			})
+		}
+	};
+}
+//#endregion
+//#region src/event-hub.ts
+var EventHub = class {
+	emitter;
+	constructor() {
+		this.emitter = new EventEmitter();
+	}
+	on(event, listener) {
+		this.emitter.on(event, listener);
+	}
+	off(event, listener) {
+		this.emitter.off(event, listener);
+	}
+	emit(event, ...args) {
+		this.emitter.emit(event, ...args);
+	}
+	once(event, listener) {
+		this.emitter.once(event, listener);
+	}
+	clear() {
+		this.emitter.clear();
+	}
+};
+function createEventHub() {
+	return new EventHub();
+}
+//#endregion
+//#region src/registry.ts
+function isRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function createRegistry() {
+	const widgets = /* @__PURE__ */ new Map();
+	let globalConfigSchema;
+	function registerWidget(meta) {
+		if (!isRecord(meta)) {
+			console.warn("[dragcraft/core] registerWidget: widget metadata must be a plain record");
+			return;
+		}
+		if (!meta.type || typeof meta.type !== "string") {
+			console.warn("[dragcraft/core] registerWidget: widget meta must have a non-empty \"type\" string");
+			return;
+		}
+		if (!meta.title || typeof meta.title !== "string") {
+			console.warn(`[dragcraft/core] registerWidget: widget "${meta.type}" must have a non-empty "title" string`);
+			return;
+		}
+		if (meta.container !== void 0) {
+			const validation = validateContainerDefinition(meta.container);
+			if (!validation.valid) {
+				const codes = validation.errors.map((error) => error.code).join(", ");
+				console.warn(`[dragcraft/core] registerWidget: widget "${meta.type}" has an invalid container definition: ${codes}`);
+				return;
+			}
+		}
+		if (widgets.has(meta.type)) console.warn(`[dragcraft/core] Widget type "${meta.type}" is already registered, overwriting.`);
+		widgets.set(meta.type, meta);
+	}
+	function registerGlobalConfigSchema(schema) {
+		globalConfigSchema = schema;
+	}
+	function registerGlobalConfigFormSchema(schema) {
+		globalConfigSchema = schema;
+	}
+	function getWidget(type) {
+		return widgets.get(type);
+	}
+	function getGlobalConfigSchema() {
+		return globalConfigSchema;
+	}
+	function getAllWidgets() {
+		return Array.from(widgets.values());
+	}
+	return {
+		registerWidget,
+		registerGlobalConfigSchema,
+		registerGlobalConfigFormSchema,
+		getWidget,
+		getGlobalConfigSchema,
+		getAllWidgets
+	};
+}
+//#endregion
+//#region src/schema-store.ts
+function createDefaultSchema() {
+	return {
+		version: DEFAULT_SCHEMA_VERSION,
+		globalConfig: {},
+		root: {
+			id: "root",
+			type: "root",
+			props: {},
+			children: []
+		}
+	};
+}
+function createSchemaStore(initialSchema, onSelectionChange) {
+	const schema = shallowRef(deepFreeze(initialSchema ? cloneSchema(initialSchema) : createDefaultSchema()));
+	const selectedNodeId = ref(null);
+	const hoveredNodeId = ref(null);
+	const dragTarget = ref(null);
+	let schemaIndex = null;
+	function getSchema() {
+		return cloneSchema(schema.value);
+	}
+	function getSnapshot() {
+		return schema.value;
+	}
+	function replaceSnapshot(snapshot) {
+		schemaIndex = null;
+		schema.value = snapshot;
+	}
+	function setSchema(newSchema) {
+		replaceSnapshot(deepFreeze(cloneSchema(newSchema)));
+	}
+	function commitSchema(newSchema) {
+		const snapshot = deepFreeze(newSchema);
+		replaceSnapshot(snapshot);
+		return snapshot;
+	}
+	function restoreSnapshot(snapshot) {
+		replaceSnapshot(snapshot);
+	}
+	function selectNode(id) {
+		selectedNodeId.value = id;
+		onSelectionChange?.(id);
+	}
+	function hoverNode(id) {
+		hoveredNodeId.value = id;
+	}
+	function setDragTarget(target) {
+		dragTarget.value = target ? { ...target } : null;
+	}
+	function getNodeById(id) {
+		if (schema.value.root.id === id) return schema.value.root;
+		schemaIndex ??= buildSchemaIndex(schema.value);
+		return schemaIndex.index.get(id)?.node ?? null;
+	}
+	return {
+		schema,
+		selectedNodeId,
+		hoveredNodeId,
+		dragTarget,
+		getSchema,
+		getSnapshot,
+		setSchema,
+		commitSchema,
+		restoreSnapshot,
+		selectNode,
+		hoverNode,
+		setDragTarget,
+		getNodeById
+	};
+}
+//#endregion
+//#region src/engine.ts
+function createEngine(options) {
+	const maxHistorySize = options?.maxHistorySize ?? 50;
+	const eventHub = createEventHub();
+	const schemaStore = createSchemaStore(void 0, (id) => {
+		eventHub.emit(EventName.SELECTION_CHANGED, id);
+	});
+	const store = {
+		schema: readonly(schemaStore.schema),
+		selectedNodeId: readonly(schemaStore.selectedNodeId),
+		hoveredNodeId: readonly(schemaStore.hoveredNodeId),
+		dragTarget: readonly(schemaStore.dragTarget),
+		selectNode: schemaStore.selectNode,
+		hoverNode: schemaStore.hoverNode,
+		setDragTarget: schemaStore.setDragTarget
+	};
+	const registry = createRegistry();
+	const history = createHistoryManager(schemaStore, eventHub, maxHistorySize);
+	const commandBus = createCommandBus(schemaStore, registry, eventHub, history);
+	const state = {
+		getSchema: schemaStore.getSnapshot,
+		getNodeById: (id) => {
+			return schemaStore.getNodeById(id);
+		},
+		getSelectedNodeId: () => store.selectedNodeId.value,
+		getHoveredNodeId: () => store.hoveredNodeId.value,
+		getDragTarget: () => {
+			const target = schemaStore.dragTarget.value;
+			return target ? { ...target } : null;
+		}
+	};
+	commandBus.registerHandler(CommandType.ADD_NODE, addNodeHandler);
+	commandBus.registerHandler(CommandType.CHANGE_CONTAINER_VARIANT, changeContainerVariantHandler);
+	commandBus.registerHandler(CommandType.DUPLICATE_NODE, duplicateNodeHandler);
+	commandBus.registerHandler(CommandType.MOVE_NODE, moveNodeHandler);
+	commandBus.registerHandler(CommandType.REMOVE_NODE, removeNodeHandler);
+	commandBus.registerHandler(CommandType.UPDATE_PROPS, updatePropsHandler);
+	commandBus.registerHandler(CommandType.SET_GLOBAL_CONFIG, setGlobalConfigHandler);
+	function execute(command) {
+		return commandBus.execute(command);
+	}
+	function registerHandler(type, handler) {
+		commandBus.registerHandler(type, handler);
+	}
+	function registerWidget(meta) {
+		registry.registerWidget(meta);
+	}
+	const migrations = [];
+	function registerMigration(migration) {
+		migrations.push(migration);
+	}
+	function migrateSchema(schema) {
+		let current = schema;
+		const applied = /* @__PURE__ */ new Set();
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const m of migrations) {
+				const key = `${m.fromVersion}->${m.toVersion}`;
+				if (current.version === m.fromVersion && !applied.has(key)) {
+					current = m.migrate(current);
+					applied.add(key);
+					changed = true;
+				}
+			}
+		}
+		return current;
+	}
+	function exportSchema() {
+		return schemaStore.getSchema();
+	}
+	function importSchema(schema) {
+		const structuralDiagnostics = collectSchemaStructuralDiagnostics(schema);
+		if (structuralDiagnostics.length > 0) {
+			console.warn("[dragcraft/core] importSchema: invalid schema, missing root or version");
+			return {
+				ok: false,
+				diagnostics: structuralDiagnostics
+			};
+		}
+		const validation = validateSchema(migrateSchema(cloneSchema(schema)), registry);
+		if (!validation.valid) return {
+			ok: false,
+			diagnostics: validation.diagnostics
+		};
+		schemaStore.setSchema(validation.schema);
+		history.clear();
+		eventHub.emit(EventName.SCHEMA_CHANGED, schemaStore.getSnapshot());
+		return {
+			ok: true,
+			diagnostics: validation.diagnostics
+		};
+	}
+	function dispose() {
+		eventHub.clear();
+		history.clear();
+		schemaStore.selectNode(null);
+		schemaStore.hoverNode(null);
+		schemaStore.setDragTarget(null);
+	}
+	return {
+		store,
+		state,
+		commandBus,
+		history,
+		registry,
+		eventHub,
+		execute,
+		registerHandler,
+		registerWidget,
+		registerMigration,
+		migrateSchema,
+		exportSchema,
+		importSchema,
+		dispose
+	};
+}
+//#endregion
+//#region src/style.ts
+const LENGTH_STYLE_KEYS = /* @__PURE__ */ new Set([
+	"bottom",
+	"height",
+	"left",
+	"margin",
+	"marginBlock",
+	"marginBlockEnd",
+	"marginBlockStart",
+	"marginBottom",
+	"marginInline",
+	"marginInlineEnd",
+	"marginInlineStart",
+	"marginLeft",
+	"marginRight",
+	"marginTop",
+	"maxHeight",
+	"maxWidth",
+	"minHeight",
+	"minWidth",
+	"padding",
+	"paddingBlock",
+	"paddingBlockEnd",
+	"paddingBlockStart",
+	"paddingBottom",
+	"paddingInline",
+	"paddingInlineEnd",
+	"paddingInlineStart",
+	"paddingLeft",
+	"paddingRight",
+	"paddingTop",
+	"right",
+	"top",
+	"width"
+]);
+function normalizeStyleValueMap(style) {
+	if (!style) return void 0;
+	const normalized = {};
+	for (const [key, value] of Object.entries(style)) normalized[key] = typeof value === "number" && value !== 0 && LENGTH_STYLE_KEYS.has(key) ? `${value}px` : value;
+	return normalized;
+}
+//#endregion
+//#region src/types.ts
+function commandFailure(code, reason = {}) {
+	return {
+		ok: false,
+		code,
+		...reason
+	};
+}
+//#endregion
+export { CommandType, DEFAULT_LAYER, DEFAULT_LAYOUT_REGION, DEFAULT_MAX_HISTORY_SIZE, DEFAULT_SCHEMA_VERSION, DEFAULT_SORT_SCOPE, EventHub, EventName, addNodeHandler, buildSchemaIndex, changeContainerVariantHandler, clampInsertIndex, cloneNodeSubtree, collectSubtreeIds, commandFailure, createCommandBus, createContainerPlan, createContainerState, createDefaultSchema, createEngine, createEventHub, createHistoryManager, createLayoutPlan, createRegisteredNode, createRegistry, duplicateNodeHandler, findIndexedNode, findNearestValidIndex, findNodeById, findParentNode, getLayoutRegionEntries, getLockedIndices, getLockedIndicesFromNodes, getSortScopeEntries, getSortScopeNodes, getSortableArrayIndexForInsert, getValidDropIndices, insertNodeIntoTree, isInsertAllowed, isMoveAllowed, isRemoveAllowed, moveNodeHandler, normalizeStyleValueMap, removeNodeFromTree, removeNodeHandler, resolveBehavior, resolveCreatable, resolveDestination, resolveNodeLayout, resolveNodeSource, resolvePlacementDecision, setGlobalConfigHandler, stripPageLayout, updatePropsHandler, validateContainerDefinition, validateSchema, walkFlatChildren };