@plitzi/sdk-server 0.32.4 → 0.32.6

package/dist/modules/mcp/catalogs/builtinTransformers.js

@@ -0,0 +1,148 @@
+//#region src/modules/mcp/catalogs/builtinTransformers.ts
+var boolParam = (description, dflt) => ({
+	type: "select",
+	description,
+	default: dflt,
+	options: ["true", "false"]
+});
+var BUILTIN_TRANSFORMERS = {
+	twigTemplate: {
+		title: "Twig Template",
+		description: "Render a Twig template around the bound value — the way to format/wrap a value (add units, compose a label). The incoming value is the token {{source}} (NOT {{value}}); {{sourceTo}} is the field’s previous value, and other data-source tokens are in scope too.",
+		strictParams: true,
+		params: { template: {
+			type: "textarea",
+			required: true,
+			description: "The Twig template string. Reference the incoming value as {{source}} — e.g. \"{{source}} min de cocción\". There is NO {{value}} token; {{sourceTo}} is the field’s original value."
+		} }
+	},
+	dateConverter: {
+		title: "Date Converter",
+		description: "Format a date/timestamp value. Reads a unix-seconds number (isUnix) or a parseable date string and outputs a formatted date, or a relative \"x ago\" string (asAge).",
+		strictParams: true,
+		params: {
+			format: {
+				type: "text",
+				default: "dd/MM/yyyy",
+				description: "date-fns format pattern, e.g. \"dd/MM/yyyy\" or \"PPpp\". Ignored when asAge is true."
+			},
+			asAge: boolParam("Output a relative \"x ago\" string instead of a formatted date.", "false"),
+			isUnix: boolParam("The source value is a unix timestamp in SECONDS (not milliseconds).", "true"),
+			isUtc: boolParam("Format in UTC instead of local time.", "false"),
+			locale: {
+				type: "select",
+				default: "en",
+				options: [
+					"en",
+					"es",
+					"pt"
+				],
+				description: "Locale for month/day names and relative text."
+			}
+		}
+	},
+	capitalize: {
+		title: "Capitalize",
+		description: "Capitalize the first letter of a string value. Takes no params.",
+		strictParams: true,
+		params: {}
+	},
+	staticValue: {
+		title: "Static Value",
+		description: "Ignore the source and emit a fixed value — use to hard-code a bound field. With valueType \"select\" the value is coerced to a boolean (\"true\"→true).",
+		strictParams: true,
+		params: {
+			valueType: {
+				type: "select",
+				default: "text",
+				options: [
+					"text",
+					"textarea",
+					"select"
+				],
+				description: "How `value` is interpreted: \"text\"/\"textarea\" → string, \"select\" → boolean (\"true\"/\"false\")."
+			},
+			value: {
+				type: "text",
+				description: "The constant value to emit (a string; \"true\"/\"false\" when valueType is select)."
+			}
+		}
+	},
+	arrayMap: {
+		title: "Array Map",
+		description: "Reshape each object of a source array by remapping keys — pick/rename fields for a list. Input must be an array; a non-array passes through unchanged.",
+		strictParams: true,
+		params: { keys: {
+			type: "textarea",
+			required: true,
+			default: "[{\"from\": \"\", \"to\": \"\"}]",
+			description: "A JSON array of { \"from\": <source path>, \"to\": <output key> } mappings, e.g. [{\"from\":\"title\",\"to\":\"label\"},{\"from\":\"id\",\"to\":\"value\"}]."
+		} }
+	},
+	stringToArray: {
+		title: "Text to List",
+		description: "Split a string into an array on a separator (each item trimmed). A non-string passes through unchanged.",
+		strictParams: true,
+		params: { separator: {
+			type: "text",
+			default: ",",
+			description: "The delimiter to split on, e.g. \",\" or \"|\"."
+		} }
+	},
+	styleSelector: {
+		title: "Style Selector",
+		description: "Compute a style-class selector from data — bind a `style` target to switch an element’s class at runtime. Builder-oriented (its `selector` options come from the style schema); prefer style variants for most cases.",
+		strictParams: true,
+		params: {
+			append: boolParam("Append `selector` to the existing selector instead of replacing it.", "false"),
+			originalSelector: boolParam("When appending, keep the element’s original base selector (requires append).", "false"),
+			selector: {
+				type: "text",
+				description: "The class-selector name to apply (a class from the style schema)."
+			}
+		}
+	},
+	styleVariant: {
+		title: "Style Variant",
+		description: "Compute an applied style-variant map from data — bind an `initialState` target to switch a variant at runtime. Builder-oriented (key/variant options come from the element’s style schema); prefer static variants for most cases.",
+		strictParams: true,
+		params: {
+			key: {
+				type: "text",
+				description: "The selector key to target, e.g. \"<type>.base\"."
+			},
+			variant: {
+				type: "text",
+				description: "The variant name to apply under `key`."
+			},
+			append: boolParam("Merge with the existing variant map instead of replacing it.", "false")
+		}
+	}
+};
+/** The built-in transformer for an action, or undefined when the action is not a known built-in transformer. */
+var getTransformer = (action) => Object.hasOwn(BUILTIN_TRANSFORMERS, action) ? BUILTIN_TRANSFORMERS[action] : void 0;
+/** The closest known transformer action to a mistyped one (substring match either way), so a wrong action like
+*  "template" teaches "twigTemplate". Undefined when nothing is close. */
+var suggestTransformer = (action) => {
+	const needle = action.toLowerCase();
+	return Object.keys(BUILTIN_TRANSFORMERS).find((name) => {
+		const known = name.toLowerCase();
+		return known.includes(needle) || needle.includes(known);
+	});
+};
+/** The transformer catalog projected for the data-sources resource / primer, so the agent knows the exact action
+*  names and params up front (the real fix for the "agent can't write transformers" problem). */
+var transformerCatalog = () => Object.entries(BUILTIN_TRANSFORMERS).map(([action, { title, description, params }]) => ({
+	action,
+	title,
+	description,
+	params: Object.entries(params).map(([name, spec]) => ({
+		name,
+		type: spec.type,
+		description: spec.description,
+		...spec.default !== void 0 ? { default: spec.default } : {},
+		...spec.options ? { options: spec.options } : {}
+	}))
+}));
+//#endregion
+export { BUILTIN_TRANSFORMERS, getTransformer, suggestTransformer, transformerCatalog };

package/dist/modules/mcp/catalogs/builtinUtilities.js

@@ -0,0 +1,90 @@
+import { reconcileParams } from "./paramSpec.js";
+//#region src/modules/mcp/catalogs/builtinUtilities.ts
+var BUILTIN_UTILITIES = {
+	delayTime: {
+		title: "Delay Time",
+		strictParams: true,
+		params: { time: {
+			type: "number",
+			description: "Milliseconds to wait before the next step runs. The key is \"time\" (not \"delay\")."
+		} }
+	},
+	twigTemplate: {
+		title: "Twig Template",
+		strictParams: true,
+		params: {
+			returnMode: {
+				type: "select",
+				description: "How the rendered template is returned.",
+				default: "text",
+				options: [
+					"text",
+					"json",
+					"jsonObject"
+				]
+			},
+			template: {
+				type: "textarea",
+				description: "The Twig template string to render against the flow/global params."
+			}
+		}
+	},
+	webHook: {
+		title: "Webhook",
+		strictParams: true,
+		params: {
+			url: {
+				type: "text",
+				description: "The URL to call."
+			},
+			method: {
+				type: "select",
+				description: "HTTP method.",
+				default: "get",
+				options: [
+					"get",
+					"post",
+					"put",
+					"delete",
+					"patch",
+					"head"
+				]
+			},
+			body: {
+				type: "textarea",
+				description: "Request body."
+			},
+			authorizationToken: {
+				type: "text",
+				description: "Value sent as the Authorization header."
+			},
+			credentials: {
+				type: "select",
+				description: "fetch credentials mode.",
+				default: "same-origin",
+				options: [
+					"include",
+					"omit",
+					"same-origin"
+				]
+			}
+		}
+	}
+};
+/** The built-in utility for an action, or undefined when the action is not a known built-in utility. */
+var getUtility = (action) => Object.hasOwn(BUILTIN_UTILITIES, action) ? BUILTIN_UTILITIES[action] : void 0;
+/** Reconcile a `utility` action against the utility catalog: unknown keys dropped for a closed utility, then missing
+*  defaults filled. An unknown action yields unchanged params. */
+var applyUtility = (action, params) => {
+	const utility = getUtility(action);
+	if (!utility) return {
+		known: false,
+		params
+	};
+	return {
+		known: true,
+		params: reconcileParams(params, utility.params, utility.strictParams)
+	};
+};
+//#endregion
+export { BUILTIN_UTILITIES, applyUtility, getUtility };

package/dist/modules/mcp/catalogs/cssCatalog.js

@@ -0,0 +1,205 @@
+import styleConstants from "@plitzi/sdk-shared/style/styleConstants";
+//#region src/modules/mcp/catalogs/cssCatalog.ts
+/** Every kebab-case CSS property Plitzi's style engine understands. Values written to a definition
+*  must use these exact keys — camelCase or unknown keys are rejected by the validator. */
+var cssProperties = Array.from(new Set(Object.values(styleConstants))).sort();
+var cssPropertySet = new Set(cssProperties);
+var isCssProperty = (key) => cssPropertySet.has(key);
+var toKebab = (key) => key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+/** If a camelCase key maps to a known kebab-case property, return it — used to teach the agent the correct key. */
+var suggestCssProperty = (key) => {
+	const kebab = toKebab(key);
+	return cssPropertySet.has(kebab) ? kebab : void 0;
+};
+var splitTokens = (value) => {
+	const tokens = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of value.trim()) {
+		if (ch === "(") depth += 1;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+		if (/\s/.test(ch) && depth === 0) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+		} else current += ch;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+};
+var COMPOUND_SHORTHANDS = {
+	flex: [
+		"flex-grow",
+		"flex-shrink",
+		"flex-basis"
+	],
+	"flex-flow": ["flex-direction", "flex-wrap"],
+	background: [
+		"background-color",
+		"background-image",
+		"background-position",
+		"background-size",
+		"background-repeat"
+	],
+	font: [
+		"font-family",
+		"font-size",
+		"font-weight",
+		"line-height"
+	],
+	transition: [
+		"transition-property",
+		"transition-duration",
+		"transition-timing-function",
+		"transition-delay"
+	],
+	animation: [
+		"animation-name",
+		"animation-duration",
+		"animation-timing-function",
+		"animation-delay",
+		"animation-iteration-count"
+	],
+	grid: [
+		"grid-template-columns",
+		"grid-template-rows",
+		"grid-template-areas"
+	],
+	"grid-template": [
+		"grid-template-columns",
+		"grid-template-rows",
+		"grid-template-areas"
+	],
+	"grid-area": [
+		"grid-row-start",
+		"grid-column-start",
+		"grid-row-end",
+		"grid-column-end"
+	],
+	"place-content": ["align-content", "justify-content"],
+	"place-items": ["align-items", "justify-items"],
+	"place-self": ["align-self", "justify-self"],
+	"list-style": [
+		"list-style-type",
+		"list-style-position",
+		"list-style-image"
+	],
+	"text-decoration": [
+		"text-decoration-line",
+		"text-decoration-color",
+		"text-decoration-style"
+	],
+	outline: [
+		"outline-width",
+		"outline-style",
+		"outline-color"
+	],
+	columns: ["column-width", "column-count"],
+	overflow: ["overflow-x", "overflow-y"]
+};
+/** The atomic longhands to write instead of a compound shorthand, or undefined when the key is not a compound
+*  shorthand. `flex` layout in particular is NOT `display` + `flex-direction` (those are their own properties). */
+var compoundLonghands = (key) => Object.hasOwn(COMPOUND_SHORTHANDS, key) ? COMPOUND_SHORTHANDS[key] : void 0;
+var SIDES = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+var box4 = (tokens) => {
+	const [a, b = a, c = a, d = b] = tokens;
+	return [
+		a,
+		b,
+		c,
+		d
+	];
+};
+var radius4 = (tokens) => {
+	const [a, b = a, c = a, d = b] = tokens;
+	return [
+		a,
+		b,
+		c,
+		d
+	];
+};
+var BORDER_STYLES = /* @__PURE__ */ new Set([
+	"none",
+	"hidden",
+	"dotted",
+	"dashed",
+	"solid",
+	"double",
+	"groove",
+	"ridge",
+	"inset",
+	"outset"
+]);
+var BORDER_WIDTH_KEYWORDS = /* @__PURE__ */ new Set([
+	"thin",
+	"medium",
+	"thick"
+]);
+var LENGTH_RE = /^-?[\d.]+([a-z%]*)$/;
+var classifyBorderToken = (token) => {
+	if (BORDER_STYLES.has(token)) return "style";
+	if (BORDER_WIDTH_KEYWORDS.has(token) || LENGTH_RE.test(token)) return "width";
+	return "color";
+};
+var expandBorder = (key, value, out) => {
+	const sides = key === "border" ? SIDES : [key.slice(7)];
+	for (const token of splitTokens(value)) {
+		const kind = classifyBorderToken(token);
+		for (const side of sides) out[`border-${side}-${kind}`] = token;
+	}
+};
+var BORDER_SIDE_KEYS = new Set(SIDES.map((s) => `border-${s}`));
+var expandOne = (key, raw, out) => {
+	const value = String(raw);
+	if (key === "padding" || key === "margin" || key === "inset") {
+		const [t, r, b, l] = box4(splitTokens(value));
+		const prefix = key === "inset" ? "" : `${key}-`;
+		out[`${prefix}top`] = t;
+		out[`${prefix}right`] = r;
+		out[`${prefix}bottom`] = b;
+		out[`${prefix}left`] = l;
+		return true;
+	}
+	if (key === "border-radius" && !value.includes("/")) {
+		const [tl, tr, br, bl] = radius4(splitTokens(value));
+		const corners = [
+			["top-left", tl],
+			["top-right", tr],
+			["bottom-right", br],
+			["bottom-left", bl]
+		];
+		for (const [corner, v] of corners) out[`border-${corner}-radius`] = v;
+		return true;
+	}
+	if (key === "gap") {
+		const [row, col = row] = splitTokens(value);
+		out["row-gap"] = row;
+		out["column-gap"] = col;
+		return true;
+	}
+	if (key === "border" || BORDER_SIDE_KEYS.has(key)) {
+		expandBorder(key, value, out);
+		return true;
+	}
+	return false;
+};
+/** Expand supported CSS shorthands to their longhand keys. Explicit longhands in the same map win over any
+*  expansion (so `{ padding: 8, padding-left: 0 }` keeps padding-left: 0). Unrecognized keys pass through. */
+var expandShorthand = (css) => {
+	const expanded = {};
+	const direct = {};
+	for (const [key, value] of Object.entries(css)) if (!expandOne(key, value, expanded)) direct[key] = value;
+	return {
+		...expanded,
+		...direct
+	};
+};
+//#endregion
+export { COMPOUND_SHORTHANDS, compoundLonghands, cssProperties, expandShorthand, isCssProperty, suggestCssProperty };

package/dist/modules/mcp/catalogs/observed.js

@@ -0,0 +1,90 @@
+import { BUILTIN_GLOBAL_CALLBACKS } from "./builtinCallbacks.js";
+import { BUILTIN_ELEMENT_CALLBACKS } from "./builtinElementCallbacks.js";
+import { BUILTIN_UTILITIES } from "./builtinUtilities.js";
+import { transformerCatalog } from "./builtinTransformers.js";
+//#region src/modules/mcp/catalogs/observed.ts
+var INTERACTION_NOTE = "Interaction actions observed on this space, grouped by node type. A flow is a trigger followed by ordered callbacks/utilities; write one with upsertInteractionFlow. Names not listed may still be valid plugin actions.";
+var GLOBAL_CALLBACKS_NOTE = "Built-in global callbacks always available in every space. A globalCallback is registered on its SOURCE MODULE, so its node `elementId` is the listed `source` (e.g. \"space\" for addNotification) — NOT the element that hosts the flow. Omit `elementId` and the MCP sets the right source and fills the param defaults for you. Use ONLY the params listed under each callback (with the exact spelling shown) — for addNotification the visible text goes in `content`; there is no title/message/type param. When strictParams is true, any other key is rejected.";
+var ELEMENT_CALLBACKS_NOTE = "Built-in `callback`-type actions every element registers on ITSELF. Unlike a globalCallback, an element callback runs against a real element, so its node `elementId` is that element (the flow host by default, or another element to act on) and its nodeType is \"callback\". `setState` here changes the element's own attribute/state (params category/key/value/revertOnFinish) — NOT the global state setState (which is a globalCallback on source \"state\" with params key/type/value). Set revertOnFinish:true for a TEMPORARY change (e.g. a \"loading…\" label): it is undone automatically when the flow finishes, so you do NOT add manual restore steps. A specific element type may register more callbacks beyond these defaults.";
+var UTILITIES_NOTE = "Built-in `utility`-type actions (no element/source module). Use nodeType \"utility\". Use the EXACT param names — e.g. delayTime waits `time` milliseconds (not `delay`).";
+var toParamInfo = (params) => Object.entries(params).map(([name, spec]) => ({
+	name,
+	type: spec.type,
+	description: spec.description,
+	...spec.default !== void 0 ? { default: spec.default } : {},
+	...spec.options ? { options: spec.options } : {},
+	...spec.when ? { conditional: true } : {}
+}));
+var builtinGlobalCallbacks = () => Object.entries(BUILTIN_GLOBAL_CALLBACKS).map(([action, { source, title, strictParams, params }]) => ({
+	action,
+	source,
+	title,
+	strictParams,
+	params: toParamInfo(params)
+}));
+var builtinElementCallbacks = () => Object.entries(BUILTIN_ELEMENT_CALLBACKS).map(([action, { title, strictParams, params }]) => ({
+	action,
+	title,
+	strictParams,
+	params: toParamInfo(params)
+}));
+var builtinUtilities = () => Object.entries(BUILTIN_UTILITIES).map(([action, { title, strictParams, params }]) => ({
+	action,
+	title,
+	strictParams,
+	params: toParamInfo(params)
+}));
+var DATA_SOURCE_NOTE = "Data-source paths and binding targets observed on this space. Bind a source to an element field with upsertBinding (category attributes|style|initialState). Paths not listed may still be valid. A binding may post-process its value through `transformers` (see below) and be gated by a `when` QueryBuilder guard.";
+var DATA_SOURCE_SCOPE_NOTE = "SCOPE: an element source named `<type>_<idRef>` (e.g. `apiContainer_products`, `list_food-list`) is provided by that element to its DESCENDANTS ONLY — the provider wraps its subtree in the source’s scope, so only elements INSIDE the provider can bind to it. Binding a sibling or unrelated element to it is schema-valid but broken at runtime (the source is not in scope), and validate/apply REJECT it as an error. To consume `apiContainer_x.data`, the bound element must live under that apiContainer. Module sources (no `<type>_<idRef>` head — e.g. state/space/navigation/auth/collection) are global and bindable anywhere.";
+var TRANSFORMERS_NOTE = "Built-in transformers that post-process a binding value before it reaches the field: `source → t₁ → t₂ → field`. Set them on a binding as `transformers: [{ action, params }]` (params are strings). The runtime resolves each by its `action` alone, so an UNKNOWN action is silently skipped (the value passes through unchanged) — use the exact action names below. Common formatting is `twigTemplate` (the value is the {{source}} token, not {{value}}).";
+var buildInteractionCatalog = (schema) => {
+	const actions = {};
+	const flows = /* @__PURE__ */ new Set();
+	for (const el of Object.values(schema.flat)) for (const node of Object.values(el.definition.interactions ?? {})) {
+		(actions[node.type] ??= /* @__PURE__ */ new Set()).add(node.action);
+		flows.add(node.flowId || node.id);
+	}
+	const grouped = {};
+	for (const [nodeType, set] of Object.entries(actions)) grouped[nodeType] = [...set].sort();
+	return {
+		note: INTERACTION_NOTE,
+		actions: grouped,
+		globalCallbacksNote: GLOBAL_CALLBACKS_NOTE,
+		globalCallbacks: builtinGlobalCallbacks(),
+		elementCallbacksNote: ELEMENT_CALLBACKS_NOTE,
+		elementCallbacks: builtinElementCallbacks(),
+		utilitiesNote: UTILITIES_NOTE,
+		utilities: builtinUtilities(),
+		flowCount: flows.size
+	};
+};
+var buildDataSourceCatalog = (schema) => {
+	const sources = /* @__PURE__ */ new Set();
+	const targets = {};
+	for (const el of Object.values(schema.flat)) for (const [category, list] of Object.entries(el.definition.bindings ?? {})) for (const binding of list) {
+		sources.add(binding.source);
+		(targets[category] ??= /* @__PURE__ */ new Set()).add(binding.to);
+	}
+	const groupedTargets = {};
+	for (const [category, set] of Object.entries(targets)) groupedTargets[category] = [...set].sort();
+	return {
+		note: DATA_SOURCE_NOTE,
+		scopeNote: DATA_SOURCE_SCOPE_NOTE,
+		sources: [...sources].sort(),
+		targets: groupedTargets,
+		transformersNote: TRANSFORMERS_NOTE,
+		transformers: transformerCatalog()
+	};
+};
+var observedInteractionActions = (schema) => {
+	const actions = /* @__PURE__ */ new Set();
+	for (const el of Object.values(schema.flat)) for (const node of Object.values(el.definition.interactions ?? {})) actions.add(node.action);
+	return actions;
+};
+var observedDataSources = (schema) => {
+	const sources = /* @__PURE__ */ new Set();
+	for (const el of Object.values(schema.flat)) for (const list of Object.values(el.definition.bindings ?? {})) for (const binding of list) sources.add(binding.source);
+	return sources;
+};
+//#endregion
+export { buildDataSourceCatalog, buildInteractionCatalog, observedDataSources, observedInteractionActions };

package/dist/modules/mcp/catalogs/paramSpec.js

@@ -0,0 +1,69 @@
+import { hasValidToken } from "@plitzi/sdk-shared/helpers/twigWrapper";
+//#region src/modules/mcp/catalogs/paramSpec.ts
+/** Declared params the agent supplied that end up HIDDEN because their own `when` guard is false against the
+*  effective params — they are silently ignored (e.g. a global setState `value` with no `type`, or an
+*  addNotification `autoDismissTimeout` with autoDismiss:false). Evaluated against the effective params so a param
+*  the default fills in (e.g. category:"attribute") does not false-report a value as hidden. */
+var hiddenParams = (provided, effective, spec) => {
+	const hidden = [];
+	for (const [key, param] of Object.entries(spec)) if (param.when && provided[key] !== void 0 && !param.when(effective)) hidden.push(key);
+	return hidden;
+};
+/** Declared params marked `required` that the agent did NOT supply, and whose `when` guard holds against the
+*  effective params (so they are actually in play). Evaluated against the effective params so a required param
+*  gated by a companion (e.g. setState `value`, shown only once `category` is set) is not reported when its guard
+*  is not met. */
+var missingRequiredParams = (provided, effective, spec) => {
+	const missing = [];
+	for (const [key, param] of Object.entries(spec)) if (param.required && provided[key] === void 0 && (!param.when || param.when(effective))) missing.push(key);
+	return missing;
+};
+var isNumeric = (value) => value.trim() !== "" && Number.isFinite(Number(value));
+var isBindingToken = (value) => typeof value === "string" && hasValidToken(value);
+var matchesType = (value, param) => {
+	switch (param.type) {
+		case "boolean": return typeof value === "boolean";
+		case "number": return typeof value === "number" || typeof value === "string" && isNumeric(value);
+		case "select": return typeof value === "string" && (!param.options || param.options.includes(value));
+		case "scalar": return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+		case "text":
+		case "textarea": return typeof value === "string";
+		default: return true;
+	}
+};
+/** Declared params the agent supplied whose value is the WRONG type for the catalog — the check that catches a
+*  malformed node the unknown/missing/hidden checks miss (a boolean stored as a string, a select value not in its
+*  options, a leftover `null`). Only params actually in play are checked: undefined values (the param is absent) and
+*  params hidden by their own `when` guard against the effective params are skipped, so this never fires on a param
+*  that is not really used. Callers gate this to CLOSED (strict) catalogs, whose types we own authoritatively. */
+var invalidParams = (provided, effective, spec) => {
+	const invalid = [];
+	for (const [key, param] of Object.entries(spec)) {
+		const value = provided[key];
+		if (value === void 0 || isBindingToken(value) || param.when && !param.when(effective)) continue;
+		if (!matchesType(value, param)) invalid.push({
+			key,
+			expected: param.type,
+			got: value === null ? "null" : typeof value,
+			...param.options ? { options: param.options } : {}
+		});
+	}
+	return invalid;
+};
+/** Reconcile supplied params to a catalog schema: drop unknown keys when the set is CLOSED (strict), then fill the
+*  builder's defaults for any declared param the agent omitted whose `when` guard holds. Mirrors what the builder
+*  stores, so the persisted node round-trips cleanly. */
+var reconcileParams = (params, spec, strict) => {
+	const next = {};
+	for (const [key, value] of Object.entries(params)) {
+		if (strict && !(key in spec)) continue;
+		next[key] = value;
+	}
+	for (const [key, param] of Object.entries(spec)) {
+		if (param.default === void 0 || next[key] !== void 0 || param.when && !param.when(next)) continue;
+		next[key] = param.default;
+	}
+	return next;
+};
+//#endregion
+export { hiddenParams, invalidParams, missingRequiredParams, reconcileParams };