@ng-forge/dynamic-forms 1.3.0-next.1 → 1.3.0-next.3

package/fesm2022/ng-forge-dynamic-forms-bootstrap-web-mcp-2wQK_wPp.mjs

@@ -0,0 +1,954 @@
+import { n as FormStateManager, s as FormSubmitEvent } from "./ng-forge-dynamic-forms-form-state-manager-DcOXRFRL.mjs";
+import { n as getNormalizedArrayMetadata } from "./ng-forge-dynamic-forms-default-value-D5M4MNE-.mjs";
+import { inject, untracked } from "@angular/core";
+import { DynamicFormLogger, EventBus, getFieldValueHandling, interpolateParams } from "@ng-forge/dynamic-forms/internal";
+function createPendingSubmission() {
+	let settled = false;
+	let accepted = false;
+	let resolve;
+	const outcome = new Promise((resolvePromise) => {
+		resolve = resolvePromise;
+	});
+	const settle = (result) => {
+		if (settled) return;
+		settled = true;
+		resolve(result);
+	};
+	return {
+		reply: {
+			accept: () => {
+				accepted = true;
+			},
+			settle
+		},
+		accepted: () => accepted,
+		outcome,
+		cancel: () => settle({ status: "cancelled" })
+	};
+}
+function buildToolSchema(plan) {
+	return {
+		type: "object",
+		properties: buildProperties(plan),
+		additionalProperties: false
+	};
+}
+function buildProperties(nodes) {
+	const properties = {};
+	for (const node of nodes) {
+		if (!node.policy.writable) continue;
+		const schema = buildNodeSchema(node);
+		if (schema) properties[node.key] = schema;
+	}
+	return properties;
+}
+function buildNodeSchema(node) {
+	switch (node.kind) {
+		case "group": return annotate(node, {
+			type: "object",
+			properties: buildProperties(node.children),
+			additionalProperties: false
+		});
+		case "array": {
+			if (!node.item) return void 0;
+			const schema = {
+				type: "array",
+				items: buildItemSchema(node.item)
+			};
+			if (node.minItems !== void 0) schema.minItems = node.minItems;
+			if (node.maxItems !== void 0) schema.maxItems = node.maxItems;
+			return annotate(node, schema);
+		}
+		case "scalar": return annotate(node, buildScalarSchema(node));
+	}
+}
+function buildItemSchema(item) {
+	if (item.kind === "object") return {
+		type: "object",
+		properties: buildProperties(item.children),
+		additionalProperties: false
+	};
+	return buildScalarSchema(item.value);
+}
+function buildScalarSchema(plan) {
+	const base = plan.options ? optionSchema(plan) : { type: singleOrUnion(plan.types) };
+	if (plan.multiple) return {
+		type: "array",
+		items: base
+	};
+	const withConstraints = { ...base };
+	const { minLength, maxLength, minimum, maximum, pattern, format } = plan.constraints;
+	if (minLength !== void 0) withConstraints.minLength = minLength;
+	if (maxLength !== void 0) withConstraints.maxLength = maxLength;
+	if (minimum !== void 0) withConstraints.minimum = minimum;
+	if (maximum !== void 0) withConstraints.maximum = maximum;
+	if (pattern !== void 0) withConstraints.pattern = pattern;
+	if (format !== void 0) withConstraints.format = format;
+	return withConstraints;
+}
+function optionSchema(plan) {
+	const options = plan.options ?? [];
+	const values = options.map((option) => option.value);
+	const nullable = !plan.multiple && plan.types.includes("null");
+	const schema = {
+		type: singleOrUnion(plan.types),
+		enum: nullable ? [...values, null] : values
+	};
+	const branches = options.map((option) => option.title ? {
+		const: option.value,
+		title: option.title
+	} : { const: option.value });
+	if (nullable) branches.push({ const: null });
+	if (options.some((option) => option.title)) schema.anyOf = branches;
+	return schema;
+}
+function singleOrUnion(types) {
+	return types.length === 1 ? types[0] : types;
+}
+function annotate(node, schema) {
+	const annotated = { ...schema };
+	if (node.label) annotated.title = node.label;
+	if (node.description) annotated.description = node.description;
+	if (node.kind === "scalar" && node.default !== void 0) annotated.default = node.default;
+	return annotated;
+}
+function collectFieldReports(plan, tree) {
+	const walkResult = {
+		reports: [],
+		paths: /* @__PURE__ */ new Map(),
+		messages: /* @__PURE__ */ new Map(),
+		state: /* @__PURE__ */ new Map()
+	};
+	walk(plan, tree, walkResult);
+	return walkResult;
+}
+function walk(nodes, tree, out) {
+	const record = tree;
+	for (const node of nodes) {
+		const subtree = record[node.key];
+		if (typeof subtree !== "function") continue;
+		const state = subtree();
+		out.paths.set(subtree, node.path);
+		if (node.messages) out.messages.set(subtree, node.messages);
+		out.state.set(node.path, {
+			disabled: state.disabled(),
+			readonly: state.readonly(),
+			hidden: state.hidden()
+		});
+		out.reports.push({
+			path: node.path,
+			label: node.label,
+			applicable: !state.hidden() && !state.disabled(),
+			required: state.required(),
+			writable: node.policy.writable,
+			readable: node.policy.readable,
+			filled: hasValue(state.value()),
+			options: node.kind === "scalar" ? node.options : void 0
+		});
+		if (node.kind === "group") {
+			walk(node.children, subtree, out);
+			continue;
+		}
+		if (node.kind === "array") walkArray(node, subtree, out);
+	}
+}
+function walkArray(node, subtree, out) {
+	if (node.item?.kind !== "object") return;
+	const value = subtree().value();
+	if (!Array.isArray(value)) return;
+	const indexed = subtree;
+	for (let index = 0; index < value.length; index += 1) {
+		const itemTree = indexed[index];
+		if (typeof itemTree !== "function") continue;
+		walk(rebase(node.item.children, `${node.path}[${index}]`), itemTree, out);
+	}
+}
+function rebase(nodes, prefix) {
+	return nodes.map((node) => {
+		const path = `${prefix}.${node.key}`;
+		if (node.kind === "group") return {
+			...node,
+			path,
+			children: rebase(node.children, path)
+		};
+		if (node.kind === "array" && node.item?.kind === "object") return {
+			...node,
+			path,
+			item: {
+				kind: "object",
+				children: rebase(node.item.children, `${path}[]`)
+			}
+		};
+		return {
+			...node,
+			path
+		};
+	});
+}
+function hasValue(value) {
+	if (value === null || value === void 0 || value === "") return false;
+	if (Array.isArray(value)) return value.length > 0;
+	if (typeof value === "number") return !Number.isNaN(value);
+	return true;
+}
+function buildFieldPlan(fields, registry, warn) {
+	const nodes = [];
+	collectInto(nodes, fields, registry, "", warn);
+	return nodes;
+}
+function collectInto(out, fields, registry, prefix, warn) {
+	for (const field of fields) {
+		const valueHandling = getFieldValueHandling(field.type, registry);
+		if (valueHandling === "exclude") continue;
+		const candidate = field;
+		if (valueHandling === "flatten") {
+			const children = asFieldArray(candidate.fields);
+			if (children) collectInto(out, children, registry, prefix, warn);
+			continue;
+		}
+		if (!candidate.key) continue;
+		const node = buildNode(candidate, registry, prefix, warn);
+		if (node) out.push(node);
+	}
+}
+function buildNode(field, registry, prefix, warn) {
+	const key = field.key;
+	const path = prefix ? `${prefix}.${key}` : key;
+	const base = {
+		key,
+		path,
+		label: staticText(field.label),
+		description: staticText(field.placeholder) ?? staticText(field.props?.placeholder) ?? staticText(field.props?.hint),
+		policy: resolvePolicy(field),
+		messages: field.validationMessages
+	};
+	if (field.type === "group") {
+		const children = [];
+		collectInto(children, asFieldArray(field.fields) ?? [], registry, path, warn);
+		return {
+			...base,
+			kind: "group",
+			children
+		};
+	}
+	if (field.type === "array") return buildArrayNode(field, base, registry, warn);
+	return buildScalar(field, base, registry);
+}
+function buildArrayNode(field, base, registry, warn) {
+	const plan = {
+		...base,
+		kind: "array",
+		item: buildItemPlan(field, base.path, registry, warn)
+	};
+	if (typeof field.minLength === "number") plan.minItems = field.minLength;
+	if (typeof field.maxLength === "number") plan.maxItems = field.maxLength;
+	return plan;
+}
+function buildItemPlan(field, path, registry, warn) {
+	const template = getNormalizedArrayMetadata(field)?.template;
+	const source = template ?? firstDeclaredItem(field);
+	if (source === void 0) return void 0;
+	const itemPlan = itemPlanFrom(source, path, registry, warn);
+	if (!itemPlan) return void 0;
+	if (!template && !itemsAreHomogeneous(field, path, registry, itemPlan, warn)) {
+		warn?.(`WebMCP: array field "${field.key}" declares items with different shapes. Only homogeneous arrays can be described to an agent, so its items are left unspecified.`);
+		return;
+	}
+	return itemPlan;
+}
+function itemPlanFrom(source, path, registry, warn) {
+	if (Array.isArray(source)) {
+		const children = [];
+		collectInto(children, source, registry, `${path}[]`, warn);
+		return {
+			kind: "object",
+			children
+		};
+	}
+	const itemField = source;
+	if (!itemField?.type) return void 0;
+	const node = buildNode(itemField, registry, `${path}[]`, warn);
+	if (!node || node.kind !== "scalar") return void 0;
+	return {
+		kind: "value",
+		value: node
+	};
+}
+function firstDeclaredItem(field) {
+	const items = Array.isArray(field.fields) ? field.fields : void 0;
+	return items?.length ? items[0] : void 0;
+}
+function itemsAreHomogeneous(field, path, registry, first, warn) {
+	return (Array.isArray(field.fields) ? field.fields : []).every((item) => {
+		const candidate = itemPlanFrom(item, path, registry, warn);
+		return candidate !== void 0 && sameShape(candidate, first);
+	});
+}
+function sameShape(a, b) {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "value" && b.kind === "value") return scalarShape(a.value) === scalarShape(b.value);
+	const aChildren = a.children;
+	const bChildren = b.children;
+	if (aChildren.length !== bChildren.length) return false;
+	return aChildren.every((child, index) => nodeShape(child) === nodeShape(bChildren[index]));
+}
+function nodeShape(node) {
+	switch (node.kind) {
+		case "scalar": return `${node.key}:${scalarShape(node)}`;
+		case "group": return `${node.key}:group(${node.children.map(nodeShape).join(",")})`;
+		case "array": return `${node.key}:array(${node.item ? itemShape(node.item) : "?"})`;
+	}
+}
+function itemShape(item) {
+	return item.kind === "value" ? scalarShape(item.value) : item.children.map(nodeShape).join(",");
+}
+function scalarShape(plan) {
+	const options = plan.options ? plan.options.map((option) => JSON.stringify(option.value)).join("|") : "";
+	return `${plan.types.join("/")}${plan.multiple ? "[]" : ""}${options ? `{${options}}` : ""}`;
+}
+function buildScalar(field, base, registry) {
+	const scope = resolveScope(field, registry);
+	const options = usableOptions(field);
+	const constraints = collectConstraints(field);
+	if (options && (scope === "single-select" || scope === "multi-select")) {
+		const types = [inferTypeFromValues(options.map((option) => option.value))];
+		const multiple = scope === "multi-select";
+		return {
+			...base,
+			kind: "scalar",
+			types: multiple || !field.nullable ? types : [...types, "null"],
+			options,
+			multiple,
+			default: jsonPrimitive(field.value),
+			constraints
+		};
+	}
+	if (scope === "date") return {
+		...base,
+		kind: "scalar",
+		types: withNull(["string"], field.nullable),
+		multiple: false,
+		default: jsonPrimitive(field.value),
+		constraints: {
+			...constraints,
+			format: constraints.format ?? "date"
+		}
+	};
+	return {
+		...base,
+		kind: "scalar",
+		types: withNull([scalarTypeFor(scope, field)], field.nullable),
+		multiple: false,
+		default: jsonPrimitive(field.value),
+		constraints
+	};
+}
+function usableOptions(field) {
+	if (!field.options?.length) return void 0;
+	const usable = field.options.filter((option) => option.disabled !== true).map((option) => {
+		const title = staticText(option.label);
+		return title ? {
+			value: option.value,
+			title
+		} : { value: option.value };
+	});
+	return usable.length ? usable : void 0;
+}
+function scalarTypeFor(scope, field) {
+	switch (scope) {
+		case "boolean": return "boolean";
+		case "numeric": return "number";
+		case "text-input": return "string";
+		default: return inferTypeFromValues([field.value]);
+	}
+}
+function resolveScope(field, registry) {
+	const declared = registry.get(field.type)?.scope;
+	if (!declared) return void 0;
+	if (!Array.isArray(declared)) return declared;
+	if (declared.includes("numeric") && declared.includes("text-input")) return field.props?.type === "number" ? "numeric" : "text-input";
+	return declared[0];
+}
+function inferTypeFromValues(values) {
+	const known = values.filter((value) => value !== null && value !== void 0);
+	if (!known.length) return "string";
+	if (known.every((value) => typeof value === "number")) return "number";
+	if (known.every((value) => typeof value === "boolean")) return "boolean";
+	return "string";
+}
+function withNull(types, nullable) {
+	return nullable ? [...types, "null"] : types;
+}
+function collectConstraints(field) {
+	const constraints = {};
+	if (typeof field.minLength === "number" && field.type !== "array") constraints.minLength = field.minLength;
+	if (typeof field.maxLength === "number" && field.type !== "array") constraints.maxLength = field.maxLength;
+	if (typeof field.min === "number") constraints.minimum = field.min;
+	if (typeof field.max === "number") constraints.maximum = field.max;
+	if (field.pattern instanceof RegExp) constraints.pattern = field.pattern.source;
+	else if (typeof field.pattern === "string") constraints.pattern = field.pattern;
+	if (field.email) constraints.format = "email";
+	for (const validator of field.validators ?? []) {
+		if (!isStaticValidator(validator)) continue;
+		const value = validator.value;
+		switch (validator.type) {
+			case "minLength":
+				if (typeof value === "number") constraints.minLength = value;
+				break;
+			case "maxLength":
+				if (typeof value === "number") constraints.maxLength = value;
+				break;
+			case "min":
+				if (typeof value === "number") constraints.minimum = value;
+				break;
+			case "max":
+				if (typeof value === "number") constraints.maximum = value;
+				break;
+			case "pattern":
+				if (value instanceof RegExp) constraints.pattern = value.source;
+				else if (typeof value === "string") constraints.pattern = value;
+				break;
+			case "email": constraints.format = "email";
+		}
+	}
+	return constraints;
+}
+function isStaticValidator(validator) {
+	return validator.when === void 0 && validator.expression === void 0;
+}
+function resolvePolicy(field) {
+	const declared = field.webMcp;
+	if (declared === false) return {
+		readable: false,
+		writable: false
+	};
+	const isHiddenType = field.type === "hidden";
+	const isSecret = field.props?.type === "password";
+	const isDerived = field.derivation !== void 0 || (field.logic ?? []).some((rule) => rule?.type === "derivation");
+	const isReadonly = field.readonly === true || (field.logic ?? []).some((rule) => rule?.type === "readonly");
+	return {
+		readable: declared?.readable ?? (!isHiddenType && !isSecret),
+		writable: declared?.writable ?? (!isHiddenType && !isDerived && !isReadonly)
+	};
+}
+function staticText(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function jsonPrimitive(value) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+}
+function asFieldArray(value) {
+	return Array.isArray(value) ? value : void 0;
+}
+function toErrorReports(errors, paths, messages, defaults) {
+	return errors.map((error) => {
+		const kind = String(error.kind);
+		const template = staticMessage(messages.get(error.fieldTree)?.[kind]) ?? staticMessage(defaults?.[kind]);
+		return {
+			path: paths.get(error.fieldTree) ?? "",
+			message: template ? interpolateParams(template, error) : error.message ?? kind
+		};
+	});
+}
+function staticMessage(message) {
+	return typeof message === "string" && message.length > 0 ? message : void 0;
+}
+function renderRejection(errors) {
+	return [
+		"Nothing was applied. The form is unchanged.",
+		"",
+		"Problems with the arguments:",
+		...errors.map((error) => `- ${error}`)
+	].join("\n");
+}
+function renderFormReport(report) {
+	const lines = [];
+	if (report.changed.length) {
+		lines.push(`Applied: ${report.changed.join(", ")}.`);
+		lines.push(report.scope === "all" ? "Current values:" : "Current values of the fields you set:");
+		lines.push(JSON.stringify(report.values, null, 2));
+	} else {
+		lines.push("No changes made.");
+		if (report.scope === "all") {
+			lines.push("Current values:");
+			lines.push(JSON.stringify(report.values, null, 2));
+		}
+	}
+	appendFieldSections(lines, report.fields);
+	appendErrorSection(lines, report.errors, report.validationPending);
+	return lines.join("\n");
+}
+function appendFieldSections(lines, fields) {
+	const inapplicable = fields.filter((field) => !field.applicable);
+	if (inapplicable.length) {
+		lines.push("");
+		lines.push(`Not currently applicable (do not send these): ${paths(inapplicable)}`);
+	}
+	const required = fields.filter((field) => field.applicable && field.required);
+	if (required.length) {
+		lines.push("");
+		lines.push(`Required (given the current values): ${paths(required)}`);
+	}
+	const empty = fields.filter((field) => field.applicable && field.writable && !field.filled);
+	if (empty.length) {
+		lines.push("");
+		lines.push(`Still empty: ${paths(empty)}`);
+	}
+	const locked = fields.filter((field) => field.applicable && !field.writable);
+	if (locked.length) {
+		lines.push("");
+		lines.push(`Cannot be set by an agent: ${paths(locked)}`);
+	}
+}
+function appendErrorSection(lines, errors, validationPending) {
+	if (errors.length) {
+		lines.push("");
+		lines.push("Validation errors:");
+		for (const error of errors) lines.push(`- ${error.path ? `${error.path}: ` : ""}${error.message}`);
+	}
+	if (validationPending) {
+		lines.push("");
+		lines.push("Validation has not finished — some checks are still running, so this list may be incomplete. Call again to re-read it.");
+		return;
+	}
+	if (!errors.length) {
+		lines.push("");
+		lines.push("No validation errors.");
+	}
+}
+function paths(fields) {
+	return fields.map((field) => field.path).join(", ");
+}
+function renderSubmitResult(outcome, report) {
+	switch (outcome.status) {
+		case "success": return "Form submitted successfully.";
+		case "dispatched": return "Form submitted. The page handled the submission itself, so there is no result to report back.";
+		case "server-errors": return renderFailure("Submitted, but it came back with errors.", report, "Correct these and call again.");
+		case "action-failed": return renderFailure(`Not submitted: the submission failed. ${describeError(outcome.error)}`, report, "The values you sent are still in the form. This may be worth retrying.");
+		case "validation-failed": return renderFailure("Not submitted: validation failed.", report, changedNote(report));
+		case "pending-validation": return renderFailure("Not submitted: validation had not finished when the form was asked to submit.", report, "The values you sent are still in the form. Call again in a moment.");
+		case "busy": return "Not submitted: this form is already submitting. Wait for that to finish before trying again.";
+		case "cancelled": return "Not submitted: the form went away before the submission finished.";
+	}
+}
+function renderFailure(headline, report, closing) {
+	const lines = [headline];
+	for (const error of report.errors) lines.push(`- ${error.path ? `${error.path}: ` : ""}${error.message}`);
+	lines.push("");
+	lines.push(closing);
+	return lines.join("\n");
+}
+function changedNote(report) {
+	return report.changed.length ? "The values you sent were applied to the form and are still there. Send only the corrected fields and call again." : "The form was not modified. Send the corrected fields and call again.";
+}
+function describeError(error) {
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+	return message ? `Reason: ${message.slice(0, 200)}` : "No reason was given.";
+}
+const NAME_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+const NAME_BUDGET = 30;
+function findModelContext() {
+	const hosts = globalThis;
+	const fromDocument = hosts.document?.["modelContext"];
+	if (isModelContext(fromDocument)) return fromDocument;
+	const fromNavigator = hosts.navigator?.["modelContext"];
+	if (isModelContext(fromNavigator)) return fromNavigator;
+}
+function isModelContext(candidate) {
+	return typeof candidate?.registerTool === "function";
+}
+function validateToolName(name) {
+	if (!NAME_PATTERN.test(name)) return `Tool name "${name}" is not usable: names must be 1-128 characters of A-Z, a-z, 0-9, "_", "-" or ".".`;
+}
+function isOverNameBudget(name) {
+	return name.length > NAME_BUDGET;
+}
+async function registerTool(context, descriptor, signal) {
+	const invalid = validateToolName(descriptor.name);
+	if (invalid) return {
+		ok: false,
+		reason: invalid
+	};
+	if (signal.aborted) return {
+		ok: false,
+		reason: "Registration was superseded before it started."
+	};
+	try {
+		await context.registerTool(descriptor, { signal });
+		return { ok: true };
+	} catch (error) {
+		return {
+			ok: false,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+const SKIP = Symbol("skip");
+function parseAgentInput(plan, input, liveBlock, current) {
+	if (input === void 0 || input === null) return {
+		ok: true,
+		patch: {},
+		paths: []
+	};
+	if (!isPlainObject$1(input)) return {
+		ok: false,
+		errors: ["Arguments must be an object of field names to values."]
+	};
+	const errors = [];
+	const paths = [];
+	const patch = parseLevel(plan, input, "", errors, paths, liveBlock, isPlainObject$1(current) ? current : void 0);
+	return errors.length ? {
+		ok: false,
+		errors
+	} : {
+		ok: true,
+		patch,
+		paths
+	};
+}
+function parseLevel(nodes, input, prefix, errors, paths, liveBlock, current) {
+	const byKey = new Map(nodes.map((node) => [node.key, node]));
+	const patch = {};
+	for (const [key, value] of Object.entries(input)) {
+		const label = prefix ? `${prefix}.${key}` : key;
+		const node = byKey.get(key);
+		if (!node) {
+			const writable = nodes.filter((candidate) => candidate.policy.writable).map((candidate) => candidate.key);
+			errors.push(`Unknown field "${label}". This form accepts: ${writable.join(", ") || "(no writable fields)"}.`);
+			continue;
+		}
+		if (!node.policy.writable) {
+			errors.push(`Field "${label}" cannot be set by an agent.`);
+			continue;
+		}
+		const blocked = liveBlock?.(node.path);
+		if (blocked) {
+			errors.push(`Field "${label}" cannot be set right now: ${blocked}.`);
+			continue;
+		}
+		const parsed = parseNode(node, value, label, errors, paths, liveBlock, current?.[key]);
+		if (parsed !== SKIP) {
+			patch[key] = parsed;
+			if (node.kind !== "group") paths.push(node.path);
+		}
+	}
+	return patch;
+}
+function parseNode(node, value, label, errors, paths, liveBlock, current) {
+	switch (node.kind) {
+		case "scalar": return parseScalar(node, value, label, errors);
+		case "group": {
+			if (!isPlainObject$1(value)) {
+				errors.push(`Field "${label}" is a group and expects an object.`);
+				return SKIP;
+			}
+			const before = errors.length;
+			const nested = parseLevel(node.children, value, label, errors, paths, liveBlock, isPlainObject$1(current) ? current : void 0);
+			return errors.length === before ? nested : SKIP;
+		}
+		case "array": {
+			if (!Array.isArray(value)) {
+				errors.push(`Field "${label}" is a list and expects an array.`);
+				return SKIP;
+			}
+			if (!node.item) {
+				errors.push(`Field "${label}" has an item shape that cannot be described to an agent, so it cannot be set.`);
+				return SKIP;
+			}
+			const protectedKeys = protectedValuesInUse(node.item, current);
+			if (protectedKeys.length) {
+				errors.push(`Field "${label}" cannot be replaced: its items carry ${protectedKeys.join(", ")}, which an agent cannot set, and a list is replaced whole rather than merged item by item. Sending it would discard those values.`);
+				return SKIP;
+			}
+			const before = errors.length;
+			const itemPaths = [];
+			const items = value.map((item, index) => parseItem(node.item, item, `${label}[${index}]`, errors, itemPaths, liveBlock));
+			return errors.length === before ? items : SKIP;
+		}
+	}
+}
+function parseItem(item, value, label, errors, paths, liveBlock) {
+	if (item.kind === "value") return parseScalar(item.value, value, label, errors);
+	if (!isPlainObject$1(value)) {
+		errors.push(`Item "${label}" expects an object.`);
+		return SKIP;
+	}
+	return parseLevel(item.children, value, label, errors, paths, liveBlock, void 0);
+}
+function parseScalar(plan, value, label, errors) {
+	if (plan.multiple) {
+		if (!Array.isArray(value)) {
+			errors.push(`Field "${label}" accepts multiple values and expects an array.`);
+			return SKIP;
+		}
+		const invalid = value.filter((entry) => !isAllowedOption(plan, entry));
+		if (invalid.length) {
+			errors.push(`Field "${label}" got ${describe(invalid[0])}, which is not one of: ${optionList(plan)}.`);
+			return SKIP;
+		}
+		return value;
+	}
+	if (plan.options) {
+		if (!isAllowedOption(plan, value) && !(value === null && plan.types.includes("null"))) {
+			errors.push(`Field "${label}" got ${describe(value)}, which is not one of: ${optionList(plan)}.`);
+			return SKIP;
+		}
+		return value;
+	}
+	if (!plan.types.some((type) => matchesType(type, value))) {
+		errors.push(`Field "${label}" expects ${plan.types.join(" or ")} but got ${describe(value)}.`);
+		return SKIP;
+	}
+	return value;
+}
+function isAllowedOption(plan, value) {
+	return (plan.options ?? []).some((option) => Object.is(option.value, value));
+}
+function optionList(plan) {
+	return (plan.options ?? []).map((option) => JSON.stringify(option.value)).join(", ");
+}
+function matchesType(type, value) {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "null": return value === null;
+	}
+}
+function describe(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return "an array";
+	if (typeof value === "object") return "an object";
+	if (typeof value === "string") return value.length > 40 ? "a long string" : JSON.stringify(value);
+	return JSON.stringify(value);
+}
+function protectedValuesInUse(item, current) {
+	if (item.kind !== "object" || !Array.isArray(current) || !current.length) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const existing of current) collectProtected(item.children, existing, "", names);
+	return [...names];
+}
+function collectProtected(nodes, value, prefix, into) {
+	if (!isPlainObject$1(value)) return;
+	for (const node of nodes) {
+		const name = prefix ? `${prefix}.${node.key}` : node.key;
+		const held = value[node.key];
+		if (node.kind === "group") {
+			collectProtected(node.children, held, name, into);
+			continue;
+		}
+		if (!node.policy.writable && holdsValue(held)) {
+			into.add(`"${name}"`);
+			continue;
+		}
+		if (node.kind === "array" && node.item && Array.isArray(held)) collectProtectedInItems(node.item, held, `${name}[]`, into);
+	}
+}
+function collectProtectedInItems(item, items, prefix, into) {
+	for (const entry of items) {
+		if (item.kind === "value") {
+			if (!item.value.policy.writable && holdsValue(entry)) into.add(`"${prefix}"`);
+			continue;
+		}
+		collectProtected(item.children, entry, prefix, into);
+	}
+}
+function holdsValue(value) {
+	if (value === void 0 || value === null || value === "") return false;
+	if (Array.isArray(value)) return value.length > 0;
+	return true;
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergePatch(current, patch, plan) {
+	const byKey = new Map(plan.map((node) => [node.key, node]));
+	const next = { ...current };
+	for (const [key, value] of Object.entries(patch)) {
+		const node = byKey.get(key);
+		if (node?.kind === "group" && isPlainObject(value)) {
+			next[key] = mergePatch(isPlainObject(current[key]) ? current[key] : {}, value, node.children);
+			continue;
+		}
+		next[key] = value;
+	}
+	return next;
+}
+const REDACTED = "[not readable by agents]";
+function redactValues(value, plan) {
+	if (!isPlainObject(value)) return value;
+	const out = {};
+	for (const node of plan) {
+		if (!(node.key in value)) continue;
+		if (!node.policy.readable) {
+			out[node.key] = REDACTED;
+			continue;
+		}
+		out[node.key] = redactNode(node, value[node.key]);
+	}
+	return out;
+}
+function redactNode(node, value) {
+	switch (node.kind) {
+		case "group": return redactValues(value, node.children);
+		case "array":
+			if (!Array.isArray(value) || node.item?.kind !== "object") return value;
+			return value.map((item) => redactValues(item, node.item.children));
+		case "scalar": return value;
+	}
+}
+function pickPaths(value, paths) {
+	if (!isPlainObject(value)) return {};
+	const out = {};
+	for (const path of paths) {
+		const [head, ...rest] = path.split(".");
+		if (!(head in value)) continue;
+		if (!rest.length) {
+			out[head] = value[head];
+			continue;
+		}
+		const nested = pickPaths(value[head], [rest.join(".")]);
+		out[head] = isPlainObject(out[head]) ? {
+			...out[head],
+			...nested
+		} : nested;
+	}
+	return out;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const NOT_READY = "The form is not ready yet. Try again shortly.";
+const CANCELLED = "The call was cancelled before it ran, so the form is unchanged and nothing was submitted.";
+const SETTLE_TIMEOUT_MS = 5e3;
+const SETTLE_POLL_MS = 10;
+async function bootstrapWebMcp(options, signal) {
+	const stateManager = inject(FormStateManager);
+	const eventBus = inject(EventBus);
+	const logger = inject(DynamicFormLogger);
+	const context = findModelContext();
+	if (!context) {
+		logger.debug("No WebMCP model context on this page; the form is not exposed to agents.");
+		return "unsupported";
+	}
+	const defaultMessages = untracked(() => stateManager.activeConfig()?.defaultValidationMessages);
+	const setup = untracked(() => stateManager.formSetup());
+	const plan = buildFieldPlan(setup?.schemaFields ?? [], setup?.registry ?? /* @__PURE__ */ new Map(), (message) => logger.warn(message));
+	const inputSchema = buildToolSchema(plan);
+	const scope = options.readback === "all" ? "all" : "changed";
+	const annotations = { untrustedContentHint: true };
+	const descriptors = [{
+		name: `fill_${options.name}`,
+		description: `Fill the "${options.name}" form: ${options.description} Accepts any subset of fields and leaves the rest untouched; a nested group is merged key by key, a list is replaced whole. Does not submit. Returns the values it set, which fields currently apply, which are still empty, and any validation errors. Call with no fields to see which apply, which are required and which are still empty, without changing anything.`,
+		inputSchema,
+		annotations,
+		execute: (args, execution) => fill(args, invocationSignal(execution))
+	}];
+	if (options.allowSubmit) {
+		const reportsOutcome = untracked(() => stateManager.activeConfig()?.submission?.action) !== void 0;
+		descriptors.push({
+			name: `submit_${options.name}`,
+			description: `Submit the "${options.name}" form: ${options.description} Applies any fields given, then submits and waits for the result. If validation fails nothing is submitted and the errors are returned; the values still remain in the form for correction. ` + (reportsOutcome ? `Reports whether the submission succeeded, was rejected by the server, or failed.` : `This page handles submission itself, so a successful call confirms the form was submitted but cannot report what came of it.`),
+			inputSchema,
+			annotations: {
+				...annotations,
+				consequentialHint: true
+			},
+			execute: (args, execution) => submitForm(args, invocationSignal(execution))
+		});
+	}
+	const failures = [];
+	for (const descriptor of descriptors) {
+		if (isOverNameBudget(descriptor.name)) logger.warn(`WebMCP tool name "${descriptor.name}" is longer than the ~30 characters agents can comfortably scan. A shorter \`webMcp.name\` reads better in a tool list.`);
+		const result = await registerTool(context, descriptor, signal);
+		if (!result.ok) failures.push(`${descriptor.name}: ${result.reason}`);
+	}
+	if (signal.aborted) return "idle";
+	if (failures.length) {
+		logger.error(`WebMCP tool registration failed. ${failures.join(" ")}`);
+		return "failed";
+	}
+	return "active";
+	async function fill(args, invocation) {
+		const tree = untracked(() => stateManager.form());
+		if (!tree) return NOT_READY;
+		const applied = await apply(args, tree, invocation);
+		if ("rejection" in applied) return applied.rejection;
+		return renderFormReport(applied.report);
+	}
+	async function submitForm(args, invocation) {
+		const tree = untracked(() => stateManager.form());
+		if (!tree) return NOT_READY;
+		const applied = await apply(args, tree, invocation);
+		if ("rejection" in applied) return applied.rejection;
+		const report = applied.report;
+		if (report.errors.length || report.validationPending) return renderSubmitResult({ status: report.validationPending ? "pending-validation" : "validation-failed" }, report);
+		return renderSubmitResult(await dispatchSubmit(invocation), reportNow(tree, report.changed));
+	}
+	function reportNow(tree, changed) {
+		return buildReport(tree, untracked(() => collectFieldReports(plan, tree)), changed, untracked(() => tree().pending()));
+	}
+	async function dispatchSubmit(invocation) {
+		const pending = createPendingSubmission();
+		if (signal.aborted || invocation?.aborted) return { status: "cancelled" };
+		const cancel = () => pending.cancel();
+		signal.addEventListener("abort", cancel, { once: true });
+		invocation?.addEventListener("abort", cancel, { once: true });
+		try {
+			eventBus.dispatch(new FormSubmitEvent(pending.reply));
+			if (!pending.accepted()) return { status: "busy" };
+			return await pending.outcome;
+		} finally {
+			signal.removeEventListener("abort", cancel);
+			invocation?.removeEventListener("abort", cancel);
+		}
+	}
+	async function apply(args, tree, invocation) {
+		if (signal.aborted || invocation?.aborted) return { rejection: CANCELLED };
+		const before = untracked(() => collectFieldReports(plan, tree));
+		const parsed = parseAgentInput(plan, args, (path) => liveBlock(before, path), untracked(() => stateManager.formValue()));
+		if (!parsed.ok) return { rejection: renderRejection(parsed.errors) };
+		const changed = parsed.paths;
+		if (changed.length) stateManager.entity.update((current) => mergePatch(current ?? {}, parsed.patch, plan));
+		const validationPending = changed.length ? await settle(tree, invocation) : untracked(() => tree().pending());
+		return { report: buildReport(tree, untracked(() => collectFieldReports(plan, tree)), changed, validationPending) };
+	}
+	function buildReport(tree, walk, changed, validationPending) {
+		const readable = redactValues(untracked(() => stateManager.formValue()), plan);
+		return {
+			values: scope === "all" ? readable : pickPaths(readable, changed),
+			fields: walk.reports,
+			errors: toErrorReports(untracked(() => tree().errorSummary()), walk.paths, walk.messages, defaultMessages),
+			changed,
+			validationPending,
+			scope
+		};
+	}
+	function liveBlock(walk, path) {
+		const state = walk.state.get(path);
+		if (state?.disabled) return "the form has disabled it";
+		if (state?.readonly) return "the form has made it read-only";
+	}
+	async function settle(tree, invocation) {
+		const deadline = Date.now() + SETTLE_TIMEOUT_MS;
+		await nextTask();
+		while (untracked(() => tree().pending())) {
+			if (Date.now() >= deadline || signal.aborted || invocation?.aborted) return true;
+			await nextTask(SETTLE_POLL_MS);
+		}
+		return false;
+	}
+}
+function invocationSignal(execution) {
+	return execution?.signal instanceof AbortSignal ? execution.signal : void 0;
+}
+function nextTask(delayMs = 0) {
+	return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+export { bootstrapWebMcp };
+
+//# sourceMappingURL=ng-forge-dynamic-forms-bootstrap-web-mcp-2wQK_wPp.mjs.map