@bluprynt/forms-core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2321 @@
+import Ajv2020 from "ajv/dist/2020";
+//#region src/date-utils.ts
+const RELATIVE_DATE_RE = /^([+-])(\d+)([dwmy])$/;
+/**
+* Type guard that checks whether a value is a relative date expression.
+*
+* Relative date expressions follow the pattern `[+-]<amount><unit>` where
+* `unit` is one of `d` (days), `w` (weeks), `m` (months), or `y` (years).
+*
+* @param value - The value to test.
+* @returns `true` if `value` is a string matching the relative date pattern.
+*
+* @example
+* ```ts
+* isRelativeDate("+7d")   // true  (7 days from now)
+* isRelativeDate("-1m")   // true  (1 month ago)
+* isRelativeDate("2024-01-01") // false (absolute date)
+* isRelativeDate(42)      // false (not a string)
+* ```
+*/
+const isRelativeDate = (value) => typeof value === "string" && RELATIVE_DATE_RE.test(value);
+/**
+* Resolves a relative date expression into an absolute ISO-8601 date string.
+*
+* Supported units:
+* - `d` -- days
+* - `w` -- weeks (7 days)
+* - `m` -- months
+* - `y` -- years
+*
+* Arithmetic is performed in UTC. If the input does not match the relative
+* date pattern, it is returned unchanged.
+*
+* @param relative - A relative date expression (e.g. `"+7d"`, `"-3m"`).
+* @param now - Reference date for the calculation. Defaults to `new Date()`.
+* @returns An ISO-8601 date-time string, or the original string if it is not
+*   a valid relative expression.
+*
+* @example
+* ```ts
+* const base = new Date("2024-06-15T00:00:00Z");
+* resolveRelativeDate("+7d", base)  // "2024-06-22T00:00:00.000Z"
+* resolveRelativeDate("-1m", base)  // "2024-05-15T00:00:00.000Z"
+* resolveRelativeDate("+1y", base)  // "2025-06-15T00:00:00.000Z"
+* ```
+*/
+const resolveRelativeDate = (relative, now) => {
+	const match = RELATIVE_DATE_RE.exec(relative);
+	if (!match) return relative;
+	const sign = match[1] === "+" ? 1 : -1;
+	const amount = Number(match[2]) * sign;
+	const unit = match[3];
+	const result = new Date(now.getTime());
+	switch (unit) {
+		case "d":
+			result.setUTCDate(result.getUTCDate() + amount);
+			break;
+		case "w":
+			result.setUTCDate(result.getUTCDate() + amount * 7);
+			break;
+		case "m":
+			result.setUTCMonth(result.getUTCMonth() + amount);
+			break;
+		case "y":
+			result.setUTCFullYear(result.getUTCFullYear() + amount);
+			break;
+	}
+	return result.toISOString();
+};
+//#endregion
+//#region src/condition-evaluator.ts
+/**
+* Evaluates condition trees against form state.
+*
+* Supports three kinds of conditions:
+* - **Simple** ({@link SimpleCondition}): compares a single field's value
+*   using one of the supported operators (`set`, `notset`, `eq`, `ne`, `lt`,
+*   `gt`, `lte`, `gte`, `in`, `notin`).
+* - **Compound AND**: `{ and: [...] }` -- all child conditions must be true.
+* - **Compound OR**: `{ or: [...] }` -- at least one child condition must be true.
+*
+* **Hidden-field rule**: when a `visibilityMap` is provided and the
+* referenced field is hidden (`false`), the condition evaluates as if the
+* field has no value. This means `notset` returns `true` and all other
+* operators return `false`.
+*
+* **Date handling**: condition values that are relative date expressions
+* (e.g. `"+7d"`) are resolved against `ctx.now` before comparison.
+*/
+var ConditionEvaluator = class {
+	/**
+	* Evaluates a condition tree against the current form state.
+	*
+	* @param condition - The condition to evaluate (simple or compound).
+	* @param ctx - Evaluation context containing form values and optional
+	*   visibility/date overrides.
+	* @returns `true` if the condition is satisfied, `false` otherwise.
+	*/
+	evalCondition(condition, ctx) {
+		if ("and" in condition) return condition.and.every((c) => this.evalCondition(c, ctx));
+		if ("or" in condition) return condition.or.some((c) => this.evalCondition(c, ctx));
+		return this.evalSimple(condition, ctx);
+	}
+	evalSimple(cond, ctx) {
+		if (ctx.visibilityMap && ctx.visibilityMap.get(cond.field) === false) return cond.op === "notset";
+		const fieldValue = ctx.values[String(cond.field)];
+		switch (cond.op) {
+			case "set": return fieldValue !== null && fieldValue !== void 0 && fieldValue !== "";
+			case "notset": return fieldValue === null || fieldValue === void 0 || fieldValue === "";
+			case "eq": return fieldValue === this.resolveIfDate(cond.value, ctx.now);
+			case "ne": return fieldValue !== this.resolveIfDate(cond.value, ctx.now);
+			case "lt": return this.compareTo(fieldValue, cond.value, ctx.now) < 0;
+			case "gt": return this.compareTo(fieldValue, cond.value, ctx.now) > 0;
+			case "lte": return this.compareTo(fieldValue, cond.value, ctx.now) <= 0;
+			case "gte": return this.compareTo(fieldValue, cond.value, ctx.now) >= 0;
+			case "in": return Array.isArray(cond.value) && cond.value.includes(fieldValue);
+			case "notin": return Array.isArray(cond.value) && !cond.value.includes(fieldValue);
+			default: return false;
+		}
+	}
+	resolveIfDate(value, now) {
+		if (isRelativeDate(value)) return resolveRelativeDate(value, now);
+		return value;
+	}
+	compareTo(a, b, now) {
+		const resolvedB = this.resolveIfDate(b, now);
+		if (typeof a === "number" && typeof resolvedB === "number") return a - resolvedB;
+		if (typeof a === "string" && typeof resolvedB === "string") {
+			const ta = Date.parse(a);
+			const tb = Date.parse(resolvedB);
+			if (!Number.isNaN(ta) && !Number.isNaN(tb)) return ta - tb;
+			if (a < resolvedB) return -1;
+			if (a > resolvedB) return 1;
+			return 0;
+		}
+		return NaN;
+	}
+};
+//#endregion
+//#region src/dependency-graph.ts
+const DfsVisitState = {
+	Unvisited: 0,
+	InProgress: 1,
+	Completed: 2
+};
+/**
+* Manages the condition dependency graph for form fields.
+*
+* Built from the field registry during engine preparation. Provides:
+* - Forward dependency graph (`graph`): answers "if field X changes, which
+*   items need to re-evaluate their visibility?"
+* - Topological ordering (`topologicalOrder`): guarantees that when computing
+*   visibility, every item is evaluated after the fields it depends on.
+* - Affected-ids lookup (`getAffectedIds`): returns all transitively
+*   affected item ids when a field value changes (lazily cached).
+*
+* Static methods (`extractFieldRefs`, `detectCycle`) can be used before
+* constructing an instance, e.g. during semantic validation.
+*/
+var DependencyGraph = class DependencyGraph {
+	/**
+	* Forward adjacencyMap map: key is a field id, value is the set of item ids
+	* whose conditions reference that field.
+	*/
+	graph;
+	/**
+	* Item ids in topological order. Dependencies come before dependents.
+	*/
+	topologicalOrder;
+	registry;
+	affectedCache = /* @__PURE__ */ new Map();
+	/**
+	* @param registry - The engine's field registry (built during preparation).
+	*/
+	constructor(registry) {
+		this.registry = registry;
+		this.graph = this.buildGraph();
+		this.topologicalOrder = this.buildTopologicalOrder();
+	}
+	/**
+	* Extracts the set of field ids referenced by a condition tree.
+	*
+	* Recursively walks compound conditions (`and`/`or`) and collects the
+	* `field` property from every leaf {@link SimpleCondition}.
+	*
+	* @param condition - A simple or compound condition.
+	* @returns Set of all unique field ids that appear in the condition.
+	*/
+	static extractFieldRefs(condition) {
+		const refs = /* @__PURE__ */ new Set();
+		DependencyGraph.collectRefs(condition, refs);
+		return refs;
+	}
+	/**
+	* Detects circular dependencies in the condition graph.
+	*
+	* Uses DFS-based cycle detection (white/gray/black coloring). If a cycle
+	* is found, the function reconstructs and returns a human-readable path
+	* string (e.g. `"1 -> 2 -> 3 -> 1"`).
+	*
+	* @param registry - The engine's field registry.
+	* @returns An array of field ids forming the cycle, or `undefined` if no cycle exists.
+	*/
+	static detectCycle(registry) {
+		const allIds = new Set(registry.keys());
+		const adjacencyMap = /* @__PURE__ */ new Map();
+		for (const [id, entry] of registry) {
+			if (!entry.condition) continue;
+			const refs = DependencyGraph.extractFieldRefs(entry.condition);
+			for (const ref of refs) {
+				if (!allIds.has(ref)) continue;
+				let targets = adjacencyMap.get(ref);
+				if (!targets) {
+					targets = /* @__PURE__ */ new Set();
+					adjacencyMap.set(ref, targets);
+				}
+				targets.add(id);
+			}
+		}
+		const nodes = /* @__PURE__ */ new Map();
+		const parent = /* @__PURE__ */ new Map();
+		for (const id of allIds) nodes.set(id, DfsVisitState.Unvisited);
+		for (const id of allIds) if (nodes.get(id) === DfsVisitState.Unvisited) {
+			const cyclePath = DependencyGraph.dfs(id, adjacencyMap, nodes, parent, allIds);
+			if (cyclePath) return cyclePath;
+		}
+	}
+	/**
+	* Returns the set of item ids whose visibility could change when the given
+	* field's value changes.
+	*
+	* Performs a transitive expansion of the forward dependency graph starting
+	* from the field's direct dependents. Results are memoized for subsequent
+	* calls with the same `fieldId`.
+	*
+	* @param fieldId - Id of the field whose value changed.
+	* @returns Set of all transitively affected item ids. Empty set if no items
+	*   depend on `fieldId`.
+	*/
+	getAffectedIds(fieldId) {
+		const cached = this.affectedCache.get(fieldId);
+		if (cached) return cached;
+		const directDeps = this.graph.get(fieldId);
+		if (!directDeps || directDeps.size === 0) {
+			const empty = /* @__PURE__ */ new Set();
+			this.affectedCache.set(fieldId, empty);
+			return empty;
+		}
+		const expanded = this.expandTransitiveDependencies(directDeps);
+		this.affectedCache.set(fieldId, expanded);
+		return expanded;
+	}
+	static collectRefs(condition, refs) {
+		if ("and" in condition) for (const c of condition.and) DependencyGraph.collectRefs(c, refs);
+		else if ("or" in condition) for (const c of condition.or) DependencyGraph.collectRefs(c, refs);
+		else refs.add(condition.field);
+	}
+	static dfs(node, adjacencyMap, nodes, parent, allIds) {
+		nodes.set(node, DfsVisitState.InProgress);
+		const neighbors = adjacencyMap.get(node);
+		if (neighbors) for (const next of neighbors) {
+			if (!allIds.has(next)) continue;
+			if (nodes.get(next) === DfsVisitState.InProgress) return DependencyGraph.reconstructCycle(next, node, parent);
+			if (nodes.get(next) === DfsVisitState.Completed) continue;
+			parent.set(next, node);
+			const cycle = DependencyGraph.dfs(next, adjacencyMap, nodes, parent, allIds);
+			if (cycle) return cycle;
+		}
+		nodes.set(node, DfsVisitState.Completed);
+	}
+	static reconstructCycle(cycleStart, cycleEnd, parent) {
+		const path = [cycleStart];
+		let current = cycleEnd;
+		while (current !== cycleStart) {
+			path.push(current);
+			const next = parent.get(current);
+			if (next === void 0) break;
+			current = next;
+		}
+		path.push(cycleStart);
+		return path.reverse();
+	}
+	/**
+	* Builds the forward dependency graph from the registry.
+	*/
+	buildGraph() {
+		const graph = /* @__PURE__ */ new Map();
+		for (const [id, entry] of this.registry) {
+			if (!entry.condition) continue;
+			const refs = DependencyGraph.extractFieldRefs(entry.condition);
+			for (const ref of refs) {
+				let deps = graph.get(ref);
+				if (!deps) {
+					deps = /* @__PURE__ */ new Set();
+					graph.set(ref, deps);
+				}
+				deps.add(id);
+			}
+		}
+		return graph;
+	}
+	/**
+	* Produces a topological ordering using Kahn's algorithm.
+	*/
+	buildTopologicalOrder() {
+		const allIds = new Set(this.registry.keys());
+		const inDegree = /* @__PURE__ */ new Map();
+		const adjacencyMap = /* @__PURE__ */ new Map();
+		for (const id of allIds) inDegree.set(id, 0);
+		for (const [id, entry] of this.registry) {
+			if (!entry.condition) continue;
+			const refs = DependencyGraph.extractFieldRefs(entry.condition);
+			for (const ref of refs) {
+				if (!allIds.has(ref)) continue;
+				let targets = adjacencyMap.get(ref);
+				if (!targets) {
+					targets = /* @__PURE__ */ new Set();
+					adjacencyMap.set(ref, targets);
+				}
+				if (!targets.has(id)) {
+					targets.add(id);
+					inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+				}
+			}
+		}
+		for (const [id, entry] of this.registry) {
+			if (entry.parentId === void 0) continue;
+			if (!allIds.has(entry.parentId)) continue;
+			let targets = adjacencyMap.get(entry.parentId);
+			if (!targets) {
+				targets = /* @__PURE__ */ new Set();
+				adjacencyMap.set(entry.parentId, targets);
+			}
+			if (!targets.has(id)) {
+				targets.add(id);
+				inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+			}
+		}
+		const queue = [];
+		for (const [id, deg] of inDegree) if (deg === 0) queue.push(id);
+		const sorted = [];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current === void 0) break;
+			sorted.push(current);
+			const targets = adjacencyMap.get(current);
+			if (targets) for (const target of targets) {
+				const newDeg = (inDegree.get(target) ?? 1) - 1;
+				inDegree.set(target, newDeg);
+				if (newDeg === 0) queue.push(target);
+			}
+		}
+		if (sorted.length !== allIds.size) {
+			const cyclePath = [...allIds].filter((id) => !sorted.includes(id)).join(" -> ");
+			return sorted.length === 0 ? [] : (() => {
+				throw cyclePath;
+			})();
+		}
+		return sorted;
+	}
+	/**
+	* Expands a set of item ids to include all transitive dependents via BFS.
+	*/
+	expandTransitiveDependencies(startIds) {
+		const result = /* @__PURE__ */ new Set();
+		const queue = [...startIds];
+		while (queue.length > 0) {
+			const id = queue.shift();
+			if (id === void 0) break;
+			if (result.has(id)) continue;
+			result.add(id);
+			const deps = this.graph.get(id);
+			if (deps) {
+				for (const dep of deps) if (!result.has(dep)) queue.push(dep);
+			}
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/validators/array-validator.ts
+var ArrayValidator = class {
+	validate(ctx) {
+		const { fieldId, value, now } = ctx;
+		const { item, validateField } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		if (value === null || value === void 0) return errors;
+		if (!Array.isArray(value)) {
+			errors.push({
+				fieldId,
+				rule: "TYPE",
+				message: "Must be an array",
+				params: { expectedType: "array" }
+			});
+			return errors;
+		}
+		if (validation?.minItems !== void 0 && value.length < validation.minItems) errors.push({
+			fieldId,
+			rule: "MIN_ITEMS",
+			message: `Must have at least ${validation.minItems} items`,
+			params: {
+				minItems: validation.minItems,
+				actual: value.length
+			}
+		});
+		if (validation?.maxItems !== void 0 && value.length > validation.maxItems) errors.push({
+			fieldId,
+			rule: "MAX_ITEMS",
+			message: `Must have at most ${validation.maxItems} items`,
+			params: {
+				maxItems: validation.maxItems,
+				actual: value.length
+			}
+		});
+		if (item) for (let i = 0; i < value.length; i++) {
+			const fakeEntry = {
+				id: fieldId,
+				type: item.type,
+				condition: void 0,
+				validation: item.validation,
+				parentId: void 0,
+				options: item.options,
+				item: void 0,
+				label: item.label,
+				title: void 0
+			};
+			const itemErrors = validateField(fieldId, value[i], fakeEntry, now);
+			errors.push(...itemErrors.map((err) => ({
+				...err,
+				itemIndex: i
+			})));
+		}
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/boolean-validator.ts
+var BooleanValidator = class {
+	validate(ctx) {
+		const { fieldId, value } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		if (validation?.required && value !== true && value !== false) errors.push({
+			fieldId,
+			rule: "REQUIRED",
+			message: "Value is required"
+		});
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/date-validator.ts
+var DateValidator = class {
+	validate(ctx) {
+		const { fieldId, value, now } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		const isEmpty = value === null || value === void 0 || value === "";
+		if (validation?.required && isEmpty) {
+			errors.push({
+				fieldId,
+				rule: "REQUIRED",
+				message: "Value is required"
+			});
+			return errors;
+		}
+		if (isEmpty) return errors;
+		if (typeof value !== "string") {
+			errors.push({
+				fieldId,
+				rule: "TYPE",
+				message: "Must be a valid date",
+				params: { expectedType: "date" }
+			});
+			return errors;
+		}
+		const timestamp = Date.parse(value);
+		if (Number.isNaN(timestamp)) {
+			errors.push({
+				fieldId,
+				rule: "INVALID_DATE",
+				message: "Must be a valid date"
+			});
+			return errors;
+		}
+		if (validation?.minDate !== void 0) {
+			const minResolved = isRelativeDate(validation.minDate) ? resolveRelativeDate(validation.minDate, now) : validation.minDate;
+			if (timestamp < Date.parse(minResolved)) errors.push({
+				fieldId,
+				rule: "MIN_DATE",
+				message: `Must be on or after ${minResolved}`,
+				params: { minDate: minResolved }
+			});
+		}
+		if (validation?.maxDate !== void 0) {
+			const maxResolved = isRelativeDate(validation.maxDate) ? resolveRelativeDate(validation.maxDate, now) : validation.maxDate;
+			if (timestamp > Date.parse(maxResolved)) errors.push({
+				fieldId,
+				rule: "MAX_DATE",
+				message: `Must be on or before ${maxResolved}`,
+				params: { maxDate: maxResolved }
+			});
+		}
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/file-validator.ts
+var FileValidator = class {
+	validate(ctx) {
+		const { fieldId, value } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		const isEmpty = value === null || value === void 0;
+		if (validation?.required && isEmpty) {
+			errors.push({
+				fieldId,
+				rule: "REQUIRED",
+				message: "Value is required"
+			});
+			return errors;
+		}
+		if (isEmpty) return errors;
+		if (typeof value !== "object" || typeof value.name !== "string" || typeof value.mimeType !== "string" || typeof value.size !== "number" || typeof value.url !== "string") errors.push({
+			fieldId,
+			rule: "TYPE",
+			message: "Must be a valid file object",
+			params: { expectedType: "file" }
+		});
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/number-validator.ts
+var NumberValidator = class {
+	validate(ctx) {
+		const { fieldId, value } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		const isEmpty = value === null || value === void 0;
+		if (validation?.required && isEmpty) {
+			errors.push({
+				fieldId,
+				rule: "REQUIRED",
+				message: "Value is required"
+			});
+			return errors;
+		}
+		if (isEmpty) return errors;
+		if (typeof value !== "number") {
+			errors.push({
+				fieldId,
+				rule: "TYPE",
+				message: "Must be a number",
+				params: { expectedType: "number" }
+			});
+			return errors;
+		}
+		if (validation?.min !== void 0 && value < validation.min) errors.push({
+			fieldId,
+			rule: "MIN",
+			message: `Must be at least ${validation.min}`,
+			params: {
+				min: validation.min,
+				actual: value
+			}
+		});
+		if (validation?.max !== void 0 && value > validation.max) errors.push({
+			fieldId,
+			rule: "MAX",
+			message: `Must be at most ${validation.max}`,
+			params: {
+				max: validation.max,
+				actual: value
+			}
+		});
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/select-validator.ts
+var SelectValidator = class {
+	validate(ctx) {
+		const { fieldId, value } = ctx;
+		const validation = ctx.validation;
+		const options = ctx.options;
+		const errors = [];
+		const isEmpty = value === null || value === void 0;
+		if (validation?.required && isEmpty) {
+			errors.push({
+				fieldId,
+				rule: "REQUIRED",
+				message: "Value is required"
+			});
+			return errors;
+		}
+		if (isEmpty) return errors;
+		if (options && !options.some((opt) => opt.value === value)) errors.push({
+			fieldId,
+			rule: "INVALID_OPTION",
+			message: "Value is not a valid option"
+		});
+		return errors;
+	}
+};
+//#endregion
+//#region src/validators/string-validator.ts
+var StringValidator = class {
+	validate(ctx) {
+		const { fieldId, value } = ctx;
+		const validation = ctx.validation;
+		const errors = [];
+		const isEmpty = value === null || value === void 0 || value === "";
+		if (validation?.required && isEmpty) {
+			errors.push({
+				fieldId,
+				rule: "REQUIRED",
+				message: "Value is required"
+			});
+			return errors;
+		}
+		if (isEmpty) return errors;
+		if (typeof value !== "string") {
+			errors.push({
+				fieldId,
+				rule: "TYPE",
+				message: "Must be a string",
+				params: { expectedType: "string" }
+			});
+			return errors;
+		}
+		if (validation?.minLength !== void 0 && value.length < validation.minLength) errors.push({
+			fieldId,
+			rule: "MIN_LENGTH",
+			message: `Must be at least ${validation.minLength} characters`,
+			params: {
+				minLength: validation.minLength,
+				actual: value.length
+			}
+		});
+		if (validation?.maxLength !== void 0 && value.length > validation.maxLength) errors.push({
+			fieldId,
+			rule: "MAX_LENGTH",
+			message: `Must be at most ${validation.maxLength} characters`,
+			params: {
+				maxLength: validation.maxLength,
+				actual: value.length
+			}
+		});
+		if (validation?.pattern !== void 0) {
+			if (!new RegExp(validation.pattern).test(value)) errors.push({
+				fieldId,
+				rule: "PATTERN",
+				message: validation.patternMessage ?? "Value does not match the required pattern"
+			});
+		}
+		return errors;
+	}
+};
+//#endregion
+//#region src/field-validator.ts
+/**
+* Validates form values against the schema's validation rules.
+*
+* **Which fields are validated:**
+* - Only fields (not sections) are validated.
+* - Hidden fields (those with `visibilityMap.get(id) === false`) are skipped
+*   entirely -- they produce no errors regardless of their value.
+*
+* **How each field type is validated:**
+* - `string` -- `required`, `minLength`, `maxLength`, `pattern`.
+* - `number` -- `required`, `min`, `max`.
+* - `boolean` -- `required` (must be explicitly `true` or `false`).
+* - `date` -- `required`, `minDate`, `maxDate`. Relative date boundaries
+*   are resolved against `now`.
+* - `select` -- `required`, plus the value must be one of the defined options.
+* - `array` -- `minItems`, `maxItems`, plus each item is validated
+*   individually according to the array's {@link ArrayItemDef}. Item-level
+*   errors carry an `itemIndex`.
+*
+* For all types, if `required` fails, no further rules are checked for that
+* field (early return). If the value is empty/absent and `required` is not
+* set, no errors are produced.
+*/
+var FieldValidator = class {
+	registry;
+	validators;
+	/**
+	* @param registry - The engine's field registry.
+	*/
+	constructor(registry) {
+		this.registry = registry;
+		this.validators = {
+			string: new StringValidator(),
+			number: new NumberValidator(),
+			boolean: new BooleanValidator(),
+			date: new DateValidator(),
+			select: new SelectValidator(),
+			array: new ArrayValidator(),
+			file: new FileValidator()
+		};
+	}
+	/**
+	* Validates form values against the schema's validation rules.
+	*
+	* @param values - The form values to validate, keyed by stringified field id.
+	* @param visibilityMap - Pre-computed visibility map for all items.
+	* @param now - Reference date for resolving relative date expressions.
+	*   Defaults to `new Date()`.
+	* @returns A {@link FormValidationResult} with `valid: true` when no errors
+	*   exist, or `valid: false` with a populated `fieldErrors` map.
+	*/
+	validate(values, visibilityMap, now = /* @__PURE__ */ new Date()) {
+		const fieldErrors = /* @__PURE__ */ new Map();
+		for (const [id, entry] of this.registry) {
+			if (entry.type === "section") continue;
+			if (visibilityMap.get(id) === false) continue;
+			const value = values[String(id)];
+			const errors = this.validateField(id, value, entry, now);
+			if (errors.length > 0) fieldErrors.set(id, errors);
+		}
+		return {
+			valid: fieldErrors.size === 0,
+			fieldErrors
+		};
+	}
+	validateField(fieldId, value, entry, now) {
+		const validator = this.validators[entry.type];
+		if (!validator) return [];
+		if (entry.type === "array") {
+			const ctx = {
+				fieldId,
+				value,
+				validation: entry.validation,
+				now,
+				item: entry.item,
+				validateField: this.validateField.bind(this)
+			};
+			return validator.validate(ctx);
+		}
+		return validator.validate({
+			fieldId,
+			value,
+			validation: entry.validation,
+			now,
+			options: entry.options
+		});
+	}
+};
+//#endregion
+//#region src/form-definition-editor.ts
+/**
+* Mutable editor for building and modifying a {@link FormDefinition}.
+*
+* Operates directly on the definition tree. All mutating methods return
+* `this` for fluent chaining.
+*
+* @example
+* ```ts
+* const editor = new FormDefinitionEditor({
+*   id: 'my-form', version: '1.0.0', title: 'My Form', content: [],
+* })
+* editor
+*   .addField({ type: 'string', label: 'Name', validation: { required: true } })
+*   .addSection({ type: 'section', title: 'Details' })
+*   .addField({ type: 'number', label: 'Age' }, 2) // into section id=2
+*
+* const definition = editor.toJSON()
+* ```
+*/
+var FormDefinitionEditor = class {
+	definition;
+	constructor(definition) {
+		this.definition = JSON.parse(JSON.stringify(definition));
+	}
+	setTitle(title) {
+		this.definition.title = title;
+		return this;
+	}
+	setDescription(description) {
+		if (description === void 0) delete this.definition.description;
+		else this.definition.description = description;
+		return this;
+	}
+	setVersion(version) {
+		this.definition.version = version;
+		return this;
+	}
+	setId(id) {
+		this.definition.id = id;
+		return this;
+	}
+	/**
+	* Returns the next available numeric id (max existing + 1).
+	*/
+	nextId() {
+		let max = 0;
+		this.walkAll(this.definition.content, (item) => {
+			if (item.id > max) max = item.id;
+		});
+		return max + 1;
+	}
+	/**
+	* Adds a field to the form.
+	*
+	* @param descriptor - Field properties. `id` is auto-assigned if omitted.
+	* @param parentId - Section id to add into. `undefined` for top-level.
+	* @param index - Position within the parent's content array. Appends if omitted.
+	* @returns `this` for chaining.
+	* @throws If `parentId` references a non-existent or non-section item, or if the id already exists.
+	*/
+	addField(descriptor, parentId, index) {
+		const id = descriptor.id ?? this.nextId();
+		this.assertIdAvailable(id);
+		const field = {
+			...descriptor,
+			id
+		};
+		this.insertItem(field, parentId, index);
+		return this;
+	}
+	/**
+	* Adds a section to the form.
+	*
+	* @param descriptor - Section properties. `id` is auto-assigned if omitted.
+	* @param parentId - Parent section id. `undefined` for top-level.
+	* @param index - Position within the parent's content array. Appends if omitted.
+	* @returns `this` for chaining.
+	* @throws If `parentId` references a non-existent or non-section item, or if the id already exists.
+	*/
+	addSection(descriptor, parentId, index) {
+		const id = descriptor.id ?? this.nextId();
+		this.assertIdAvailable(id);
+		const section = {
+			...descriptor,
+			id,
+			content: descriptor.content ?? []
+		};
+		this.insertItem(section, parentId, index);
+		return this;
+	}
+	/**
+	* Updates properties of an existing field.
+	*
+	* Cannot change `id` or `type`. Use {@link removeItem} + {@link addField}
+	* to change the type.
+	*/
+	updateField(id, updates) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type === "section") throw new Error(`Item ${id} is a section, not a field`);
+		Object.assign(item, updates);
+		return this;
+	}
+	/**
+	* Updates properties of an existing section.
+	*
+	* Cannot change `id`, `type`, or `content` directly. Use add/remove methods
+	* for content manipulation.
+	*/
+	updateSection(id, updates) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type !== "section") throw new Error(`Item ${id} is not a section`);
+		Object.assign(item, updates);
+		return this;
+	}
+	/**
+	* Removes a field or section (and all its descendants) by id.
+	*
+	* @returns `this` for chaining.
+	* @throws If the id is not found.
+	*/
+	removeItem(id) {
+		if (!this.removeFromContent(this.definition.content, id)) throw new Error(`Item with id ${id} not found`);
+		return this;
+	}
+	/**
+	* Moves an item to a new parent and/or position.
+	*
+	* @param id - Id of the item to move.
+	* @param targetParentId - Destination section id, or `undefined` for top-level.
+	* @param index - Position in the target content array. Appends if omitted.
+	*/
+	moveItem(id, targetParentId, index) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (targetParentId !== void 0 && item.type === "section") {
+			if (targetParentId === id) throw new Error("Cannot move a section into itself");
+			if (this.collectDescendantIds(item).has(targetParentId)) throw new Error("Cannot move a section into its own descendant");
+		}
+		const clone = JSON.parse(JSON.stringify(item));
+		this.removeFromContent(this.definition.content, id);
+		this.insertItem(clone, targetParentId, index);
+		return this;
+	}
+	/**
+	* Returns a flat list of all content items (fields + sections) with parent info.
+	*/
+	listAll() {
+		const result = [];
+		this.walkAllWithParent(this.definition.content, void 0, (item, parentId) => {
+			result.push({
+				id: item.id,
+				type: item.type,
+				label: item.type !== "section" ? item.label : void 0,
+				title: item.type === "section" ? item.title : void 0,
+				parentId
+			});
+		});
+		return result;
+	}
+	/**
+	* Returns a flat list of all fields (excludes sections).
+	*/
+	listFields() {
+		return this.listAll().filter((i) => i.type !== "section");
+	}
+	/**
+	* Returns a flat list of all sections.
+	*/
+	listSections() {
+		return this.listAll().filter((i) => i.type === "section");
+	}
+	/**
+	* Returns the content item with the given id, or `undefined` if not found.
+	*/
+	getItem(id) {
+		return this.findItem(id) ?? void 0;
+	}
+	/**
+	* Sets or clears the validation rules for a field.
+	*/
+	setValidation(id, validation) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type === "section") throw new Error("Sections do not have validation");
+		const field = item;
+		if (validation === void 0) delete field.validation;
+		else field.validation = validation;
+		return this;
+	}
+	/**
+	* Sets or clears the visibility condition for a field or section.
+	*/
+	setCondition(id, condition) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (condition === void 0) delete item.condition;
+		else item.condition = condition;
+		return this;
+	}
+	/**
+	* Sets the select options for a `select` field.
+	*/
+	setOptions(id, options) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type !== "select") throw new Error(`Field ${id} is not a select field`);
+		const field = item;
+		field.options = options;
+		return this;
+	}
+	/**
+	* Sets the item definition for an `array` field.
+	*/
+	setArrayItem(id, itemDef) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type !== "array") throw new Error(`Field ${id} is not an array field`);
+		const field = item;
+		field.item = itemDef;
+		return this;
+	}
+	/**
+	* Sets the label for a field.
+	*/
+	setLabel(id, label) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (item.type === "section") throw new Error("Sections use title, not label");
+		const field = item;
+		field.label = label;
+		return this;
+	}
+	/**
+	* Sets the description for a field or section.
+	*/
+	setFieldDescription(id, description) {
+		const item = this.findItem(id);
+		if (!item) throw new Error(`Item with id ${id} not found`);
+		if (description === void 0) delete item.description;
+		else item.description = description;
+		return this;
+	}
+	/**
+	* Returns a deep clone of the current form definition.
+	*/
+	toJSON() {
+		return JSON.parse(JSON.stringify(this.definition));
+	}
+	findItem(id) {
+		let found;
+		this.walkAll(this.definition.content, (item) => {
+			if (item.id === id) found = item;
+		});
+		return found;
+	}
+	assertIdAvailable(id) {
+		if (this.findItem(id)) throw new Error(`Item with id ${id} already exists`);
+	}
+	insertItem(item, parentId, index) {
+		const target = this.getTargetContent(parentId);
+		if (index !== void 0 && index >= 0 && index < target.length) target.splice(index, 0, item);
+		else target.push(item);
+	}
+	getTargetContent(parentId) {
+		if (parentId === void 0) return this.definition.content;
+		const parent = this.findItem(parentId);
+		if (!parent) throw new Error(`Parent section with id ${parentId} not found`);
+		if (parent.type !== "section") throw new Error(`Item ${parentId} is not a section`);
+		return parent.content;
+	}
+	removeFromContent(content, id) {
+		const idx = content.findIndex((item) => item.id === id);
+		if (idx !== -1) {
+			content.splice(idx, 1);
+			return true;
+		}
+		for (const item of content) if (item.type === "section") {
+			if (this.removeFromContent(item.content, id)) return true;
+		}
+		return false;
+	}
+	walkAll(content, fn) {
+		for (const item of content) {
+			fn(item);
+			if (item.type === "section") this.walkAll(item.content, fn);
+		}
+	}
+	walkAllWithParent(content, parentId, fn) {
+		for (const item of content) {
+			fn(item, parentId);
+			if (item.type === "section") this.walkAllWithParent(item.content, item.id, fn);
+		}
+	}
+	collectDescendantIds(section) {
+		const ids = /* @__PURE__ */ new Set();
+		this.walkAll(section.content, (item) => ids.add(item.id));
+		return ids;
+	}
+};
+//#endregion
+//#region src/form-definition-validator.ts
+const validateFn = new Ajv2020({ allErrors: true }).compile({
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	title: "Bluprynt Form Definition",
+	type: "object",
+	required: [
+		"id",
+		"version",
+		"title",
+		"content"
+	],
+	additionalProperties: false,
+	properties: {
+		"id": { "type": "string" },
+		"version": {
+			"type": "string",
+			"pattern": "^\\d+\\.\\d+\\.\\d+$"
+		},
+		"title": { "type": "string" },
+		"description": { "type": "string" },
+		"content": {
+			"type": "array",
+			"minItems": 1,
+			"items": { "$ref": "#/$defs/contentItem" }
+		}
+	},
+	$defs: {
+		"conditionNoValue": {
+			"type": "object",
+			"required": ["field", "op"],
+			"properties": {
+				"field": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"op": {
+					"type": "string",
+					"enum": ["set", "notset"]
+				}
+			},
+			"additionalProperties": false
+		},
+		"conditionWithValue": {
+			"type": "object",
+			"required": [
+				"field",
+				"op",
+				"value"
+			],
+			"properties": {
+				"field": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"op": {
+					"type": "string",
+					"enum": [
+						"eq",
+						"ne",
+						"lt",
+						"gt",
+						"lte",
+						"gte"
+					]
+				},
+				"value": {}
+			},
+			"additionalProperties": false
+		},
+		"conditionWithArrayValue": {
+			"type": "object",
+			"required": [
+				"field",
+				"op",
+				"value"
+			],
+			"properties": {
+				"field": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"op": {
+					"type": "string",
+					"enum": ["in", "notin"]
+				},
+				"value": { "type": "array" }
+			},
+			"additionalProperties": false
+		},
+		"simpleCondition": { "oneOf": [
+			{ "$ref": "#/$defs/conditionNoValue" },
+			{ "$ref": "#/$defs/conditionWithValue" },
+			{ "$ref": "#/$defs/conditionWithArrayValue" }
+		] },
+		"condition": { "oneOf": [
+			{ "$ref": "#/$defs/simpleCondition" },
+			{
+				"type": "object",
+				"required": ["and"],
+				"properties": { "and": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/condition" }
+				} },
+				"additionalProperties": false
+			},
+			{
+				"type": "object",
+				"required": ["or"],
+				"properties": { "or": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/condition" }
+				} },
+				"additionalProperties": false
+			}
+		] },
+		"stringValidation": {
+			"type": "object",
+			"properties": {
+				"required": { "type": "boolean" },
+				"minLength": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"maxLength": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"pattern": { "type": "string" },
+				"patternMessage": { "type": "string" }
+			},
+			"additionalProperties": false
+		},
+		"numberValidation": {
+			"type": "object",
+			"properties": {
+				"required": { "type": "boolean" },
+				"min": { "type": "number" },
+				"max": { "type": "number" }
+			},
+			"additionalProperties": false
+		},
+		"booleanValidation": {
+			"type": "object",
+			"properties": { "required": { "type": "boolean" } },
+			"additionalProperties": false
+		},
+		"dateValidation": {
+			"type": "object",
+			"properties": {
+				"required": { "type": "boolean" },
+				"minDate": {
+					"type": "string",
+					"pattern": "^([+-]\\d+[dwmy]|\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z)$"
+				},
+				"maxDate": {
+					"type": "string",
+					"pattern": "^([+-]\\d+[dwmy]|\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z)$"
+				}
+			},
+			"additionalProperties": false
+		},
+		"selectValidation": {
+			"type": "object",
+			"properties": { "required": { "type": "boolean" } },
+			"additionalProperties": false
+		},
+		"arrayValidation": {
+			"type": "object",
+			"properties": {
+				"minItems": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"maxItems": {
+					"type": "integer",
+					"minimum": 1
+				}
+			},
+			"additionalProperties": false
+		},
+		"fileValidation": {
+			"type": "object",
+			"properties": { "required": { "type": "boolean" } },
+			"additionalProperties": false
+		},
+		"selectOption": {
+			"type": "object",
+			"required": ["value", "label"],
+			"properties": {
+				"value": { "oneOf": [{ "type": "string" }, { "type": "number" }] },
+				"label": { "type": "string" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemString": {
+			"type": "object",
+			"required": ["type", "label"],
+			"properties": {
+				"type": { "const": "string" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"validation": { "$ref": "#/$defs/stringValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemNumber": {
+			"type": "object",
+			"required": ["type", "label"],
+			"properties": {
+				"type": { "const": "number" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"validation": { "$ref": "#/$defs/numberValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemBoolean": {
+			"type": "object",
+			"required": ["type", "label"],
+			"properties": {
+				"type": { "const": "boolean" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"validation": { "$ref": "#/$defs/booleanValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemDate": {
+			"type": "object",
+			"required": ["type", "label"],
+			"properties": {
+				"type": { "const": "date" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"validation": { "$ref": "#/$defs/dateValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemSelect": {
+			"type": "object",
+			"required": [
+				"type",
+				"label",
+				"options"
+			],
+			"properties": {
+				"type": { "const": "select" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"options": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/selectOption" }
+				},
+				"validation": { "$ref": "#/$defs/selectValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItemFile": {
+			"type": "object",
+			"required": ["type", "label"],
+			"properties": {
+				"type": { "const": "file" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"validation": { "$ref": "#/$defs/fileValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayItem": { "oneOf": [
+			{ "$ref": "#/$defs/arrayItemString" },
+			{ "$ref": "#/$defs/arrayItemNumber" },
+			{ "$ref": "#/$defs/arrayItemBoolean" },
+			{ "$ref": "#/$defs/arrayItemDate" },
+			{ "$ref": "#/$defs/arrayItemSelect" },
+			{ "$ref": "#/$defs/arrayItemFile" }
+		] },
+		"stringField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "string" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"validation": { "$ref": "#/$defs/stringValidation" }
+			},
+			"additionalProperties": false
+		},
+		"numberField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "number" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"validation": { "$ref": "#/$defs/numberValidation" }
+			},
+			"additionalProperties": false
+		},
+		"booleanField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "boolean" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"validation": { "$ref": "#/$defs/booleanValidation" }
+			},
+			"additionalProperties": false
+		},
+		"dateField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "date" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"validation": { "$ref": "#/$defs/dateValidation" }
+			},
+			"additionalProperties": false
+		},
+		"selectField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label",
+				"options"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "select" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"options": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/selectOption" }
+				},
+				"validation": { "$ref": "#/$defs/selectValidation" }
+			},
+			"additionalProperties": false
+		},
+		"arrayField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label",
+				"item"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "array" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"item": { "$ref": "#/$defs/arrayItem" },
+				"validation": { "$ref": "#/$defs/arrayValidation" }
+			},
+			"additionalProperties": false
+		},
+		"fileField": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"label"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "file" },
+				"label": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"validation": { "$ref": "#/$defs/fileValidation" }
+			},
+			"additionalProperties": false
+		},
+		"fieldItem": { "oneOf": [
+			{ "$ref": "#/$defs/stringField" },
+			{ "$ref": "#/$defs/numberField" },
+			{ "$ref": "#/$defs/booleanField" },
+			{ "$ref": "#/$defs/dateField" },
+			{ "$ref": "#/$defs/selectField" },
+			{ "$ref": "#/$defs/arrayField" },
+			{ "$ref": "#/$defs/fileField" }
+		] },
+		"section": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"title",
+				"content"
+			],
+			"properties": {
+				"id": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"type": { "const": "section" },
+				"title": { "type": "string" },
+				"description": { "type": "string" },
+				"condition": { "$ref": "#/$defs/condition" },
+				"content": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/contentItem" }
+				}
+			},
+			"additionalProperties": false
+		},
+		"contentItem": { "oneOf": [{ "$ref": "#/$defs/fieldItem" }, { "$ref": "#/$defs/section" }] }
+	}
+});
+/**
+* Validates form definitions at both the structural (JSON Schema) and
+* semantic levels.
+*
+* Used by {@link FormEngine} during construction before building the engine.
+*
+* ### Schema validation (`validateSchema`)
+* Validates raw input against the form definition JSON Schema. Returns
+* `SCHEMA_INVALID` issues for every violation found.
+*
+* ### Semantic validation (`validate`)
+* Checks for logical issues that go beyond JSON schema validity:
+* 1. **Duplicate IDs** (`DUPLICATE_ID`) -- every content item id must be unique.
+* 2. **Nesting depth** (`NESTING_DEPTH`) -- sections may not be nested more
+*    than 3 levels deep.
+* 3. **Unknown field references** (`UNKNOWN_FIELD_REF`) -- conditions must
+*    only reference field ids that exist in the registry.
+* 4. **Condition references section** (`CONDITION_REFS_SECTION`) -- conditions
+*    must not reference section ids, because sections have no values.
+* 5. **Constraint contradictions** (`INVALID_MIN_MAX`) -- e.g. `minLength > maxLength`,
+*    `min > max`, `minDate > maxDate` (absolute dates only), `minItems > maxItems`.
+* 6. **Invalid regex** (`INVALID_REGEX`) -- string field `pattern` values must
+*    be valid regular expressions.
+*/
+var FormDefinitionValidator = class {
+	/**
+	* Validates raw input against the form definition JSON schema.
+	*
+	* @param input - The raw input to validate.
+	* @returns Array of `SCHEMA_INVALID` issues. Empty when the input conforms to the schema.
+	*/
+	validateSchema(input) {
+		if (validateFn(input)) return [];
+		return (validateFn.errors ?? []).map((err) => {
+			const path = err.instancePath || "/";
+			const message = err.message ?? "Unknown error";
+			if (err.keyword === "additionalProperties") return {
+				code: "SCHEMA_INVALID",
+				message: `${path}: ${message}: '${err.params.additionalProperty}'`
+			};
+			return {
+				code: "SCHEMA_INVALID",
+				message: `${path}: ${message}`
+			};
+		});
+	}
+	/**
+	* Validates a form definition semantically.
+	*
+	* @param definition - The form definition to validate.
+	* @param registry - The flattened field registry built from the definition.
+	* @returns Array of issues found. Empty if the definition is semantically valid.
+	*/
+	validate(definition, registry) {
+		const issues = [];
+		this.checkDuplicateIds(definition.content, issues);
+		this.checkNestingDepth(definition.content, 0, issues);
+		this.checkConditionRefs(registry, issues);
+		this.checkConditionRefsSection(registry, issues);
+		this.checkConstraintContradictions(registry, issues);
+		this.checkInvalidRegex(registry, issues);
+		return issues;
+	}
+	checkDuplicateIds(content, issues) {
+		const seen = /* @__PURE__ */ new Set();
+		this.walkItems(content, (item) => {
+			if (seen.has(item.id)) issues.push({
+				code: "DUPLICATE_ID",
+				message: `Duplicate id: ${item.id}`,
+				itemId: item.id
+			});
+			else seen.add(item.id);
+		});
+	}
+	checkNestingDepth(content, depth, issues) {
+		for (const item of content) if (item.type === "section") if (depth >= 3) issues.push({
+			code: "NESTING_DEPTH",
+			message: `Section nesting exceeds maximum depth of 3: ${item.id}`,
+			itemId: item.id
+		});
+		else this.checkNestingDepth(item.content, depth + 1, issues);
+	}
+	checkConditionRefs(registry, issues) {
+		for (const [id, entry] of registry) {
+			if (!entry.condition) continue;
+			const refs = DependencyGraph.extractFieldRefs(entry.condition);
+			for (const ref of refs) if (!registry.has(ref)) issues.push({
+				code: "UNKNOWN_FIELD_REF",
+				message: `Condition references unknown field: ${ref} (in item ${id})`,
+				itemId: id
+			});
+		}
+	}
+	checkConditionRefsSection(registry, issues) {
+		for (const [id, entry] of registry) {
+			if (!entry.condition) continue;
+			const refs = DependencyGraph.extractFieldRefs(entry.condition);
+			for (const ref of refs) {
+				const refEntry = registry.get(ref);
+				if (refEntry && refEntry.type === "section") issues.push({
+					code: "CONDITION_REFS_SECTION",
+					message: `Condition references section ${ref}, which has no value (in item ${id})`,
+					itemId: id
+				});
+			}
+		}
+	}
+	checkConstraintContradictions(registry, issues) {
+		for (const [id, entry] of registry) {
+			if (!entry.validation) continue;
+			switch (entry.type) {
+				case "string": {
+					const v = entry.validation;
+					if (v.minLength !== void 0 && v.maxLength !== void 0 && v.maxLength < v.minLength) issues.push({
+						code: "INVALID_MIN_MAX",
+						message: `maxLength must be >= minLength for field ${id}`,
+						itemId: id
+					});
+					break;
+				}
+				case "number": {
+					const v = entry.validation;
+					if (v.min !== void 0 && v.max !== void 0 && v.max < v.min) issues.push({
+						code: "INVALID_MIN_MAX",
+						message: `max must be >= min for field ${id}`,
+						itemId: id
+					});
+					break;
+				}
+				case "date": {
+					const v = entry.validation;
+					if (v.minDate !== void 0 && v.maxDate !== void 0) {
+						const minIsAbsolute = !isRelativeDate(v.minDate);
+						const maxIsAbsolute = !isRelativeDate(v.maxDate);
+						if (minIsAbsolute && maxIsAbsolute) {
+							if (Date.parse(v.maxDate) < Date.parse(v.minDate)) issues.push({
+								code: "INVALID_MIN_MAX",
+								message: `maxDate must be >= minDate for field ${id}`,
+								itemId: id
+							});
+						}
+					}
+					break;
+				}
+				case "array": {
+					const v = entry.validation;
+					if (v.minItems !== void 0 && v.maxItems !== void 0 && v.maxItems < v.minItems) issues.push({
+						code: "INVALID_MIN_MAX",
+						message: `maxItems must be >= minItems for field ${id}`,
+						itemId: id
+					});
+					break;
+				}
+			}
+		}
+	}
+	checkInvalidRegex(registry, issues) {
+		for (const [id, entry] of registry) {
+			if (entry.type !== "string" || !entry.validation) continue;
+			const v = entry.validation;
+			if (v.pattern === void 0) continue;
+			try {
+				new RegExp(v.pattern);
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				issues.push({
+					code: "INVALID_REGEX",
+					message: `Invalid regex pattern for field ${id}: ${msg}`,
+					itemId: id
+				});
+			}
+		}
+	}
+	walkItems(content, fn) {
+		for (const item of content) {
+			fn(item);
+			if (item.type === "section") this.walkItems(item.content, fn);
+		}
+	}
+};
+//#endregion
+//#region src/types/errors.ts
+/**
+* Error thrown when form definition or document validation fails.
+*
+* Inspect {@link errors} for structured programmatic access to all
+* validation issues.
+*
+* @example
+* ```ts
+* try {
+*   const engine = new FormEngine(definition);
+* } catch (err) {
+*   if (err instanceof DocumentError) {
+*     for (const e of err.errors) {
+*       console.log(e.code, e.message);
+*     }
+*   }
+* }
+* ```
+*/
+var DocumentError = class extends Error {
+	/** Structured list of all validation errors. */
+	errors;
+	/**
+	* @param errors - One or more validation errors that caused the error.
+	*/
+	constructor(errors) {
+		const summary = errors.map((e) => e.message).join("; ");
+		super(`Document validation failed: ${summary}`);
+		this.name = "DocumentError";
+		this.errors = errors;
+	}
+};
+//#endregion
+//#region src/visibility-resolver.ts
+/**
+* Computes field and section visibility for a form.
+*
+* Provides two modes of visibility computation:
+* - **Single-item** (`isVisible`): evaluates one item's condition plus its
+*   parent chain. Does not use the hidden-field rule.
+* - **Bulk** (`getVisibilityMap`): evaluates all items in topological order
+*   with the hidden-field rule applied (references to hidden fields are
+*   treated as "not set").
+*/
+var VisibilityResolver = class {
+	registry;
+	conditionEvaluator;
+	topologicalOrder;
+	/**
+	* @param registry - The engine's field registry.
+	* @param conditionEvaluator - Evaluator for condition trees.
+	* @param topologicalOrder - Item ids in topological order (from {@link DependencyGraph}).
+	*/
+	constructor(registry, conditionEvaluator, topologicalOrder) {
+		this.registry = registry;
+		this.conditionEvaluator = conditionEvaluator;
+		this.topologicalOrder = topologicalOrder;
+	}
+	/**
+	* Determines whether a single field or section is visible.
+	*
+	* Evaluation logic:
+	* 1. If the item has its own condition, evaluate it. If `false`, the item is hidden.
+	* 2. If the item has a parent section, recursively check parent visibility.
+	*    An item is hidden whenever any ancestor is hidden.
+	* 3. Items without conditions and without hidden parents are visible.
+	*
+	* Unlike {@link getVisibilityMap}, this method does not use the
+	* pre-computed visibility map and does not apply the hidden-field rule.
+	* Use it for one-off visibility checks; prefer `getVisibilityMap` when
+	* evaluating many items at once.
+	*
+	* @param id - Numeric id of the field or section to check.
+	* @param values - Current form values.
+	* @param now - Reference date for relative date expressions.
+	* @returns `true` if the item should be displayed.
+	*/
+	isVisible(id, values, now) {
+		const entry = this.registry.get(id);
+		if (!entry) return false;
+		if (entry.condition) {
+			if (!this.conditionEvaluator.evalCondition(entry.condition, {
+				values,
+				now
+			})) return false;
+		}
+		if (entry.parentId !== void 0) return this.isVisible(entry.parentId, values, now);
+		return true;
+	}
+	/**
+	* Computes visibility for all fields and sections in a single pass.
+	*
+	* Iterates in topological order so that every item is evaluated after the
+	* fields its condition depends on. This enables the **hidden-field rule**:
+	* if a condition references a field that has already been determined hidden,
+	* that field is treated as "not set".
+	*
+	* Cascading parent visibility is also enforced -- if a parent section is
+	* hidden, all its children are immediately marked hidden without evaluating
+	* their own conditions.
+	*
+	* @param values - Current form values.
+	* @param now - Reference date for relative date expressions.
+	* @returns Map from item id to visibility boolean (`true` = visible).
+	*/
+	getVisibilityMap(values, now) {
+		const result = /* @__PURE__ */ new Map();
+		for (const id of this.topologicalOrder) {
+			const entry = this.registry.get(id);
+			if (!entry) {
+				result.set(id, false);
+				continue;
+			}
+			if (entry.parentId !== void 0 && result.get(entry.parentId) === false) {
+				result.set(id, false);
+				continue;
+			}
+			if (entry.condition) {
+				const visible = this.conditionEvaluator.evalCondition(entry.condition, {
+					values,
+					visibilityMap: result,
+					now
+				});
+				result.set(id, visible);
+			} else result.set(id, true);
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/form-engine.ts
+/**
+* The runtime form engine.
+*
+* Created by passing a {@link FormDefinition} to the constructor. The
+* construction lifecycle is:
+*
+* 1. **Build field registry** -- walks the definition tree depth-first,
+*    creating a flat {@link FieldEntry} for every field and section while
+*    recording document-order ids in `contentOrder`.
+* 2. **Semantic validation** -- checks for duplicate ids, excessive nesting,
+*    unknown/invalid condition references, constraint contradictions, and
+*    invalid regex patterns.
+* 3. **Cycle detection** -- verifies that condition dependencies form a DAG
+*    (no circular references).
+* 4. **Error reporting** -- if any issues were found in steps 2-3, throws a
+*    {@link DocumentError} containing all issues.
+* 5. **Build dependency graph** -- creates a forward adjacency map so the
+*    engine can quickly determine which items are affected when a field
+*    value changes.
+* 6. **Topological sort** -- orders all items so that dependencies are
+*    evaluated before dependents (used by `getVisibilityMap`).
+* 7. **Assemble components** -- creates internal {@link ConditionEvaluator},
+*    {@link VisibilityResolver}, and {@link FieldValidator} instances.
+*
+* @example
+* ```ts
+* const engine = new FormEngine(myFormDefinition);
+* const visibility = engine.getVisibilityMap(formValues);
+* const result = engine.validate(formValues);
+* ```
+*/
+var FormEngine = class FormEngine {
+	registry;
+	depGraph;
+	visibilityResolver;
+	fieldValidator;
+	definition;
+	formId;
+	formVersion;
+	/**
+	* Ordered list of all content item ids in depth-first document order.
+	* Matches the order in which items appear in the form definition.
+	*/
+	contentOrder;
+	/**
+	* Compiles a {@link FormDefinition} into a ready-to-use engine.
+	*
+	* @param definition - A complete form definition to compile.
+	* @throws {DocumentError} If the definition contains semantic issues
+	*   or circular condition dependencies.
+	*/
+	constructor(definition) {
+		const definitionValidator = new FormDefinitionValidator();
+		const schemaIssues = definitionValidator.validateSchema(definition);
+		if (schemaIssues.length > 0) throw new DocumentError(schemaIssues);
+		const registry = /* @__PURE__ */ new Map();
+		const contentOrder = [];
+		FormEngine.walkContent(definition.content, void 0, registry, contentOrder);
+		const issues = definitionValidator.validate(definition, registry);
+		const cyclePath = DependencyGraph.detectCycle(registry);
+		if (cyclePath) issues.push({
+			code: "CIRCULAR_DEPENDENCY",
+			message: `Circular condition dependency detected: ${cyclePath.join(" -> ")}`
+		});
+		if (issues.length > 0) throw new DocumentError(issues);
+		this.depGraph = new DependencyGraph(registry);
+		this.visibilityResolver = new VisibilityResolver(registry, new ConditionEvaluator(), this.depGraph.topologicalOrder);
+		this.fieldValidator = new FieldValidator(registry);
+		this.registry = registry;
+		this.contentOrder = contentOrder;
+		this.definition = definition;
+		this.formId = definition.id;
+		this.formVersion = definition.version;
+	}
+	/**
+	* Creates a {@link FormDocument} pre-populated with the form schema's
+	* id and version.
+	*
+	* @param values - Optional initial field values. Defaults to an empty object.
+	* @returns A new form document ready for use with engine methods.
+	*/
+	createFormDocument(values) {
+		return {
+			form: {
+				id: this.formId,
+				version: this.formVersion,
+				submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			values: values ?? {}
+		};
+	}
+	/**
+	* Serializes the form definition and document into a single {@link FormSnapshot}.
+	*
+	* The snapshot contains the original {@link FormDefinition} used to construct
+	* the engine and the provided {@link FormDocument}. No validation is performed;
+	* call {@link validate} separately if needed.
+	*
+	* @param doc - The form document to include in the snapshot.
+	* @returns A snapshot containing both the definition and the document.
+	*/
+	dumpDocument(doc) {
+		return {
+			definition: this.definition,
+			document: doc
+		};
+	}
+	/**
+	* Loads a {@link FormDocument} from a previously created {@link FormSnapshot}.
+	*
+	* Verifies that the snapshot's form definition matches the engine's
+	* compiled definition by comparing id and version. Throws a
+	* {@link DocumentError} if there is a mismatch.
+	*
+	* @param snapshot - A snapshot previously produced by {@link dumpDocument}.
+	* @returns The form document from the snapshot.
+	* @throws {DocumentError} If the snapshot's definition id or version
+	*   does not match the engine's.
+	*/
+	loadDocument(snapshot) {
+		const errors = [];
+		if (snapshot.definition.id !== this.formId) errors.push({
+			code: "FORM_ID_MISMATCH",
+			message: `Snapshot form id "${snapshot.definition.id}" does not match expected "${this.formId}"`,
+			params: {
+				expected: this.formId,
+				actual: snapshot.definition.id
+			}
+		});
+		if (snapshot.definition.version !== this.formVersion) errors.push({
+			code: "FORM_VERSION_MISMATCH",
+			message: `Snapshot form version "${snapshot.definition.version}" does not match expected "${this.formVersion}"`,
+			params: {
+				expected: this.formVersion,
+				actual: snapshot.definition.version
+			}
+		});
+		if (errors.length > 0) throw new DocumentError(errors);
+		return snapshot.document;
+	}
+	/**
+	* Determines whether a field or section is visible given the current form document.
+	*
+	* Evaluates the item's own condition and walks up the parent chain --
+	* an item is hidden if any ancestor is hidden.
+	*
+	* @param id - Numeric id of the field or section.
+	* @param doc - Current form document.
+	* @returns `true` if the item should be displayed, `false` otherwise.
+	*/
+	isVisible(id, doc) {
+		return this.visibilityResolver.isVisible(id, doc.values, FormEngine.parseNow(doc));
+	}
+	/**
+	* Computes visibility for every field and section in topological order.
+	*
+	* The resulting map is keyed by item id. Items whose conditions depend on
+	* other items are evaluated after their dependencies, ensuring correct
+	* cascading visibility (e.g. a hidden parent hides all children).
+	*
+	* @param doc - Current form document.
+	* @returns Map from item id to visibility boolean.
+	*/
+	getVisibilityMap(doc) {
+		return this.visibilityResolver.getVisibilityMap(doc.values, FormEngine.parseNow(doc));
+	}
+	/**
+	* Returns the set of item ids whose visibility may change when the
+	* specified field's value changes.
+	*
+	* Includes transitive dependents -- if field A controls field B, and
+	* field B controls field C, changing A returns `{B, C}`.
+	* Results are cached for the lifetime of the engine.
+	*
+	* @param fieldId - Id of the field that changed.
+	* @returns Set of affected item ids (does not include `fieldId` itself unless
+	*   it is part of a dependency chain).
+	*/
+	getAffectedIds(fieldId) {
+		return this.depGraph.getAffectedIds(fieldId);
+	}
+	/**
+	* Validates form values against the schema's validation rules.
+	*
+	* Only visible fields are validated -- hidden fields are skipped entirely.
+	* Sections are never validated directly. For array fields, each item is
+	* validated individually according to the array's item definition.
+	*
+	* The reference time for relative date validation is derived from
+	* `doc.form.submittedAt`. If that value is missing or unparseable, a
+	* document-level error is reported and `new Date()` is used as fallback.
+	*
+	* @param doc - Current form document to validate.
+	* @returns Validation result with a `valid` flag and a `fieldErrors` map.
+	*/
+	validate(doc) {
+		const documentErrors = [];
+		if (doc.form.id !== this.formId) documentErrors.push({
+			code: "FORM_ID_MISMATCH",
+			message: `Document form id "${doc.form.id}" does not match expected "${this.formId}"`,
+			params: {
+				expected: this.formId,
+				actual: doc.form.id
+			}
+		});
+		if (doc.form.version !== this.formVersion) documentErrors.push({
+			code: "FORM_VERSION_MISMATCH",
+			message: `Document form version "${doc.form.version}" does not match expected "${this.formVersion}"`,
+			params: {
+				expected: this.formVersion,
+				actual: doc.form.version
+			}
+		});
+		let now;
+		if (!doc.form.submittedAt) {
+			documentErrors.push({
+				code: "FORM_SUBMITTED_AT_MISSING",
+				message: "Document form submittedAt is missing"
+			});
+			now = /* @__PURE__ */ new Date();
+		} else {
+			const parsedSubmittedAt = new Date(doc.form.submittedAt);
+			if (Number.isNaN(parsedSubmittedAt.getTime())) {
+				documentErrors.push({
+					code: "FORM_SUBMITTED_AT_INVALID",
+					message: `Document form submittedAt "${doc.form.submittedAt}" is not a valid date`,
+					params: { actual: doc.form.submittedAt }
+				});
+				now = /* @__PURE__ */ new Date();
+			} else now = parsedSubmittedAt;
+		}
+		if (documentErrors.length > 0) return {
+			valid: false,
+			fieldErrors: /* @__PURE__ */ new Map(),
+			documentErrors
+		};
+		const visibilityMap = this.visibilityResolver.getVisibilityMap(doc.values, now);
+		return this.fieldValidator.validate(doc.values, visibilityMap, now);
+	}
+	/**
+	* Retrieves the internal {@link FieldEntry} for a given id.
+	*
+	* @param id - Numeric id of the field or section.
+	* @returns The field entry, or `undefined` if the id is not in the registry.
+	*/
+	getFieldDef(id) {
+		return this.registry.get(id);
+	}
+	static parseNow(doc) {
+		if (doc.form.submittedAt) {
+			const parsed = new Date(doc.form.submittedAt);
+			if (!Number.isNaN(parsed.getTime())) return parsed;
+		}
+		return /* @__PURE__ */ new Date();
+	}
+	static walkContent(content, parentId, registry, contentOrder) {
+		for (const item of content) {
+			const entry = {
+				id: item.id,
+				type: item.type,
+				condition: item.condition,
+				validation: item.type !== "section" ? item.validation : void 0,
+				parentId,
+				options: item.type === "select" ? item.options : void 0,
+				item: item.type === "array" ? item.item : void 0,
+				label: item.type !== "section" ? item.label : void 0,
+				title: item.type === "section" ? item.title : void 0
+			};
+			registry.set(item.id, entry);
+			contentOrder.push(item.id);
+			if (item.type === "section") FormEngine.walkContent(item.content, item.id, registry, contentOrder);
+		}
+	}
+};
+//#endregion
+//#region src/form-values-editor.ts
+/**
+* Mutable editor for building and modifying form values against a {@link FormDefinition}.
+*
+* Wraps a {@link FormEngine} and a mutable {@link FormDocument}. All mutating
+* methods return `this` for fluent chaining.
+*
+* @example
+* ```ts
+* const editor = new FormValuesEditor(definition)
+* editor
+*   .setFieldValue(1, 'Alice')
+*   .setFieldValue(2, 30)
+*   .setSubmittedAt('2025-01-01T00:00:00Z')
+*
+* const result = editor.validate()
+* const doc = editor.toJSON()
+* ```
+*/
+var FormValuesEditor = class {
+	engine;
+	doc;
+	/**
+	* Creates a new editor for the given form definition.
+	*
+	* @param definition - The form definition to edit values against.
+	* @param doc - An existing document to pre-populate. Deep-cloned internally.
+	*   When omitted a blank document is created via {@link FormEngine.createFormDocument}.
+	*/
+	constructor(definition, doc) {
+		this.engine = new FormEngine(definition);
+		this.doc = doc ? JSON.parse(JSON.stringify(doc)) : this.engine.createFormDocument();
+	}
+	/**
+	* Returns the current value of a field.
+	*
+	* @param fieldId - Numeric id of the field.
+	* @returns The field value, or `undefined` if not set.
+	*/
+	getFieldValue(fieldId) {
+		return this.doc.values[String(fieldId)];
+	}
+	/**
+	* Sets the value of a field.
+	*
+	* @param fieldId - Numeric id of the field.
+	* @param value - The value to set.
+	* @returns `this` for chaining.
+	* @throws If `fieldId` is unknown or references a section.
+	*/
+	setFieldValue(fieldId, value) {
+		this.assertField(fieldId);
+		this.doc.values[String(fieldId)] = value;
+		return this;
+	}
+	/**
+	* Removes the value of a field.
+	*
+	* @param fieldId - Numeric id of the field.
+	* @returns `this` for chaining.
+	*/
+	clearFieldValue(fieldId) {
+		delete this.doc.values[String(fieldId)];
+		return this;
+	}
+	/**
+	* Appends an item to an array field.
+	*
+	* If the field currently has no value, it is initialized to an empty array
+	* before appending.
+	*
+	* @param fieldId - Numeric id of the array field.
+	* @param value - The value to append. Defaults to `undefined`.
+	* @returns `this` for chaining.
+	* @throws If `fieldId` is not an array field.
+	*/
+	addArrayItem(fieldId, value) {
+		this.getOrInitArray(fieldId).push(value);
+		return this;
+	}
+	/**
+	* Removes an item from an array field by index.
+	*
+	* @param fieldId - Numeric id of the array field.
+	* @param index - Zero-based index of the item to remove.
+	* @returns `this` for chaining.
+	* @throws If `fieldId` is not an array field or the index is out of bounds.
+	*/
+	removeArrayItem(fieldId, index) {
+		const arr = this.assertArray(fieldId);
+		if (index < 0 || index >= arr.length) throw new Error(`Index ${index} is out of bounds for array field ${fieldId} (length ${arr.length})`);
+		arr.splice(index, 1);
+		return this;
+	}
+	/**
+	* Moves an item within an array field from one index to another.
+	*
+	* @param fieldId - Numeric id of the array field.
+	* @param fromIndex - Current zero-based index of the item.
+	* @param toIndex - Target zero-based index.
+	* @returns `this` for chaining.
+	* @throws If `fieldId` is not an array field or either index is out of bounds.
+	*/
+	moveArrayItem(fieldId, fromIndex, toIndex) {
+		const arr = this.assertArray(fieldId);
+		if (fromIndex < 0 || fromIndex >= arr.length) throw new Error(`fromIndex ${fromIndex} is out of bounds for array field ${fieldId} (length ${arr.length})`);
+		if (toIndex < 0 || toIndex >= arr.length) throw new Error(`toIndex ${toIndex} is out of bounds for array field ${fieldId} (length ${arr.length})`);
+		const [item] = arr.splice(fromIndex, 1);
+		arr.splice(toIndex, 0, item);
+		return this;
+	}
+	/**
+	* Sets the value of an item at a specific index in an array field.
+	*
+	* @param fieldId - Numeric id of the array field.
+	* @param index - Zero-based index of the item to set.
+	* @param value - The new value for the item.
+	* @returns `this` for chaining.
+	* @throws If `fieldId` is not an array field or the index is out of bounds.
+	*/
+	setArrayItem(fieldId, index, value) {
+		const arr = this.assertArray(fieldId);
+		if (index < 0 || index >= arr.length) throw new Error(`Index ${index} is out of bounds for array field ${fieldId} (length ${arr.length})`);
+		arr[index] = value;
+		return this;
+	}
+	/**
+	* Sets the `submittedAt` timestamp on the document.
+	*
+	* @param submittedAt - ISO 8601 timestamp string.
+	* @returns `this` for chaining.
+	*/
+	setSubmittedAt(submittedAt) {
+		this.doc.form.submittedAt = submittedAt;
+		return this;
+	}
+	/**
+	* Validates the current document against the form definition.
+	*
+	* Delegates to {@link FormEngine.validate}.
+	*
+	* @returns The validation result.
+	*/
+	validate() {
+		return this.engine.validate(this.doc);
+	}
+	/**
+	* Computes visibility for every field and section.
+	*
+	* Delegates to {@link FormEngine.getVisibilityMap}.
+	*
+	* @returns Map from item id to visibility boolean.
+	*/
+	getVisibilityMap() {
+		return this.engine.getVisibilityMap(this.doc);
+	}
+	/**
+	* Determines whether a field or section is visible given current values.
+	*
+	* Delegates to {@link FormEngine.isVisible}.
+	*
+	* @param id - Numeric id of the field or section.
+	* @returns `true` if the item should be displayed.
+	*/
+	isVisible(id) {
+		return this.engine.isVisible(id, this.doc);
+	}
+	/**
+	* Returns a deep clone of the current form document.
+	*
+	* @returns A new serializable {@link FormDocument} instance.
+	*/
+	toJSON() {
+		return JSON.parse(JSON.stringify(this.doc));
+	}
+	/**
+	* Asserts that `fieldId` exists in the registry and is not a section.
+	*/
+	assertField(fieldId) {
+		const entry = this.engine.getFieldDef(fieldId);
+		if (!entry) throw new Error(`Field with id ${fieldId} not found`);
+		if (entry.type === "section") throw new Error(`Item ${fieldId} is a section, not a field`);
+	}
+	/**
+	* Asserts that `fieldId` is an array field and returns the current array value.
+	* Throws if the field is not an array type or the current value is not an array.
+	*/
+	assertArray(fieldId) {
+		const entry = this.engine.getFieldDef(fieldId);
+		if (!entry) throw new Error(`Field with id ${fieldId} not found`);
+		if (entry.type !== "array") throw new Error(`Field ${fieldId} is not an array field`);
+		const val = this.doc.values[String(fieldId)];
+		if (!Array.isArray(val)) throw new Error(`Field ${fieldId} does not currently hold an array value`);
+		return val;
+	}
+	/**
+	* Returns the array value for `fieldId`, initializing to `[]` if not yet set.
+	*/
+	getOrInitArray(fieldId) {
+		const entry = this.engine.getFieldDef(fieldId);
+		if (!entry) throw new Error(`Field with id ${fieldId} not found`);
+		if (entry.type !== "array") throw new Error(`Field ${fieldId} is not an array field`);
+		const key = String(fieldId);
+		let val = this.doc.values[key];
+		if (!Array.isArray(val)) {
+			val = [];
+			this.doc.values[key] = val;
+		}
+		return val;
+	}
+};
+//#endregion
+export { ConditionEvaluator, DependencyGraph, DocumentError, FieldValidator, FormDefinitionEditor, FormDefinitionValidator, FormEngine, FormValuesEditor, VisibilityResolver };
+
+//# sourceMappingURL=index.mjs.map