@ng-forge/dynamic-form-mcp 1.3.0-next.4 → 1.3.0

package/bin/ng-forge-mcp.js

@@ -86,7 +86,7 @@ var FIELD_TYPES = [
       multiple: {
         name: "multiple",
         type: "boolean",
-        description: "Allow multiple selections",
+        description: "Allow multiple selections. The value becomes an array of the selected values",
         required: false,
         default: false
       }
@@ -3218,6 +3218,8 @@ Evaluates a JavaScript expression with access to \`formValue\`, \`fieldValue\`,
 }
 \`\`\`
 
+**Expression syntax** (javascript conditions and derivations): property access with \`?.\`, arithmetic, comparisons, \`&&\`, \`||\`, \`!\`, \`??\`, ternaries, array and object literals, and arrow functions as method arguments (\`formValue.items.some(i => i.done)\`). Mixing \`??\` with \`&&\` or \`||\` needs parentheses, as in JavaScript. Methods are limited to safe string, number, array and date methods (\`toFixed\`, \`includes\`, \`map\`, \`getFullYear\`, ...). There are no statements, no \`new\`, no direct function calls (\`parseInt(x)\`, \`String(x)\`) and no globals (\`Math\`, \`Date\`, \`JSON\`): an unknown name reads as \`undefined\`. Use a number input (\`props: { type: 'number' }\`) instead of parsing, and a custom function for anything else. The validator (MCP or CLI) reports an expression that breaks these rules, with its path, under \`core/expression-syntax\`, and in dev mode the library warns about it at startup.
+
 **Condition scoping:** in logic conditions, \`formValue\` is the whole form value regardless of where the field sits, except inside array items where it is scoped to the current item (use \`rootFormValue\` for the rest of the form). Reference group-nested fields by their full path, e.g. \`formValue.person.firstName\`. Note that \`derivation\` expressions scope differently: there \`formValue\` is also scoped to the parent group for group-nested fields.
 
 #### Custom Condition
@@ -3288,6 +3290,8 @@ Combine conditions with \`and\` (all must be true) or \`or\` (at least one must
 }
 \`\`\`
 
+An empty \`conditions\` array evaluates to false, so an empty group never fires. Dev mode warns about it at startup.
+
 ## UI Library Integration
 
 ng-forge supports multiple UI libraries. Configure in \`app.config.ts\`:
@@ -5408,7 +5412,7 @@ var BaseFormConfigSchema = z19.object({
 });
 
 // internal/dynamic-forms-validation/validate/src/json-schema/form-config-json-schema.ts
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 
 // internal/dynamic-forms-validation/material/src/props/mat-common-props.schema.ts
 import { z as z20 } from "zod";
@@ -5731,17 +5735,43 @@ var MatButtonPropsSchema = z30.object({
 });
 
 // internal/dynamic-forms-validation/material/src/fields/mat-input-field.schema.ts
+import { z as z32 } from "zod";
+
+// internal/dynamic-forms-validation/src/lib/schemas/field/input-value.schema.ts
 import { z as z31 } from "zod";
+var InputValueSchema = z31.union([z31.string(), z31.number()]).nullable().optional();
+var inputValueTypeRefine = (data, ctx) => {
+  if (!data || typeof data !== "object") return;
+  const field = data;
+  if (field.type !== "input") return;
+  const numeric = field.props?.type === "number";
+  if (typeof field.value === "number" && !numeric) {
+    ctx.addIssue({
+      code: z31.ZodIssueCode.custom,
+      path: ["value"],
+      message: "A number value needs `props: { type: 'number' }`. Other input types hold strings."
+    });
+  }
+  if (typeof field.value === "string" && numeric) {
+    ctx.addIssue({
+      code: z31.ZodIssueCode.custom,
+      path: ["value"],
+      message: "An input with `props: { type: 'number' }` holds a number, not a string."
+    });
+  }
+};
+
+// internal/dynamic-forms-validation/material/src/fields/mat-input-field.schema.ts
 var MatInputFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z31.literal("input"),
-  nullable: z31.boolean().optional(),
+  type: z32.literal("input"),
+  nullable: z32.boolean().optional(),
   /**
    * Initial value for the input.
    */
-  value: z31.string().nullable().optional(),
+  value: InputValueSchema,
   /**
    * Placeholder text (can also be in props).
    */
@@ -5751,20 +5781,20 @@ var MatInputFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSche
    */
   props: MatInputPropsSchema.optional()
 });
-var MatInputFieldSchema = MatInputFieldSchemaObject.superRefine(nullableValueRefine);
+var MatInputFieldSchema = MatInputFieldSchemaObject.superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-textarea-field.schema.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var MatTextareaFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z32.literal("textarea"),
-  nullable: z32.boolean().optional(),
+  type: z33.literal("textarea"),
+  nullable: z33.boolean().optional(),
   /**
    * Initial value for the textarea.
    */
-  value: z32.string().nullable().optional(),
+  value: z33.string().nullable().optional(),
   /**
    * Placeholder text (can also be in props).
    */
@@ -5777,18 +5807,18 @@ var MatTextareaFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationS
 var MatTextareaFieldSchema = MatTextareaFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-select-field.schema.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var MatSelectFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z33.literal("select"),
-  nullable: z33.boolean().optional(),
+  type: z34.literal("select"),
+  nullable: z34.boolean().optional(),
   /**
    * Initial value for the select.
    * Can be single value or array if multiple is enabled.
    */
-  value: z33.unknown().nullable().optional(),
+  value: z34.unknown().nullable().optional(),
   /**
    * Placeholder text (can also be in props).
    */
@@ -5805,16 +5835,16 @@ var MatSelectFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSch
 var MatSelectFieldSchema = MatSelectFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-checkbox-field.schema.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var MatCheckboxFieldSchema = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z34.literal("checkbox"),
+  type: z35.literal("checkbox"),
   /**
    * Initial checked state.
    */
-  value: z34.boolean().optional(),
+  value: z35.boolean().optional(),
   /**
    * Placeholder/helper text.
    */
@@ -5826,17 +5856,17 @@ var MatCheckboxFieldSchema = BaseFieldDefSchema.merge(FieldWithValidationSchema)
 });
 
 // internal/dynamic-forms-validation/material/src/fields/mat-radio-field.schema.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var MatRadioFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z35.literal("radio"),
-  nullable: z35.boolean().optional(),
+  type: z36.literal("radio"),
+  nullable: z36.boolean().optional(),
   /**
    * Initial selected value.
    */
-  value: z35.unknown().nullable().optional(),
+  value: z36.unknown().nullable().optional(),
   /**
    * Placeholder/helper text.
    */
@@ -5853,17 +5883,17 @@ var MatRadioFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSche
 var MatRadioFieldSchema = MatRadioFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-multi-checkbox-field.schema.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var MatMultiCheckboxFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z36.literal("multi-checkbox"),
-  nullable: z36.boolean().optional(),
+  type: z37.literal("multi-checkbox"),
+  nullable: z37.boolean().optional(),
   /**
    * Initial selected values (array).
    */
-  value: z36.array(z36.unknown()).nullable().optional(),
+  value: z37.array(z37.unknown()).nullable().optional(),
   /**
    * Placeholder/helper text.
    */
@@ -5880,16 +5910,16 @@ var MatMultiCheckboxFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValida
 var MatMultiCheckboxFieldSchema = MatMultiCheckboxFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-toggle-field.schema.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var MatToggleFieldSchema = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z37.literal("toggle"),
+  type: z38.literal("toggle"),
   /**
    * Initial toggle state.
    */
-  value: z37.boolean().optional(),
+  value: z38.boolean().optional(),
   /**
    * Placeholder/helper text.
    */
@@ -5901,29 +5931,36 @@ var MatToggleFieldSchema = BaseFieldDefSchema.merge(FieldWithValidationSchema).e
 });
 
 // internal/dynamic-forms-validation/material/src/fields/mat-slider-field.schema.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
+
+// internal/dynamic-forms-validation/src/lib/schemas/field/multi-value.schema.ts
+import { z as z39 } from "zod";
+var SliderValueSchema = z39.union([z39.number(), z39.array(z39.number()), z39.object({ lower: z39.number(), upper: z39.number() })]).nullable().optional();
+var DatepickerValueSchema = z39.union([z39.string(), z39.array(z39.string())]).nullable().optional();
+
+// internal/dynamic-forms-validation/material/src/fields/mat-slider-field.schema.ts
 var MatSliderFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z38.literal("slider"),
-  nullable: z38.boolean().optional(),
+  type: z40.literal("slider"),
+  nullable: z40.boolean().optional(),
   /**
    * Initial slider value.
    */
-  value: z38.number().nullable().optional(),
+  value: SliderValueSchema,
   /**
    * Minimum slider value.
    */
-  minValue: z38.number().optional(),
+  minValue: z40.number().optional(),
   /**
    * Maximum slider value.
    */
-  maxValue: z38.number().optional(),
+  maxValue: z40.number().optional(),
   /**
    * Step increment.
    */
-  step: z38.number().positive().optional(),
+  step: z40.number().positive().optional(),
   /**
    * Placeholder/helper text.
    */
@@ -5936,18 +5973,18 @@ var MatSliderFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSch
 var MatSliderFieldSchema = MatSliderFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-datepicker-field.schema.ts
-import { z as z39 } from "zod";
-var DateValueSchema = z39.union([z39.string(), z39.null()]);
+import { z as z41 } from "zod";
+var DateValueSchema = z41.union([z41.string(), z41.null()]);
 var MatDatepickerFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidationSchema).extend({
   /**
    * Field type discriminant.
    */
-  type: z39.literal("datepicker"),
-  nullable: z39.boolean().optional(),
+  type: z41.literal("datepicker"),
+  nullable: z41.boolean().optional(),
   /**
    * Initial date value (ISO string in JSON configs).
    */
-  value: DateValueSchema.nullable().optional(),
+  value: DatepickerValueSchema,
   /**
    * Minimum selectable date.
    */
@@ -5972,29 +6009,29 @@ var MatDatepickerFieldSchemaObject = BaseFieldDefSchema.merge(FieldWithValidatio
 var MatDatepickerFieldSchema = MatDatepickerFieldSchemaObject.superRefine(nullableValueRefine);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-button-field.schema.ts
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 
 // internal/dynamic-forms-validation/src/lib/schemas/field/array-item-template.schema.ts
-import { z as z40 } from "zod";
-var FieldLikeSchema = z40.object({ type: z40.string() }).passthrough();
-var ArrayItemTemplateSchema = z40.union([FieldLikeSchema, z40.array(FieldLikeSchema)]);
+import { z as z42 } from "zod";
+var FieldLikeSchema = z42.object({ type: z42.string() }).passthrough();
+var ArrayItemTemplateSchema = z42.union([FieldLikeSchema, z42.array(FieldLikeSchema)]);
 
 // internal/dynamic-forms-validation/material/src/fields/mat-button-field.schema.ts
-var EventArgSchema = z41.union([z41.string(), z41.number(), z41.boolean(), z41.null(), z41.undefined()]);
+var EventArgSchema = z43.union([z43.string(), z43.number(), z43.boolean(), z43.null(), z43.undefined()]);
 var MatButtonFieldSchema = BaseFieldDefSchema.extend({
   /**
    * Field type discriminant.
    */
-  type: z41.literal("button"),
+  type: z43.literal("button"),
   /**
    * Event type name (string reference to registered event).
    * Note: Full event configuration requires runtime setup.
    */
-  event: z41.string().optional(),
+  event: z43.string().optional(),
   /**
    * Arguments passed to the event constructor.
    */
-  eventArgs: z41.array(EventArgSchema).optional(),
+  eventArgs: z43.array(EventArgSchema).optional(),
   /**
    * Material-specific button properties.
    */
@@ -6005,17 +6042,17 @@ var MatButtonFieldSchema = BaseFieldDefSchema.extend({
   logic: LogicArraySchema.optional()
 });
 var MatSubmitButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("submit"),
+  type: z43.literal("submit"),
   props: MatButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var MatNextButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("next"),
+  type: z43.literal("next"),
   props: MatButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var MatPreviousButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("previous"),
+  type: z43.literal("previous"),
   props: MatButtonPropsSchema.optional()
 });
 var MatAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6024,21 +6061,21 @@ var MatAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z41.literal("add-array-item"),
+  type: z43.literal("add-array-item"),
   /**
    * Key of the array field to add items to.
    * If omitted, uses the parent array context.
    */
-  arrayKey: z41.string().optional(),
+  arrayKey: z43.string().optional(),
   props: MatButtonPropsSchema.optional()
 });
 var MatRemoveArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("remove-array-item"),
+  type: z43.literal("remove-array-item"),
   /**
    * Key of the array field to remove items from.
    * If omitted, uses the parent array context.
    */
-  arrayKey: z41.string().optional(),
+  arrayKey: z43.string().optional(),
   props: MatButtonPropsSchema.optional()
 });
 var MatPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6047,12 +6084,12 @@ var MatPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z41.literal("prepend-array-item"),
+  type: z43.literal("prepend-array-item"),
   /**
    * Key of the array field to prepend items to.
    * If omitted, uses the parent array context.
    */
-  arrayKey: z41.string().optional(),
+  arrayKey: z43.string().optional(),
   props: MatButtonPropsSchema.optional()
 });
 var MatInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6061,38 +6098,38 @@ var MatInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z41.literal("insert-array-item"),
+  type: z43.literal("insert-array-item"),
   /**
    * Key of the array field to insert items into.
    * If omitted, uses the parent array context.
    */
-  arrayKey: z41.string().optional(),
+  arrayKey: z43.string().optional(),
   /**
    * Index at which to insert the new item.
    */
-  index: z41.number(),
+  index: z43.number(),
   props: MatButtonPropsSchema.optional()
 });
 var MatPopArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("pop-array-item"),
+  type: z43.literal("pop-array-item"),
   /**
    * Key of the array field to pop items from.
    */
-  arrayKey: z41.string(),
+  arrayKey: z43.string(),
   props: MatButtonPropsSchema.optional()
 });
 var MatShiftArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z41.literal("shift-array-item"),
+  type: z43.literal("shift-array-item"),
   /**
    * Key of the array field to shift items from.
    */
-  arrayKey: z41.string(),
+  arrayKey: z43.string(),
   props: MatButtonPropsSchema.optional()
 });
 
 // internal/dynamic-forms-validation/material/src/mat-leaf-field.schema.ts
-import { z as z42 } from "zod";
-var MatLeafFieldSchema = z42.discriminatedUnion("type", [
+import { z as z44 } from "zod";
+var MatLeafFieldSchema = z44.discriminatedUnion("type", [
   // Default fields
   TextFieldSchema,
   HiddenFieldSchema,
@@ -6117,7 +6154,7 @@ var MatLeafFieldSchema = z42.discriminatedUnion("type", [
   MatInsertArrayItemButtonFieldSchema,
   MatPopArrayItemButtonFieldSchema,
   MatShiftArrayItemButtonFieldSchema
-]).superRefine(nullableValueRefine);
+]).superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 
 // internal/dynamic-forms-validation/material/src/mat-field.schema.ts
 var containerSchemas = createContainerSchemas({
@@ -6130,8 +6167,8 @@ var MatArrayFieldSchema = containerSchemas.ArrayFieldSchema;
 var MatFieldSchema = containerSchemas.AllFieldsSchema;
 
 // internal/dynamic-forms-validation/material/src/mat-form-config.schema.ts
-import { z as z43 } from "zod";
-var MatFormDefaultPropsSchema = z43.object({
+import { z as z45 } from "zod";
+var MatFormDefaultPropsSchema = z45.object({
   /**
    * Default form field appearance for all fields.
    */
@@ -6148,15 +6185,15 @@ var MatFormDefaultPropsSchema = z43.object({
 var MatFormConfigSchema = createFormConfigSchema(MatFieldSchema, MatFormDefaultPropsSchema);
 
 // internal/dynamic-forms-validation/bootstrap/src/props/index.ts
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 
 // internal/dynamic-forms-validation/bootstrap/src/props/bs-common-props.schema.ts
-import { z as z44 } from "zod";
-var BsSizeSchema = z44.enum(["sm", "lg"]);
-var BsButtonVariantSchema = z44.enum(["primary", "secondary", "success", "danger", "warning", "info", "light", "dark", "link"]);
-var BsFormFieldPropsSchema = z44.object({
+import { z as z46 } from "zod";
+var BsSizeSchema = z46.enum(["sm", "lg"]);
+var BsButtonVariantSchema = z46.enum(["primary", "secondary", "success", "danger", "warning", "info", "light", "dark", "link"]);
+var BsFormFieldPropsSchema = z46.object({
   size: BsSizeSchema.optional(),
-  floatingLabel: z44.boolean().optional(),
+  floatingLabel: z46.boolean().optional(),
   hint: DynamicTextSchema.optional(),
   validFeedback: DynamicTextSchema.optional(),
   invalidFeedback: DynamicTextSchema.optional()
@@ -6164,94 +6201,94 @@ var BsFormFieldPropsSchema = z44.object({
 
 // internal/dynamic-forms-validation/bootstrap/src/props/index.ts
 var BsInputPropsSchema = BsFormFieldPropsSchema.extend({
-  type: z45.enum(["text", "email", "password", "number", "tel", "url"]).optional(),
+  type: z47.enum(["text", "email", "password", "number", "tel", "url"]).optional(),
   placeholder: DynamicTextSchema.optional(),
-  plaintext: z45.boolean().optional()
+  plaintext: z47.boolean().optional()
 });
 var BsTextareaPropsSchema = BsFormFieldPropsSchema.extend({
-  rows: z45.number().positive().optional(),
+  rows: z47.number().positive().optional(),
   placeholder: DynamicTextSchema.optional()
 });
 var BsSelectPropsSchema = BsFormFieldPropsSchema.extend({
-  multiple: z45.boolean().optional(),
-  htmlSize: z45.number().positive().optional(),
+  multiple: z47.boolean().optional(),
+  htmlSize: z47.number().positive().optional(),
   placeholder: DynamicTextSchema.optional()
 });
-var BsCheckboxPropsSchema = z45.object({
-  switch: z45.boolean().optional(),
-  inline: z45.boolean().optional(),
-  reverse: z45.boolean().optional(),
-  indeterminate: z45.boolean().optional(),
+var BsCheckboxPropsSchema = z47.object({
+  switch: z47.boolean().optional(),
+  inline: z47.boolean().optional(),
+  reverse: z47.boolean().optional(),
+  indeterminate: z47.boolean().optional(),
   hint: DynamicTextSchema.optional()
 });
-var BsRadioPropsSchema = z45.object({
-  inline: z45.boolean().optional(),
-  reverse: z45.boolean().optional(),
-  buttonGroup: z45.boolean().optional(),
+var BsRadioPropsSchema = z47.object({
+  inline: z47.boolean().optional(),
+  reverse: z47.boolean().optional(),
+  buttonGroup: z47.boolean().optional(),
   buttonSize: BsSizeSchema.optional(),
   hint: DynamicTextSchema.optional()
 });
-var BsMultiCheckboxPropsSchema = z45.object({
-  switch: z45.boolean().optional(),
-  inline: z45.boolean().optional(),
-  reverse: z45.boolean().optional(),
+var BsMultiCheckboxPropsSchema = z47.object({
+  switch: z47.boolean().optional(),
+  inline: z47.boolean().optional(),
+  reverse: z47.boolean().optional(),
   hint: DynamicTextSchema.optional()
 });
-var BsTogglePropsSchema = z45.object({
+var BsTogglePropsSchema = z47.object({
   size: BsSizeSchema.optional(),
-  reverse: z45.boolean().optional(),
-  inline: z45.boolean().optional(),
+  reverse: z47.boolean().optional(),
+  inline: z47.boolean().optional(),
   hint: DynamicTextSchema.optional()
 });
 var BsDatepickerPropsSchema = BsFormFieldPropsSchema.extend({
-  useNgBootstrap: z45.boolean().optional(),
-  displayMonths: z45.number().positive().optional(),
-  navigation: z45.enum(["select", "arrows", "none"]).optional(),
-  outsideDays: z45.enum(["visible", "collapsed", "hidden"]).optional(),
-  showWeekNumbers: z45.boolean().optional(),
+  useNgBootstrap: z47.boolean().optional(),
+  displayMonths: z47.number().positive().optional(),
+  navigation: z47.enum(["select", "arrows", "none"]).optional(),
+  outsideDays: z47.enum(["visible", "collapsed", "hidden"]).optional(),
+  showWeekNumbers: z47.boolean().optional(),
   placeholder: DynamicTextSchema.optional()
 });
-var BsSliderPropsSchema = z45.object({
-  showValue: z45.boolean().optional(),
-  valuePrefix: z45.string().optional(),
-  valueSuffix: z45.string().optional(),
+var BsSliderPropsSchema = z47.object({
+  showValue: z47.boolean().optional(),
+  valuePrefix: z47.string().optional(),
+  valueSuffix: z47.string().optional(),
   hint: DynamicTextSchema.optional(),
-  min: z45.number().optional(),
-  max: z45.number().optional(),
-  step: z45.number().positive().optional()
+  min: z47.number().optional(),
+  max: z47.number().optional(),
+  step: z47.number().positive().optional()
 });
-var BsButtonPropsSchema = z45.object({
+var BsButtonPropsSchema = z47.object({
   variant: BsButtonVariantSchema.optional(),
-  outline: z45.boolean().optional(),
+  outline: z47.boolean().optional(),
   size: BsSizeSchema.optional(),
-  block: z45.boolean().optional(),
-  active: z45.boolean().optional(),
-  type: z45.enum(["button", "submit", "reset"]).optional()
+  block: z47.boolean().optional(),
+  active: z47.boolean().optional(),
+  type: z47.enum(["button", "submit", "reset"]).optional()
 });
 
 // internal/dynamic-forms-validation/bootstrap/src/fields/index.ts
-import { z as z46 } from "zod";
+import { z as z48 } from "zod";
 var BsValueFieldBase = BaseFieldDefSchema.merge(FieldWithValidationSchema);
 var BsInputFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("input"),
-  nullable: z46.boolean().optional(),
-  value: z46.string().nullable().optional(),
+  type: z48.literal("input"),
+  nullable: z48.boolean().optional(),
+  value: InputValueSchema,
   placeholder: DynamicTextSchema.optional(),
   props: BsInputPropsSchema.optional()
 });
-var BsInputFieldSchema = BsInputFieldSchemaObject.superRefine(nullableValueRefine);
+var BsInputFieldSchema = BsInputFieldSchemaObject.superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 var BsTextareaFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("textarea"),
-  nullable: z46.boolean().optional(),
-  value: z46.string().nullable().optional(),
+  type: z48.literal("textarea"),
+  nullable: z48.boolean().optional(),
+  value: z48.string().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: BsTextareaPropsSchema.optional()
 });
 var BsTextareaFieldSchema = BsTextareaFieldSchemaObject.superRefine(nullableValueRefine);
 var BsSelectFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("select"),
-  nullable: z46.boolean().optional(),
-  value: z46.string().nullable().optional(),
+  type: z48.literal("select"),
+  nullable: z48.boolean().optional(),
+  value: z48.string().nullable().optional(),
   // Bootstrap select only supports strings
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
@@ -6259,76 +6296,76 @@ var BsSelectFieldSchemaObject = BsValueFieldBase.extend({
 });
 var BsSelectFieldSchema = BsSelectFieldSchemaObject.superRefine(nullableValueRefine);
 var BsCheckboxFieldSchema = BsValueFieldBase.extend({
-  type: z46.literal("checkbox"),
-  value: z46.boolean().optional(),
+  type: z48.literal("checkbox"),
+  value: z48.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: BsCheckboxPropsSchema.optional()
 });
 var BsRadioFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("radio"),
-  nullable: z46.boolean().optional(),
-  value: z46.unknown().nullable().optional(),
+  type: z48.literal("radio"),
+  nullable: z48.boolean().optional(),
+  value: z48.unknown().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: BsRadioPropsSchema.optional()
 });
 var BsRadioFieldSchema = BsRadioFieldSchemaObject.superRefine(nullableValueRefine);
 var BsMultiCheckboxFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("multi-checkbox"),
-  nullable: z46.boolean().optional(),
-  value: z46.array(z46.unknown()).nullable().optional(),
+  type: z48.literal("multi-checkbox"),
+  nullable: z48.boolean().optional(),
+  value: z48.array(z48.unknown()).nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: BsMultiCheckboxPropsSchema.optional()
 });
 var BsMultiCheckboxFieldSchema = BsMultiCheckboxFieldSchemaObject.superRefine(nullableValueRefine);
 var BsToggleFieldSchema = BsValueFieldBase.extend({
-  type: z46.literal("toggle"),
-  value: z46.boolean().optional(),
+  type: z48.literal("toggle"),
+  value: z48.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: BsTogglePropsSchema.optional()
 });
 var BsDatepickerFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("datepicker"),
-  nullable: z46.boolean().optional(),
-  value: z46.union([z46.string(), z46.null()]).optional(),
-  minDate: z46.union([z46.string(), z46.null()]).optional(),
-  maxDate: z46.union([z46.string(), z46.null()]).optional(),
-  startAt: z46.union([z46.string(), z46.null()]).optional(),
+  type: z48.literal("datepicker"),
+  nullable: z48.boolean().optional(),
+  value: DatepickerValueSchema,
+  minDate: z48.union([z48.string(), z48.null()]).optional(),
+  maxDate: z48.union([z48.string(), z48.null()]).optional(),
+  startAt: z48.union([z48.string(), z48.null()]).optional(),
   placeholder: DynamicTextSchema.optional(),
   props: BsDatepickerPropsSchema.optional()
 });
 var BsDatepickerFieldSchema = BsDatepickerFieldSchemaObject.superRefine(nullableValueRefine);
 var BsSliderFieldSchemaObject = BsValueFieldBase.extend({
-  type: z46.literal("slider"),
-  nullable: z46.boolean().optional(),
-  value: z46.number().nullable().optional(),
-  minValue: z46.number().optional(),
-  maxValue: z46.number().optional(),
-  step: z46.number().positive().optional(),
+  type: z48.literal("slider"),
+  nullable: z48.boolean().optional(),
+  value: SliderValueSchema,
+  minValue: z48.number().optional(),
+  maxValue: z48.number().optional(),
+  step: z48.number().positive().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: BsSliderPropsSchema.optional()
 });
 var BsSliderFieldSchema = BsSliderFieldSchemaObject.superRefine(nullableValueRefine);
 var BsButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("button"),
-  event: z46.string().optional(),
-  eventArgs: z46.array(z46.union([z46.string(), z46.number(), z46.boolean(), z46.null(), z46.undefined()])).optional(),
+  type: z48.literal("button"),
+  event: z48.string().optional(),
+  eventArgs: z48.array(z48.union([z48.string(), z48.number(), z48.boolean(), z48.null(), z48.undefined()])).optional(),
   props: BsButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var BsSubmitButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("submit"),
+  type: z48.literal("submit"),
   props: BsButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var BsNextButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("next"),
+  type: z48.literal("next"),
   props: BsButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var BsPreviousButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("previous"),
+  type: z48.literal("previous"),
   props: BsButtonPropsSchema.optional()
 });
 var BsAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6337,13 +6374,13 @@ var BsAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z46.literal("add-array-item"),
-  arrayKey: z46.string().optional(),
+  type: z48.literal("add-array-item"),
+  arrayKey: z48.string().optional(),
   props: BsButtonPropsSchema.optional()
 });
 var BsRemoveArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("remove-array-item"),
-  arrayKey: z46.string().optional(),
+  type: z48.literal("remove-array-item"),
+  arrayKey: z48.string().optional(),
   props: BsButtonPropsSchema.optional()
 });
 var BsPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6352,8 +6389,8 @@ var BsPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z46.literal("prepend-array-item"),
-  arrayKey: z46.string().optional(),
+  type: z48.literal("prepend-array-item"),
+  arrayKey: z48.string().optional(),
   props: BsButtonPropsSchema.optional()
 });
 var BsInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6362,25 +6399,25 @@ var BsInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z46.literal("insert-array-item"),
-  arrayKey: z46.string().optional(),
-  index: z46.number(),
+  type: z48.literal("insert-array-item"),
+  arrayKey: z48.string().optional(),
+  index: z48.number(),
   props: BsButtonPropsSchema.optional()
 });
 var BsPopArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("pop-array-item"),
-  arrayKey: z46.string(),
+  type: z48.literal("pop-array-item"),
+  arrayKey: z48.string(),
   props: BsButtonPropsSchema.optional()
 });
 var BsShiftArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z46.literal("shift-array-item"),
-  arrayKey: z46.string(),
+  type: z48.literal("shift-array-item"),
+  arrayKey: z48.string(),
   props: BsButtonPropsSchema.optional()
 });
 
 // internal/dynamic-forms-validation/bootstrap/src/bs-leaf-field.schema.ts
-import { z as z47 } from "zod";
-var BsLeafFieldSchema = z47.discriminatedUnion("type", [
+import { z as z49 } from "zod";
+var BsLeafFieldSchema = z49.discriminatedUnion("type", [
   TextFieldSchema,
   HiddenFieldSchema,
   BsInputFieldSchemaObject,
@@ -6402,10 +6439,10 @@ var BsLeafFieldSchema = z47.discriminatedUnion("type", [
   BsInsertArrayItemButtonFieldSchema,
   BsPopArrayItemButtonFieldSchema,
   BsShiftArrayItemButtonFieldSchema
-]).superRefine(nullableValueRefine);
+]).superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 
 // internal/dynamic-forms-validation/bootstrap/src/bs-form-config.schema.ts
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 var containerSchemas2 = createContainerSchemas({
   leafFieldSchema: BsLeafFieldSchema
 });
@@ -6414,173 +6451,173 @@ var BsRowFieldSchema = containerSchemas2.RowFieldSchema;
 var BsGroupFieldSchema = containerSchemas2.GroupFieldSchema;
 var BsArrayFieldSchema = containerSchemas2.ArrayFieldSchema;
 var BsFieldSchema = containerSchemas2.AllFieldsSchema;
-var BsFormDefaultPropsSchema = z48.object({
+var BsFormDefaultPropsSchema = z50.object({
   size: BsSizeSchema.optional(),
-  floatingLabel: z48.boolean().optional()
+  floatingLabel: z50.boolean().optional()
 });
 var BsFormConfigSchema = createFormConfigSchema(BsFieldSchema, BsFormDefaultPropsSchema);
 
 // internal/dynamic-forms-validation/primeng/src/props/index.ts
-import { z as z49 } from "zod";
-var PrimeSeveritySchema = z49.enum(["primary", "secondary", "success", "info", "warn", "danger", "help", "contrast"]);
-var PrimeCommonPropsSchema = z49.object({
-  styleClass: z49.string().optional(),
+import { z as z51 } from "zod";
+var PrimeSeveritySchema = z51.enum(["primary", "secondary", "success", "info", "warn", "danger", "help", "contrast"]);
+var PrimeCommonPropsSchema = z51.object({
+  styleClass: z51.string().optional(),
   hint: DynamicTextSchema.optional()
 });
 var PrimeInputPropsSchema = PrimeCommonPropsSchema.extend({
-  type: z49.enum(["text", "email", "password", "number", "tel", "url"]).optional(),
+  type: z51.enum(["text", "email", "password", "number", "tel", "url"]).optional(),
   placeholder: DynamicTextSchema.optional(),
-  size: z49.enum(["small", "large"]).optional(),
-  variant: z49.enum(["outlined", "filled"]).optional()
+  size: z51.enum(["small", "large"]).optional(),
+  variant: z51.enum(["outlined", "filled"]).optional()
 });
 var PrimeCheckboxPropsSchema = PrimeCommonPropsSchema.extend({
-  binary: z49.boolean().optional(),
-  trueValue: z49.unknown().optional(),
-  falseValue: z49.unknown().optional()
+  binary: z51.boolean().optional(),
+  trueValue: z51.unknown().optional(),
+  falseValue: z51.unknown().optional()
 });
 var PrimeRadioPropsSchema = PrimeCommonPropsSchema.extend({
-  name: z49.string().optional()
+  name: z51.string().optional()
 });
 var PrimeSelectPropsSchema = PrimeCommonPropsSchema.extend({
-  multiple: z49.boolean().optional(),
-  filter: z49.boolean().optional(),
+  multiple: z51.boolean().optional(),
+  filter: z51.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
-  showClear: z49.boolean().optional()
+  showClear: z51.boolean().optional()
 });
 var PrimeMultiCheckboxPropsSchema = PrimeCommonPropsSchema;
 var PrimeDatepickerPropsSchema = PrimeCommonPropsSchema.extend({
-  dateFormat: z49.string().optional(),
-  inline: z49.boolean().optional(),
-  showIcon: z49.boolean().optional(),
-  showButtonBar: z49.boolean().optional(),
-  selectionMode: z49.enum(["single", "multiple", "range"]).optional(),
-  touchUI: z49.boolean().optional(),
-  view: z49.enum(["date", "month", "year"]).optional(),
+  dateFormat: z51.string().optional(),
+  inline: z51.boolean().optional(),
+  showIcon: z51.boolean().optional(),
+  showButtonBar: z51.boolean().optional(),
+  selectionMode: z51.enum(["single", "multiple", "range"]).optional(),
+  touchUI: z51.boolean().optional(),
+  view: z51.enum(["date", "month", "year"]).optional(),
   placeholder: DynamicTextSchema.optional()
 });
 var PrimeTextareaPropsSchema = PrimeCommonPropsSchema.extend({
-  rows: z49.number().positive().optional(),
-  autoResize: z49.boolean().optional(),
+  rows: z51.number().positive().optional(),
+  autoResize: z51.boolean().optional(),
   placeholder: DynamicTextSchema.optional()
 });
 var PrimeSliderPropsSchema = PrimeCommonPropsSchema.extend({
-  min: z49.number().optional(),
-  max: z49.number().optional(),
-  step: z49.number().positive().optional(),
-  range: z49.boolean().optional(),
-  orientation: z49.enum(["horizontal", "vertical"]).optional()
+  min: z51.number().optional(),
+  max: z51.number().optional(),
+  step: z51.number().positive().optional(),
+  range: z51.boolean().optional(),
+  orientation: z51.enum(["horizontal", "vertical"]).optional()
 });
 var PrimeTogglePropsSchema = PrimeCommonPropsSchema;
-var PrimeButtonPropsSchema = z49.object({
+var PrimeButtonPropsSchema = z51.object({
   severity: PrimeSeveritySchema.optional(),
-  text: z49.boolean().optional(),
-  outlined: z49.boolean().optional(),
-  raised: z49.boolean().optional(),
-  rounded: z49.boolean().optional(),
-  icon: z49.string().optional(),
-  iconPos: z49.enum(["left", "right", "top", "bottom"]).optional(),
-  type: z49.enum(["button", "submit", "reset"]).optional()
+  text: z51.boolean().optional(),
+  outlined: z51.boolean().optional(),
+  raised: z51.boolean().optional(),
+  rounded: z51.boolean().optional(),
+  icon: z51.string().optional(),
+  iconPos: z51.enum(["left", "right", "top", "bottom"]).optional(),
+  type: z51.enum(["button", "submit", "reset"]).optional()
 });
 
 // internal/dynamic-forms-validation/primeng/src/fields/index.ts
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 var PrimeValueFieldBase = BaseFieldDefSchema.merge(FieldWithValidationSchema);
 var PrimeInputFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("input"),
-  nullable: z50.boolean().optional(),
-  value: z50.string().nullable().optional(),
+  type: z52.literal("input"),
+  nullable: z52.boolean().optional(),
+  value: InputValueSchema,
   placeholder: DynamicTextSchema.optional(),
   props: PrimeInputPropsSchema.optional()
 });
-var PrimeInputFieldSchema = PrimeInputFieldSchemaObject.superRefine(nullableValueRefine);
+var PrimeInputFieldSchema = PrimeInputFieldSchemaObject.superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 var PrimeCheckboxFieldSchema = PrimeValueFieldBase.extend({
-  type: z50.literal("checkbox"),
-  value: z50.boolean().optional(),
+  type: z52.literal("checkbox"),
+  value: z52.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: PrimeCheckboxPropsSchema.optional()
 });
 var PrimeRadioFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("radio"),
-  nullable: z50.boolean().optional(),
-  value: z50.unknown().nullable().optional(),
+  type: z52.literal("radio"),
+  nullable: z52.boolean().optional(),
+  value: z52.unknown().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: PrimeRadioPropsSchema.optional()
 });
 var PrimeRadioFieldSchema = PrimeRadioFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeSelectFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("select"),
-  nullable: z50.boolean().optional(),
-  value: z50.unknown().nullable().optional(),
+  type: z52.literal("select"),
+  nullable: z52.boolean().optional(),
+  value: z52.unknown().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: PrimeSelectPropsSchema.optional()
 });
 var PrimeSelectFieldSchema = PrimeSelectFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeMultiCheckboxFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("multi-checkbox"),
-  nullable: z50.boolean().optional(),
-  value: z50.array(z50.unknown()).nullable().optional(),
+  type: z52.literal("multi-checkbox"),
+  nullable: z52.boolean().optional(),
+  value: z52.array(z52.unknown()).nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: PrimeMultiCheckboxPropsSchema.optional()
 });
 var PrimeMultiCheckboxFieldSchema = PrimeMultiCheckboxFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeDatepickerFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("datepicker"),
-  nullable: z50.boolean().optional(),
-  value: z50.union([z50.string(), z50.null()]).optional(),
-  minDate: z50.union([z50.string(), z50.null()]).optional(),
-  maxDate: z50.union([z50.string(), z50.null()]).optional(),
-  startAt: z50.union([z50.string(), z50.null()]).optional(),
+  type: z52.literal("datepicker"),
+  nullable: z52.boolean().optional(),
+  value: DatepickerValueSchema,
+  minDate: z52.union([z52.string(), z52.null()]).optional(),
+  maxDate: z52.union([z52.string(), z52.null()]).optional(),
+  startAt: z52.union([z52.string(), z52.null()]).optional(),
   placeholder: DynamicTextSchema.optional(),
   props: PrimeDatepickerPropsSchema.optional()
 });
 var PrimeDatepickerFieldSchema = PrimeDatepickerFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeTextareaFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("textarea"),
-  nullable: z50.boolean().optional(),
-  value: z50.string().nullable().optional(),
+  type: z52.literal("textarea"),
+  nullable: z52.boolean().optional(),
+  value: z52.string().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: PrimeTextareaPropsSchema.optional()
 });
 var PrimeTextareaFieldSchema = PrimeTextareaFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeSliderFieldSchemaObject = PrimeValueFieldBase.extend({
-  type: z50.literal("slider"),
-  nullable: z50.boolean().optional(),
-  value: z50.number().nullable().optional(),
-  minValue: z50.number().optional(),
-  maxValue: z50.number().optional(),
-  step: z50.number().positive().optional(),
+  type: z52.literal("slider"),
+  nullable: z52.boolean().optional(),
+  value: SliderValueSchema,
+  minValue: z52.number().optional(),
+  maxValue: z52.number().optional(),
+  step: z52.number().positive().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: PrimeSliderPropsSchema.optional()
 });
 var PrimeSliderFieldSchema = PrimeSliderFieldSchemaObject.superRefine(nullableValueRefine);
 var PrimeToggleFieldSchema = PrimeValueFieldBase.extend({
-  type: z50.literal("toggle"),
-  value: z50.boolean().optional(),
+  type: z52.literal("toggle"),
+  value: z52.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: PrimeTogglePropsSchema.optional()
 });
 var PrimeButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("button"),
-  event: z50.string().optional(),
-  eventArgs: z50.array(z50.union([z50.string(), z50.number(), z50.boolean(), z50.null(), z50.undefined()])).optional(),
+  type: z52.literal("button"),
+  event: z52.string().optional(),
+  eventArgs: z52.array(z52.union([z52.string(), z52.number(), z52.boolean(), z52.null(), z52.undefined()])).optional(),
   props: PrimeButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var PrimeSubmitButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("submit"),
+  type: z52.literal("submit"),
   props: PrimeButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var PrimeNextButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("next"),
+  type: z52.literal("next"),
   props: PrimeButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var PrimePreviousButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("previous"),
+  type: z52.literal("previous"),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimeAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6589,13 +6626,13 @@ var PrimeAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z50.literal("add-array-item"),
-  arrayKey: z50.string().optional(),
+  type: z52.literal("add-array-item"),
+  arrayKey: z52.string().optional(),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimeRemoveArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("remove-array-item"),
-  arrayKey: z50.string().optional(),
+  type: z52.literal("remove-array-item"),
+  arrayKey: z52.string().optional(),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimePrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6604,8 +6641,8 @@ var PrimePrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z50.literal("prepend-array-item"),
-  arrayKey: z50.string().optional(),
+  type: z52.literal("prepend-array-item"),
+  arrayKey: z52.string().optional(),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimeInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6614,25 +6651,25 @@ var PrimeInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z50.literal("insert-array-item"),
-  arrayKey: z50.string().optional(),
-  index: z50.number(),
+  type: z52.literal("insert-array-item"),
+  arrayKey: z52.string().optional(),
+  index: z52.number(),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimePopArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("pop-array-item"),
-  arrayKey: z50.string(),
+  type: z52.literal("pop-array-item"),
+  arrayKey: z52.string(),
   props: PrimeButtonPropsSchema.optional()
 });
 var PrimeShiftArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z50.literal("shift-array-item"),
-  arrayKey: z50.string(),
+  type: z52.literal("shift-array-item"),
+  arrayKey: z52.string(),
   props: PrimeButtonPropsSchema.optional()
 });
 
 // internal/dynamic-forms-validation/primeng/src/prime-leaf-field.schema.ts
-import { z as z51 } from "zod";
-var PrimeLeafFieldSchema = z51.discriminatedUnion("type", [
+import { z as z53 } from "zod";
+var PrimeLeafFieldSchema = z53.discriminatedUnion("type", [
   TextFieldSchema,
   HiddenFieldSchema,
   PrimeInputFieldSchemaObject,
@@ -6654,10 +6691,10 @@ var PrimeLeafFieldSchema = z51.discriminatedUnion("type", [
   PrimeInsertArrayItemButtonFieldSchema,
   PrimePopArrayItemButtonFieldSchema,
   PrimeShiftArrayItemButtonFieldSchema
-]).superRefine(nullableValueRefine);
+]).superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 
 // internal/dynamic-forms-validation/primeng/src/prime-form-config.schema.ts
-import { z as z52 } from "zod";
+import { z as z54 } from "zod";
 var containerSchemas3 = createContainerSchemas({
   leafFieldSchema: PrimeLeafFieldSchema
 });
@@ -6666,13 +6703,13 @@ var PrimeRowFieldSchema = containerSchemas3.RowFieldSchema;
 var PrimeGroupFieldSchema = containerSchemas3.GroupFieldSchema;
 var PrimeArrayFieldSchema = containerSchemas3.ArrayFieldSchema;
 var PrimeFieldSchema = containerSchemas3.AllFieldsSchema;
-var PrimeFormDefaultPropsSchema = z52.object({
-  styleClass: z52.string().optional()
+var PrimeFormDefaultPropsSchema = z54.object({
+  styleClass: z54.string().optional()
 });
 var PrimeFormConfigSchema = createFormConfigSchema(PrimeFieldSchema, PrimeFormDefaultPropsSchema);
 
 // internal/dynamic-forms-validation/ionic/src/props/index.ts
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 function isLocaleTag(value) {
   try {
     return Intl.getCanonicalLocales(value).length > 0;
@@ -6680,209 +6717,209 @@ function isLocaleTag(value) {
     return false;
   }
 }
-var IonicColorSchema = z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger", "light", "medium", "dark"]);
-var IonicLabelPlacementSchema = z53.enum(["start", "end", "fixed", "stacked", "floating"]);
-var IonicJustifySchema = z53.enum(["start", "end", "space-between"]);
-var IonicFillSchema = z53.enum(["solid", "outline", "clear", "default"]);
-var IonicInputPropsSchema = z53.object({
-  fill: z53.enum(["solid", "outline"]).optional(),
-  shape: z53.literal("round").optional(),
+var IonicColorSchema = z55.enum(["primary", "secondary", "tertiary", "success", "warning", "danger", "light", "medium", "dark"]);
+var IonicLabelPlacementSchema = z55.enum(["start", "end", "fixed", "stacked", "floating"]);
+var IonicJustifySchema = z55.enum(["start", "end", "space-between"]);
+var IonicFillSchema = z55.enum(["solid", "outline", "clear", "default"]);
+var IonicInputPropsSchema = z55.object({
+  fill: z55.enum(["solid", "outline"]).optional(),
+  shape: z55.literal("round").optional(),
   labelPlacement: IonicLabelPlacementSchema.optional(),
   color: IonicColorSchema.optional(),
   hint: DynamicTextSchema.optional(),
   errorText: DynamicTextSchema.optional(),
-  counter: z53.boolean().optional(),
-  clearInput: z53.boolean().optional(),
-  type: z53.enum(["text", "email", "password", "number", "tel", "url", "search"]).optional(),
+  counter: z55.boolean().optional(),
+  clearInput: z55.boolean().optional(),
+  type: z55.enum(["text", "email", "password", "number", "tel", "url", "search"]).optional(),
   placeholder: DynamicTextSchema.optional()
 });
-var IonicCheckboxPropsSchema = z53.object({
-  labelPlacement: z53.enum(["start", "end", "fixed", "stacked"]).optional(),
+var IonicCheckboxPropsSchema = z55.object({
+  labelPlacement: z55.enum(["start", "end", "fixed", "stacked"]).optional(),
   justify: IonicJustifySchema.optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
-  indeterminate: z53.boolean().optional(),
+  color: IonicColorSchema.optional(),
+  indeterminate: z55.boolean().optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicRadioPropsSchema = z53.object({
-  labelPlacement: z53.enum(["start", "end", "fixed", "stacked"]).optional(),
+var IonicRadioPropsSchema = z55.object({
+  labelPlacement: z55.enum(["start", "end", "fixed", "stacked"]).optional(),
   justify: IonicJustifySchema.optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
+  color: IonicColorSchema.optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicTogglePropsSchema = z53.object({
-  labelPlacement: z53.enum(["start", "end", "fixed", "stacked"]).optional(),
+var IonicTogglePropsSchema = z55.object({
+  labelPlacement: z55.enum(["start", "end", "fixed", "stacked"]).optional(),
   justify: IonicJustifySchema.optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
-  enableOnOffLabels: z53.boolean().optional(),
+  color: IonicColorSchema.optional(),
+  enableOnOffLabels: z55.boolean().optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicSliderPropsSchema = z53.object({
-  min: z53.number().optional(),
-  max: z53.number().optional(),
-  step: z53.number().positive().optional(),
-  dualKnobs: z53.boolean().optional(),
-  pin: z53.boolean().optional(),
-  ticks: z53.boolean().optional(),
-  snaps: z53.boolean().optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
-  labelPlacement: z53.enum(["start", "end", "fixed", "stacked"]).optional(),
+var IonicSliderPropsSchema = z55.object({
+  min: z55.number().optional(),
+  max: z55.number().optional(),
+  step: z55.number().positive().optional(),
+  dualKnobs: z55.boolean().optional(),
+  pin: z55.boolean().optional(),
+  ticks: z55.boolean().optional(),
+  snaps: z55.boolean().optional(),
+  color: IonicColorSchema.optional(),
+  labelPlacement: z55.enum(["start", "end", "fixed", "stacked"]).optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicDatepickerPropsSchema = z53.object({
-  presentation: z53.enum(["date", "date-time", "time", "time-date", "month", "month-year", "year"]).optional(),
-  multiple: z53.boolean().optional(),
-  preferWheel: z53.boolean().optional(),
-  showDefaultButtons: z53.boolean().optional(),
-  showDefaultTitle: z53.boolean().optional(),
-  showDefaultTimeLabel: z53.boolean().optional(),
-  showClearButton: z53.boolean().optional(),
-  doneText: z53.string().optional(),
-  cancelText: z53.string().optional(),
-  size: z53.enum(["cover", "fixed"]).optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
+var IonicDatepickerPropsSchema = z55.object({
+  presentation: z55.enum(["date", "date-time", "time", "time-date", "month", "month-year", "year"]).optional(),
+  multiple: z55.boolean().optional(),
+  preferWheel: z55.boolean().optional(),
+  showDefaultButtons: z55.boolean().optional(),
+  showDefaultTitle: z55.boolean().optional(),
+  showDefaultTimeLabel: z55.boolean().optional(),
+  showClearButton: z55.boolean().optional(),
+  doneText: DynamicTextSchema.optional(),
+  cancelText: DynamicTextSchema.optional(),
+  size: z55.enum(["cover", "fixed"]).optional(),
+  color: IonicColorSchema.optional(),
   hint: DynamicTextSchema.optional(),
-  locale: z53.string().refine(isLocaleTag, { message: 'Expected a BCP 47 locale tag such as "de-DE"' }).optional(),
+  locale: z55.string().refine(isLocaleTag, { message: 'Expected a BCP 47 locale tag such as "de-DE"' }).optional(),
   placeholder: DynamicTextSchema.optional()
 });
-var IonicSelectPropsSchema = z53.object({
-  multiple: z53.boolean().optional(),
-  interface: z53.enum(["action-sheet", "popover", "alert"]).optional(),
-  cancelText: z53.string().optional(),
-  okText: z53.string().optional(),
+var IonicSelectPropsSchema = z55.object({
+  multiple: z55.boolean().optional(),
+  interface: z55.enum(["action-sheet", "popover", "alert"]).optional(),
+  cancelText: DynamicTextSchema.optional(),
+  okText: DynamicTextSchema.optional(),
   placeholder: DynamicTextSchema.optional(),
-  fill: z53.enum(["solid", "outline"]).optional(),
-  shape: z53.literal("round").optional(),
+  fill: z55.enum(["solid", "outline"]).optional(),
+  shape: z55.literal("round").optional(),
   labelPlacement: IonicLabelPlacementSchema.optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
+  color: IonicColorSchema.optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicTextareaPropsSchema = z53.object({
-  rows: z53.number().positive().optional(),
-  autoGrow: z53.boolean().optional(),
-  counter: z53.boolean().optional(),
-  fill: z53.enum(["solid", "outline"]).optional(),
-  shape: z53.literal("round").optional(),
+var IonicTextareaPropsSchema = z55.object({
+  rows: z55.number().positive().optional(),
+  autoGrow: z55.boolean().optional(),
+  counter: z55.boolean().optional(),
+  fill: z55.enum(["solid", "outline"]).optional(),
+  shape: z55.literal("round").optional(),
   labelPlacement: IonicLabelPlacementSchema.optional(),
   hint: DynamicTextSchema.optional(),
   errorText: DynamicTextSchema.optional(),
   color: IonicColorSchema.optional(),
   placeholder: DynamicTextSchema.optional()
 });
-var IonicMultiCheckboxPropsSchema = z53.object({
-  labelPlacement: z53.enum(["start", "end", "fixed", "stacked"]).optional(),
+var IonicMultiCheckboxPropsSchema = z55.object({
+  labelPlacement: z55.enum(["start", "end", "fixed", "stacked"]).optional(),
   justify: IonicJustifySchema.optional(),
-  color: z53.enum(["primary", "secondary", "tertiary", "success", "warning", "danger"]).optional(),
+  color: IonicColorSchema.optional(),
   hint: DynamicTextSchema.optional()
 });
-var IonicButtonPropsSchema = z53.object({
-  expand: z53.enum(["full", "block"]).optional(),
+var IonicButtonPropsSchema = z55.object({
+  expand: z55.enum(["full", "block"]).optional(),
   fill: IonicFillSchema.optional(),
-  shape: z53.literal("round").optional(),
-  size: z53.enum(["small", "default", "large"]).optional(),
+  shape: z55.literal("round").optional(),
+  size: z55.enum(["small", "default", "large"]).optional(),
   color: IonicColorSchema.optional(),
-  strong: z53.boolean().optional(),
-  type: z53.enum(["button", "submit", "reset"]).optional()
+  strong: z55.boolean().optional(),
+  type: z55.enum(["button", "submit", "reset"]).optional()
 });
 
 // internal/dynamic-forms-validation/ionic/src/fields/index.ts
-import { z as z54 } from "zod";
+import { z as z56 } from "zod";
 var IonicValueFieldBase = BaseFieldDefSchema.merge(FieldWithValidationSchema);
 var IonicInputFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("input"),
-  nullable: z54.boolean().optional(),
-  value: z54.string().nullable().optional(),
+  type: z56.literal("input"),
+  nullable: z56.boolean().optional(),
+  value: InputValueSchema,
   placeholder: DynamicTextSchema.optional(),
   props: IonicInputPropsSchema.optional()
 });
-var IonicInputFieldSchema = IonicInputFieldSchemaObject.superRefine(nullableValueRefine);
+var IonicInputFieldSchema = IonicInputFieldSchemaObject.superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 var IonicCheckboxFieldSchema = IonicValueFieldBase.extend({
-  type: z54.literal("checkbox"),
-  value: z54.boolean().optional(),
+  type: z56.literal("checkbox"),
+  value: z56.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: IonicCheckboxPropsSchema.optional()
 });
 var IonicRadioFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("radio"),
-  nullable: z54.boolean().optional(),
-  value: z54.unknown().nullable().optional(),
+  type: z56.literal("radio"),
+  nullable: z56.boolean().optional(),
+  value: z56.unknown().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: IonicRadioPropsSchema.optional()
 });
 var IonicRadioFieldSchema = IonicRadioFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicToggleFieldSchema = IonicValueFieldBase.extend({
-  type: z54.literal("toggle"),
-  value: z54.boolean().optional(),
+  type: z56.literal("toggle"),
+  value: z56.boolean().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: IonicTogglePropsSchema.optional()
 });
 var IonicSliderFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("slider"),
-  nullable: z54.boolean().optional(),
-  value: z54.number().nullable().optional(),
-  minValue: z54.number().optional(),
-  maxValue: z54.number().optional(),
-  step: z54.number().positive().optional(),
+  type: z56.literal("slider"),
+  nullable: z56.boolean().optional(),
+  value: SliderValueSchema,
+  minValue: z56.number().optional(),
+  maxValue: z56.number().optional(),
+  step: z56.number().positive().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: IonicSliderPropsSchema.optional()
 });
 var IonicSliderFieldSchema = IonicSliderFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicDatepickerFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("datepicker"),
-  nullable: z54.boolean().optional(),
-  value: z54.union([z54.string(), z54.null()]).optional(),
-  minDate: z54.union([z54.string(), z54.null()]).optional(),
-  maxDate: z54.union([z54.string(), z54.null()]).optional(),
-  startAt: z54.union([z54.string(), z54.null()]).optional(),
+  type: z56.literal("datepicker"),
+  nullable: z56.boolean().optional(),
+  value: DatepickerValueSchema,
+  minDate: z56.union([z56.string(), z56.null()]).optional(),
+  maxDate: z56.union([z56.string(), z56.null()]).optional(),
+  startAt: z56.union([z56.string(), z56.null()]).optional(),
   placeholder: DynamicTextSchema.optional(),
   props: IonicDatepickerPropsSchema.optional()
 });
 var IonicDatepickerFieldSchema = IonicDatepickerFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicSelectFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("select"),
-  nullable: z54.boolean().optional(),
-  value: z54.unknown().nullable().optional(),
+  type: z56.literal("select"),
+  nullable: z56.boolean().optional(),
+  value: z56.unknown().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: IonicSelectPropsSchema.optional()
 });
 var IonicSelectFieldSchema = IonicSelectFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicTextareaFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("textarea"),
-  nullable: z54.boolean().optional(),
-  value: z54.string().nullable().optional(),
+  type: z56.literal("textarea"),
+  nullable: z56.boolean().optional(),
+  value: z56.string().nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   props: IonicTextareaPropsSchema.optional()
 });
 var IonicTextareaFieldSchema = IonicTextareaFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicMultiCheckboxFieldSchemaObject = IonicValueFieldBase.extend({
-  type: z54.literal("multi-checkbox"),
-  nullable: z54.boolean().optional(),
-  value: z54.array(z54.unknown()).nullable().optional(),
+  type: z56.literal("multi-checkbox"),
+  nullable: z56.boolean().optional(),
+  value: z56.array(z56.unknown()).nullable().optional(),
   placeholder: DynamicTextSchema.optional(),
   options: FieldOptionsSchema,
   props: IonicMultiCheckboxPropsSchema.optional()
 });
 var IonicMultiCheckboxFieldSchema = IonicMultiCheckboxFieldSchemaObject.superRefine(nullableValueRefine);
 var IonicButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("button"),
-  event: z54.string().optional(),
-  eventArgs: z54.array(z54.union([z54.string(), z54.number(), z54.boolean(), z54.null(), z54.undefined()])).optional(),
+  type: z56.literal("button"),
+  event: z56.string().optional(),
+  eventArgs: z56.array(z56.union([z56.string(), z56.number(), z56.boolean(), z56.null(), z56.undefined()])).optional(),
   props: IonicButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var IonicSubmitButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("submit"),
+  type: z56.literal("submit"),
   props: IonicButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var IonicNextButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("next"),
+  type: z56.literal("next"),
   props: IonicButtonPropsSchema.optional(),
   logic: LogicArraySchema.optional()
 });
 var IonicPreviousButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("previous"),
+  type: z56.literal("previous"),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6891,13 +6928,13 @@ var IonicAddArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z54.literal("add-array-item"),
-  arrayKey: z54.string().optional(),
+  type: z56.literal("add-array-item"),
+  arrayKey: z56.string().optional(),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicRemoveArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("remove-array-item"),
-  arrayKey: z54.string().optional(),
+  type: z56.literal("remove-array-item"),
+  arrayKey: z56.string().optional(),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6906,8 +6943,8 @@ var IonicPrependArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z54.literal("prepend-array-item"),
-  arrayKey: z54.string().optional(),
+  type: z56.literal("prepend-array-item"),
+  arrayKey: z56.string().optional(),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
@@ -6916,25 +6953,25 @@ var IonicInsertArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
    * item, or a list of them for an object item.
    */
   template: ArrayItemTemplateSchema,
-  type: z54.literal("insert-array-item"),
-  arrayKey: z54.string().optional(),
-  index: z54.number(),
+  type: z56.literal("insert-array-item"),
+  arrayKey: z56.string().optional(),
+  index: z56.number(),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicPopArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("pop-array-item"),
-  arrayKey: z54.string(),
+  type: z56.literal("pop-array-item"),
+  arrayKey: z56.string(),
   props: IonicButtonPropsSchema.optional()
 });
 var IonicShiftArrayItemButtonFieldSchema = BaseFieldDefSchema.extend({
-  type: z54.literal("shift-array-item"),
-  arrayKey: z54.string(),
+  type: z56.literal("shift-array-item"),
+  arrayKey: z56.string(),
   props: IonicButtonPropsSchema.optional()
 });
 
 // internal/dynamic-forms-validation/ionic/src/ionic-leaf-field.schema.ts
-import { z as z55 } from "zod";
-var IonicLeafFieldSchema = z55.discriminatedUnion("type", [
+import { z as z57 } from "zod";
+var IonicLeafFieldSchema = z57.discriminatedUnion("type", [
   TextFieldSchema,
   HiddenFieldSchema,
   IonicInputFieldSchemaObject,
@@ -6956,10 +6993,10 @@ var IonicLeafFieldSchema = z55.discriminatedUnion("type", [
   IonicInsertArrayItemButtonFieldSchema,
   IonicPopArrayItemButtonFieldSchema,
   IonicShiftArrayItemButtonFieldSchema
-]).superRefine(nullableValueRefine);
+]).superRefine(nullableValueRefine).superRefine(inputValueTypeRefine);
 
 // internal/dynamic-forms-validation/ionic/src/ionic-form-config.schema.ts
-import { z as z56 } from "zod";
+import { z as z58 } from "zod";
 var containerSchemas4 = createContainerSchemas({
   leafFieldSchema: IonicLeafFieldSchema
 });
@@ -6968,7 +7005,7 @@ var IonicRowFieldSchema = containerSchemas4.RowFieldSchema;
 var IonicGroupFieldSchema = containerSchemas4.GroupFieldSchema;
 var IonicArrayFieldSchema = containerSchemas4.ArrayFieldSchema;
 var IonicFieldSchema = containerSchemas4.AllFieldsSchema;
-var IonicFormDefaultPropsSchema = z56.object({
+var IonicFormDefaultPropsSchema = z58.object({
   color: IonicColorSchema.optional(),
   labelPlacement: IonicLabelPlacementSchema.optional()
 });
@@ -6976,7 +7013,7 @@ var IonicFormConfigSchema = createFormConfigSchema(IonicFieldSchema, IonicFormDe
 
 // internal/dynamic-forms-validation/validate/src/json-schema/form-config-json-schema.ts
 function toJsonSchema(schema, name, basePath) {
-  const jsonSchema = z57.toJSONSchema(schema, { target: "draft-7", io: "input", unrepresentable: "any" });
+  const jsonSchema = z59.toJSONSchema(schema, { target: "draft-7", io: "input", unrepresentable: "any" });
   jsonSchema["$id"] = basePath ? `${basePath.replace(/\/$/, "")}/${name}` : name;
   return jsonSchema;
 }
@@ -7074,30 +7111,30 @@ function getFieldTypeJsonSchema(uiIntegration, fieldType) {
 }
 
 // internal/dynamic-forms-validation/src/lib/schemas/field-type-names.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 var MAX_DEPTH = 20;
 function collectDiscriminator(schema, into) {
-  if (schema instanceof z58.ZodLiteral) {
+  if (schema instanceof z60.ZodLiteral) {
     for (const value of schema.def.values) {
       if (typeof value === "string") into.add(value);
     }
     return;
   }
-  if (schema instanceof z58.ZodEnum) {
+  if (schema instanceof z60.ZodEnum) {
     for (const value of schema.options) into.add(value);
   }
 }
 function visit(schema, into, depth) {
   if (depth > MAX_DEPTH) return;
-  if (schema instanceof z58.ZodLazy) {
+  if (schema instanceof z60.ZodLazy) {
     visit(schema.unwrap(), into, depth + 1);
     return;
   }
-  if (schema instanceof z58.ZodUnion) {
+  if (schema instanceof z60.ZodUnion) {
     for (const option of schema.options) visit(option, into, depth + 1);
     return;
   }
-  if (schema instanceof z58.ZodObject) {
+  if (schema instanceof z60.ZodObject) {
     collectDiscriminator(schema.shape["type"], into);
     return;
   }
@@ -7108,6 +7145,1040 @@ function collectFieldTypeNames(schema) {
   return [...names];
 }
 
+// packages/dynamic-forms/internal/src/lib/errors/dynamic-form-error.ts
+var DynamicFormError = class _DynamicFormError extends Error {
+  static PREFIX = "[Dynamic Forms]";
+  constructor(message) {
+    super(`${_DynamicFormError.PREFIX} ${message}`);
+    this.name = "DynamicFormError";
+  }
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/types.ts
+var ExpressionParserError = class extends DynamicFormError {
+  constructor(message, position, expression) {
+    super(`${message} at position ${position} in expression: ${expression}`);
+    this.position = position;
+    this.expression = expression;
+    this.name = "ExpressionParserError";
+  }
+  position;
+  expression;
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/evaluator.ts
+var STRING_SAFE_METHODS = [
+  "charAt",
+  "charCodeAt",
+  "concat",
+  "endsWith",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "match",
+  "padEnd",
+  "padStart",
+  "repeat",
+  "replace",
+  "search",
+  "slice",
+  "split",
+  "startsWith",
+  "substring",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart",
+  "toString"
+];
+var NUMBER_SAFE_METHODS = ["toExponential", "toFixed", "toPrecision", "toString"];
+var ARRAY_SAFE_METHODS = [
+  "concat",
+  "every",
+  "filter",
+  "find",
+  "findIndex",
+  "flat",
+  "flatMap",
+  "includes",
+  "indexOf",
+  "join",
+  "lastIndexOf",
+  "map",
+  "reduce",
+  "reduceRight",
+  "slice",
+  "some",
+  "toString",
+  "entries",
+  "keys",
+  "values"
+];
+var DATE_SAFE_METHODS = [
+  "getDate",
+  "getDay",
+  "getFullYear",
+  "getHours",
+  "getMilliseconds",
+  "getMinutes",
+  "getMonth",
+  "getSeconds",
+  "getTime",
+  "getTimezoneOffset",
+  "getUTCDate",
+  "getUTCDay",
+  "getUTCFullYear",
+  "getUTCHours",
+  "getUTCMilliseconds",
+  "getUTCMinutes",
+  "getUTCMonth",
+  "getUTCSeconds",
+  "toDateString",
+  "toISOString",
+  "toJSON",
+  "toString",
+  "toTimeString",
+  "toUTCString"
+];
+var SAFE_METHODS = {
+  string: new Set(STRING_SAFE_METHODS),
+  number: new Set(NUMBER_SAFE_METHODS),
+  array: new Set(ARRAY_SAFE_METHODS),
+  date: new Set(DATE_SAFE_METHODS)
+};
+var ALLOWED_METHOD_NAMES = new Set(Object.values(SAFE_METHODS).flatMap((methods) => [...methods]));
+var BLOCKED_PROPERTIES = /* @__PURE__ */ new Set([
+  "constructor",
+  "__proto__",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+var Evaluator = class _Evaluator {
+  scope;
+  expression;
+  constructor(scope, expression) {
+    this.scope = scope;
+    this.expression = expression;
+  }
+  /** Evaluate an AST node */
+  evaluate(node) {
+    switch (node.type) {
+      case "Literal":
+        return node.value;
+      case "Identifier":
+        return this.evaluateIdentifier(node.name);
+      case "MemberAccess":
+        return this.evaluateMemberAccess(node);
+      case "ComputedMemberAccess":
+        return this.evaluateComputedMemberAccess(node);
+      case "BinaryOp":
+        return this.evaluateBinaryOp(node);
+      case "UnaryOp":
+        return this.evaluateUnaryOp(node);
+      case "CallExpression":
+        return this.evaluateCallExpression(node);
+      case "Conditional":
+        return this.evaluate(node.test) ? this.evaluate(node.consequent) : this.evaluate(node.alternate);
+      case "ArrayLiteral":
+        return this.evaluateArrayLiteral(node);
+      case "ObjectLiteral":
+        return this.evaluateObjectLiteral(node);
+      case "ArrowFunction":
+        return this.evaluateArrowFunction(node);
+      default:
+        throw new ExpressionParserError(`Unknown node type: ${node.type}`, 0, this.expression);
+    }
+  }
+  evaluateIdentifier(name) {
+    if (name in this.scope) {
+      return this.scope[name];
+    }
+    return void 0;
+  }
+  evaluateMemberAccess(node) {
+    const obj = this.evaluate(node.object);
+    if (obj === null || obj === void 0) {
+      return void 0;
+    }
+    if (BLOCKED_PROPERTIES.has(node.property)) {
+      throw new ExpressionParserError(`Property "${node.property}" is not accessible for security reasons`, 0, this.expression);
+    }
+    if (typeof obj === "object" || typeof obj === "string" || typeof obj === "number") {
+      return obj[node.property];
+    }
+    return void 0;
+  }
+  evaluateComputedMemberAccess(node) {
+    const obj = this.evaluate(node.object);
+    if (obj === null || obj === void 0) {
+      return void 0;
+    }
+    const rawKey = this.evaluate(node.property);
+    if (rawKey === null || rawKey === void 0) return void 0;
+    const key = String(rawKey);
+    if (BLOCKED_PROPERTIES.has(key)) {
+      throw new ExpressionParserError(`Property "${key}" is not accessible for security reasons`, 0, this.expression);
+    }
+    if (typeof obj === "object" || typeof obj === "string" || typeof obj === "number") {
+      return obj[key];
+    }
+    return void 0;
+  }
+  evaluateBinaryOp(node) {
+    if (node.operator === "&&") {
+      const left2 = this.evaluate(node.left);
+      return left2 ? this.evaluate(node.right) : left2;
+    }
+    if (node.operator === "||") {
+      const left2 = this.evaluate(node.left);
+      return left2 ? left2 : this.evaluate(node.right);
+    }
+    if (node.operator === "??") {
+      const left2 = this.evaluate(node.left);
+      return left2 ?? this.evaluate(node.right);
+    }
+    const left = this.evaluate(node.left);
+    const right = this.evaluate(node.right);
+    switch (node.operator) {
+      // Arithmetic
+      case "+":
+        return left + right;
+      case "-":
+        return left - right;
+      case "*":
+        return left * right;
+      case "/":
+        if (right === 0) return null;
+        return left / right;
+      case "%":
+        if (right === 0) return null;
+        return left % right;
+      // Comparison - using == and != intentionally for loose equality
+      case "==":
+        return left == right;
+      case "===":
+        return left === right;
+      case "!=":
+        return left != right;
+      case "!==":
+        return left !== right;
+      case ">":
+        return left > right;
+      case "<":
+        return left < right;
+      case ">=":
+        return left >= right;
+      case "<=":
+        return left <= right;
+      default:
+        throw new ExpressionParserError(`Unknown binary operator: ${node.operator}`, 0, this.expression);
+    }
+  }
+  evaluateUnaryOp(node) {
+    const operand = this.evaluate(node.operand);
+    switch (node.operator) {
+      case "!":
+        return !operand;
+      case "-":
+        return -operand;
+      case "+":
+        return +operand;
+      default:
+        throw new ExpressionParserError(`Unknown unary operator: ${node.operator}`, 0, this.expression);
+    }
+  }
+  evaluateCallExpression(node) {
+    if (node.callee.type !== "MemberAccess") {
+      throw new ExpressionParserError("Only method calls are allowed, not arbitrary function calls", 0, this.expression);
+    }
+    const obj = this.evaluate(node.callee.object);
+    if (obj === null || obj === void 0) {
+      return void 0;
+    }
+    const methodName = node.callee.property;
+    if (BLOCKED_PROPERTIES.has(methodName)) {
+      throw new ExpressionParserError(`Property "${methodName}" is not accessible for security reasons`, 0, this.expression);
+    }
+    if (!this.isMethodSafe(obj, methodName)) {
+      throw new ExpressionParserError(`Method "${methodName}" is not allowed for security reasons`, 0, this.expression);
+    }
+    const args = node.arguments.map((arg) => this.evaluate(arg));
+    const method = obj[methodName];
+    if (typeof method === "function") {
+      return method.call(obj, ...args);
+    }
+    return void 0;
+  }
+  evaluateArrayLiteral(node) {
+    return node.elements.map((element) => this.evaluate(element));
+  }
+  evaluateObjectLiteral(node) {
+    const result = {};
+    for (const { key, value } of node.properties) {
+      if (BLOCKED_PROPERTIES.has(key)) {
+        throw new ExpressionParserError(`Property "${key}" is not allowed in object literals for security reasons`, 0, this.expression);
+      }
+      result[key] = this.evaluate(value);
+    }
+    return result;
+  }
+  evaluateArrowFunction(node) {
+    const parentScope = this.scope;
+    const expression = this.expression;
+    return (...args) => {
+      const childScope = { ...parentScope };
+      for (let i = 0; i < node.params.length; i++) {
+        childScope[node.params[i]] = args[i];
+      }
+      const childEvaluator = new _Evaluator(childScope, expression);
+      return childEvaluator.evaluate(node.body);
+    };
+  }
+  isMethodSafe(obj, methodName) {
+    if (obj === null || obj === void 0) {
+      return false;
+    }
+    const type = Array.isArray(obj) ? "array" : obj instanceof Date ? "date" : typeof obj;
+    const safeMethods = SAFE_METHODS[type];
+    if (!safeMethods) {
+      return false;
+    }
+    return safeMethods.has(methodName);
+  }
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/tokenizer.ts
+var IDENTIFIER_START = /[\p{ID_Start}$_]/u;
+var IDENTIFIER_PART = /[\p{ID_Continue}$]/u;
+var Tokenizer = class {
+  position = 0;
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  /** Tokenize the entire expression */
+  tokenize() {
+    const tokens = [];
+    while (this.position < this.expression.length) {
+      this.skipWhitespace();
+      if (this.position >= this.expression.length) {
+        break;
+      }
+      const token = this.nextToken();
+      tokens.push(token);
+    }
+    tokens.push({ type: "EOF" /* EOF */, value: "", position: this.position });
+    return tokens;
+  }
+  skipWhitespace() {
+    while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
+      this.position++;
+    }
+  }
+  nextToken() {
+    const char = this.expression[this.position];
+    if (char === '"' || char === "'") {
+      return this.readString(char);
+    }
+    if (/[0-9]/.test(char)) {
+      return this.readNumber();
+    }
+    if (IDENTIFIER_START.test(this.codePointAt(this.position))) {
+      return this.readIdentifierOrKeyword();
+    }
+    return this.readOperatorOrPunctuation();
+  }
+  readString(quote) {
+    const start = this.position;
+    this.position++;
+    let value = "";
+    while (this.position < this.expression.length) {
+      const char = this.expression[this.position];
+      if (char === quote) {
+        this.position++;
+        return { type: "STRING" /* STRING */, value, position: start };
+      }
+      if (char === "\\" && this.position + 1 < this.expression.length) {
+        this.position++;
+        const nextChar = this.expression[this.position];
+        switch (nextChar) {
+          case "n":
+            value += "\n";
+            break;
+          case "t":
+            value += "	";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case quote:
+            value += quote;
+            break;
+          default:
+            value += nextChar;
+        }
+        this.position++;
+      } else {
+        value += char;
+        this.position++;
+      }
+    }
+    throw new ExpressionParserError("Unterminated string literal", start, this.expression);
+  }
+  readNumber() {
+    const start = this.position;
+    let value = "";
+    while (this.position < this.expression.length && /[0-9.]/.test(this.expression[this.position])) {
+      value += this.expression[this.position];
+      this.position++;
+    }
+    if (!/^\d+(\.\d+)?$/.test(value)) {
+      throw new ExpressionParserError(`Invalid number: ${value}`, start, this.expression);
+    }
+    return { type: "NUMBER" /* NUMBER */, value, position: start };
+  }
+  readIdentifierOrKeyword() {
+    const start = this.position;
+    let value = "";
+    while (this.position < this.expression.length) {
+      const char = this.codePointAt(this.position);
+      if (!IDENTIFIER_PART.test(char)) {
+        break;
+      }
+      value += char;
+      this.position += char.length;
+    }
+    const type = this.getKeywordType(value);
+    return { type, value, position: start };
+  }
+  /** Reads the whole code point at `position`, keeping surrogate pairs intact. */
+  codePointAt(position) {
+    const codePoint = this.expression.codePointAt(position);
+    return codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
+  }
+  getKeywordType(value) {
+    switch (value) {
+      case "true":
+        return "TRUE" /* TRUE */;
+      case "false":
+        return "FALSE" /* FALSE */;
+      case "null":
+        return "NULL" /* NULL */;
+      case "undefined":
+        return "UNDEFINED" /* UNDEFINED */;
+      default:
+        return "IDENTIFIER" /* IDENTIFIER */;
+    }
+  }
+  readOperatorOrPunctuation() {
+    const start = this.position;
+    const char = this.expression[this.position];
+    const nextChar = this.position + 1 < this.expression.length ? this.expression[this.position + 1] : "";
+    const thirdChar = this.position + 2 < this.expression.length ? this.expression[this.position + 2] : "";
+    const threeChar = char + nextChar + thirdChar;
+    if (threeChar === "===") {
+      this.position += 3;
+      return { type: "EQUAL" /* EQUAL */, value: "===", position: start };
+    }
+    if (threeChar === "!==") {
+      this.position += 3;
+      return { type: "NOT_EQUAL" /* NOT_EQUAL */, value: "!==", position: start };
+    }
+    const twoChar = char + nextChar;
+    switch (twoChar) {
+      case "==":
+        this.position += 2;
+        return { type: "EQUAL" /* EQUAL */, value: "==", position: start };
+      case "!=":
+        this.position += 2;
+        return { type: "NOT_EQUAL" /* NOT_EQUAL */, value: "!=", position: start };
+      case ">=":
+        this.position += 2;
+        return { type: "GREATER_EQUAL" /* GREATER_EQUAL */, value: ">=", position: start };
+      case "<=":
+        this.position += 2;
+        return { type: "LESS_EQUAL" /* LESS_EQUAL */, value: "<=", position: start };
+      case "&&":
+        this.position += 2;
+        return { type: "AND" /* AND */, value: "&&", position: start };
+      case "||":
+        this.position += 2;
+        return { type: "OR" /* OR */, value: "||", position: start };
+      case "=>":
+        this.position += 2;
+        return { type: "ARROW" /* ARROW */, value: "=>", position: start };
+      case "??":
+        this.position += 2;
+        return { type: "NULLISH" /* NULLISH */, value: "??", position: start };
+      case "?.":
+        this.position += 2;
+        return { type: "OPTIONAL_DOT" /* OPTIONAL_DOT */, value: "?.", position: start };
+    }
+    this.position++;
+    switch (char) {
+      case "+":
+        return { type: "PLUS" /* PLUS */, value: "+", position: start };
+      case "-":
+        return { type: "MINUS" /* MINUS */, value: "-", position: start };
+      case "*":
+        return { type: "MULTIPLY" /* MULTIPLY */, value: "*", position: start };
+      case "/":
+        return { type: "DIVIDE" /* DIVIDE */, value: "/", position: start };
+      case "%":
+        return { type: "MODULO" /* MODULO */, value: "%", position: start };
+      case ">":
+        return { type: "GREATER" /* GREATER */, value: ">", position: start };
+      case "<":
+        return { type: "LESS" /* LESS */, value: "<", position: start };
+      case "!":
+        return { type: "NOT" /* NOT */, value: "!", position: start };
+      case ".":
+        return { type: "DOT" /* DOT */, value: ".", position: start };
+      case ",":
+        return { type: "COMMA" /* COMMA */, value: ",", position: start };
+      case ":":
+        return { type: "COLON" /* COLON */, value: ":", position: start };
+      case "(":
+        return { type: "LPAREN" /* LPAREN */, value: "(", position: start };
+      case ")":
+        return { type: "RPAREN" /* RPAREN */, value: ")", position: start };
+      case "[":
+        return { type: "LBRACKET" /* LBRACKET */, value: "[", position: start };
+      case "]":
+        return { type: "RBRACKET" /* RBRACKET */, value: "]", position: start };
+      case "{":
+        return { type: "LBRACE" /* LBRACE */, value: "{", position: start };
+      case "}":
+        return { type: "RBRACE" /* RBRACE */, value: "}", position: start };
+      case "?":
+        return { type: "QUESTION" /* QUESTION */, value: "?", position: start };
+      default:
+        throw new ExpressionParserError(`Unexpected character: ${char}`, start, this.expression);
+    }
+  }
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/parser.ts
+var Parser = class {
+  tokens = [];
+  current = 0;
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  /** Parse the expression into an AST */
+  parse() {
+    const tokenizer = new Tokenizer(this.expression);
+    this.tokens = tokenizer.tokenize();
+    this.current = 0;
+    if (this.isAtEnd()) {
+      throw new ExpressionParserError("Empty expression", 0, this.expression);
+    }
+    const result = this.parseExpression();
+    if (!this.isAtEnd()) {
+      const token = this.peek();
+      throw new ExpressionParserError(
+        `Unexpected token '${token.value}' at position ${token.position} \u2014 expression has trailing content`,
+        token.position,
+        this.expression
+      );
+    }
+    return result;
+  }
+  parseExpression() {
+    const arrow = this.tryParseArrowFunction();
+    if (arrow) return arrow;
+    return this.parseConditional();
+  }
+  /**
+   * Ternary `test ? consequent : alternate` — right-associative, sits between
+   * the arrow-function check and logical-or in precedence.
+   */
+  parseConditional() {
+    const test = this.parseShortCircuit();
+    if (!this.match("QUESTION" /* QUESTION */)) return test;
+    const consequent = this.parseExpression();
+    this.consume("COLON" /* COLON */, 'Expected ":" between ternary branches');
+    const alternate = this.parseExpression();
+    return { type: "Conditional", test, consequent, alternate };
+  }
+  /**
+   * Attempts to parse an arrow function. Returns null and leaves position
+   * unchanged if the next tokens don't form an arrow function head.
+   */
+  tryParseArrowFunction() {
+    const savedPos = this.current;
+    if (this.check("IDENTIFIER" /* IDENTIFIER */) && this.checkAt(this.current + 1, "ARROW" /* ARROW */)) {
+      const param = this.advance().value;
+      this.advance();
+      const body = this.parseExpression();
+      return { type: "ArrowFunction", params: [param], body };
+    }
+    if (this.check("LPAREN" /* LPAREN */)) {
+      this.advance();
+      const params = [];
+      if (this.check("RPAREN" /* RPAREN */)) {
+        this.advance();
+      } else if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+        params.push(this.advance().value);
+        while (this.check("COMMA" /* COMMA */)) {
+          this.advance();
+          if (!this.check("IDENTIFIER" /* IDENTIFIER */)) {
+            this.current = savedPos;
+            return null;
+          }
+          params.push(this.advance().value);
+        }
+        if (!this.check("RPAREN" /* RPAREN */)) {
+          this.current = savedPos;
+          return null;
+        }
+        this.advance();
+      } else {
+        this.current = savedPos;
+        return null;
+      }
+      if (!this.check("ARROW" /* ARROW */)) {
+        this.current = savedPos;
+        return null;
+      }
+      this.advance();
+      const body = this.parseExpression();
+      return { type: "ArrowFunction", params, body };
+    }
+    return null;
+  }
+  checkAt(index, type) {
+    if (index < 0 || index >= this.tokens.length) return false;
+    return this.tokens[index].type === type;
+  }
+  /**
+   * `a ?? b` or an `||`/`&&` chain. As in JavaScript, `??` can't be mixed with
+   * `&&` or `||` without parentheses.
+   */
+  parseShortCircuit() {
+    const first = this.parseEquality();
+    if (!this.check("NULLISH" /* NULLISH */)) {
+      const node2 = this.parseLogicalOr(first);
+      if (this.check("NULLISH" /* NULLISH */)) this.throwMixedNullish();
+      return node2;
+    }
+    let node = first;
+    while (this.match("NULLISH" /* NULLISH */)) {
+      node = { type: "BinaryOp", operator: "??", left: node, right: this.parseEquality() };
+    }
+    if (this.check("AND" /* AND */) || this.check("OR" /* OR */)) this.throwMixedNullish();
+    return node;
+  }
+  throwMixedNullish() {
+    throw new ExpressionParserError('Cannot mix "??" with "&&" or "||" without parentheses', this.peek().position, this.expression);
+  }
+  parseLogicalOr(first) {
+    let node = this.parseLogicalAnd(first);
+    while (this.match("OR" /* OR */)) {
+      const operator = this.previous().value;
+      const right = this.parseLogicalAnd();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseLogicalAnd(first) {
+    let node = first ?? this.parseEquality();
+    while (this.match("AND" /* AND */)) {
+      const operator = this.previous().value;
+      const right = this.parseEquality();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseEquality() {
+    let node = this.parseComparison();
+    while (this.match("EQUAL" /* EQUAL */, "NOT_EQUAL" /* NOT_EQUAL */)) {
+      const operator = this.previous().value;
+      const right = this.parseComparison();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseComparison() {
+    let node = this.parseAddition();
+    while (this.match("GREATER" /* GREATER */, "GREATER_EQUAL" /* GREATER_EQUAL */, "LESS" /* LESS */, "LESS_EQUAL" /* LESS_EQUAL */)) {
+      const operator = this.previous().value;
+      const right = this.parseAddition();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseAddition() {
+    let node = this.parseMultiplication();
+    while (this.match("PLUS" /* PLUS */, "MINUS" /* MINUS */)) {
+      const operator = this.previous().value;
+      const right = this.parseMultiplication();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseMultiplication() {
+    let node = this.parseUnary();
+    while (this.match("MULTIPLY" /* MULTIPLY */, "DIVIDE" /* DIVIDE */, "MODULO" /* MODULO */)) {
+      const operator = this.previous().value;
+      const right = this.parseUnary();
+      node = { type: "BinaryOp", operator, left: node, right };
+    }
+    return node;
+  }
+  parseUnary() {
+    if (this.match("NOT" /* NOT */, "MINUS" /* MINUS */, "PLUS" /* PLUS */)) {
+      const operator = this.previous().value;
+      const operand = this.parseUnary();
+      return { type: "UnaryOp", operator, operand };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let node = this.parsePrimary();
+    while (true) {
+      if (this.match("DOT" /* DOT */)) {
+        if (!this.check("IDENTIFIER" /* IDENTIFIER */)) {
+          throw new ExpressionParserError('Expected property name after "."', this.peek().position, this.expression);
+        }
+        const property = this.advance().value;
+        node = { type: "MemberAccess", object: node, property };
+      } else if (this.match("OPTIONAL_DOT" /* OPTIONAL_DOT */)) {
+        if (this.match("LBRACKET" /* LBRACKET */)) {
+          const property = this.parseExpression();
+          this.consume("RBRACKET" /* RBRACKET */, 'Expected "]" after computed property');
+          node = { type: "ComputedMemberAccess", object: node, property, optional: true };
+        } else if (this.match("LPAREN" /* LPAREN */)) {
+          const args = this.parseArgumentList();
+          this.consume("RPAREN" /* RPAREN */, 'Expected ")" after arguments');
+          node = { type: "CallExpression", callee: node, arguments: args, optional: true };
+        } else if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
+          const property = this.advance().value;
+          node = { type: "MemberAccess", object: node, property, optional: true };
+        } else {
+          throw new ExpressionParserError('Expected property name, "[", or "(" after "?."', this.peek().position, this.expression);
+        }
+      } else if (this.match("LBRACKET" /* LBRACKET */)) {
+        const property = this.parseExpression();
+        this.consume("RBRACKET" /* RBRACKET */, 'Expected "]" after computed property');
+        node = { type: "ComputedMemberAccess", object: node, property };
+      } else if (this.match("LPAREN" /* LPAREN */)) {
+        const args = this.parseArgumentList();
+        this.consume("RPAREN" /* RPAREN */, 'Expected ")" after arguments');
+        node = { type: "CallExpression", callee: node, arguments: args };
+      } else {
+        break;
+      }
+    }
+    return node;
+  }
+  parsePrimary() {
+    if (this.match("TRUE" /* TRUE */)) {
+      return { type: "Literal", value: true };
+    }
+    if (this.match("FALSE" /* FALSE */)) {
+      return { type: "Literal", value: false };
+    }
+    if (this.match("NULL" /* NULL */)) {
+      return { type: "Literal", value: null };
+    }
+    if (this.match("UNDEFINED" /* UNDEFINED */)) {
+      return { type: "Literal", value: void 0 };
+    }
+    if (this.match("NUMBER" /* NUMBER */)) {
+      return { type: "Literal", value: parseFloat(this.previous().value) };
+    }
+    if (this.match("STRING" /* STRING */)) {
+      return { type: "Literal", value: this.previous().value };
+    }
+    if (this.match("LBRACKET" /* LBRACKET */)) {
+      const elements = this.parseArrayElements();
+      this.consume("RBRACKET" /* RBRACKET */, 'Expected "]" after array elements');
+      return { type: "ArrayLiteral", elements };
+    }
+    if (this.match("LBRACE" /* LBRACE */)) {
+      const properties = this.parseObjectProperties();
+      this.consume("RBRACE" /* RBRACE */, 'Expected "}" after object properties');
+      return { type: "ObjectLiteral", properties };
+    }
+    if (this.match("IDENTIFIER" /* IDENTIFIER */)) {
+      return { type: "Identifier", name: this.previous().value };
+    }
+    if (this.match("LPAREN" /* LPAREN */)) {
+      const expr = this.parseExpression();
+      this.consume("RPAREN" /* RPAREN */, 'Expected ")" after expression');
+      return expr;
+    }
+    throw new ExpressionParserError(`Unexpected token: ${this.peek().value}`, this.peek().position, this.expression);
+  }
+  parseArgumentList() {
+    const args = [];
+    if (!this.check("RPAREN" /* RPAREN */)) {
+      do {
+        args.push(this.parseExpression());
+      } while (this.match("COMMA" /* COMMA */));
+    }
+    return args;
+  }
+  parseArrayElements() {
+    const elements = [];
+    if (!this.check("RBRACKET" /* RBRACKET */)) {
+      do {
+        elements.push(this.parseExpression());
+      } while (this.match("COMMA" /* COMMA */));
+    }
+    return elements;
+  }
+  parseObjectProperties() {
+    const properties = [];
+    if (this.check("RBRACE" /* RBRACE */)) {
+      return properties;
+    }
+    do {
+      if (this.check("RBRACE" /* RBRACE */)) break;
+      let key;
+      if (this.check("IDENTIFIER" /* IDENTIFIER */) || this.check("STRING" /* STRING */)) {
+        key = this.advance().value;
+      } else {
+        throw new ExpressionParserError(
+          `Expected property name (identifier or string) in object literal, got '${this.peek().value}'`,
+          this.peek().position,
+          this.expression
+        );
+      }
+      this.consume("COLON" /* COLON */, 'Expected ":" after property name in object literal');
+      const value = this.parseExpression();
+      properties.push({ key, value });
+    } while (this.match("COMMA" /* COMMA */));
+    return properties;
+  }
+  match(...types) {
+    for (const type of types) {
+      if (this.check(type)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  check(type) {
+    if (this.isAtEnd()) return false;
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd()) this.current++;
+    return this.previous();
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF" /* EOF */;
+  }
+  peek() {
+    return this.tokens[this.current];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+  consume(type, message) {
+    if (this.check(type)) return this.advance();
+    throw new ExpressionParserError(message, this.peek().position, this.expression);
+  }
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/expression-parser.ts
+var MAX_AST_CACHE_SIZE = 1e3;
+var LRUCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var astCache = new LRUCache(MAX_AST_CACHE_SIZE);
+var ExpressionParser = class {
+  /**
+   * Parse an expression string into an AST
+   * Results are cached for performance using LRU eviction
+   */
+  static parse(expression) {
+    const cached = astCache.get(expression);
+    if (cached) {
+      return cached;
+    }
+    const parser = new Parser(expression);
+    const ast = parser.parse();
+    astCache.set(expression, ast);
+    return ast;
+  }
+  /** Evaluate an expression with a given scope */
+  static evaluate(expression, scope) {
+    try {
+      const ast = this.parse(expression);
+      const evaluator = new Evaluator(scope, expression);
+      return evaluator.evaluate(ast);
+    } catch (error) {
+      if (error instanceof ExpressionParserError) {
+        throw error;
+      }
+      throw new ExpressionParserError(
+        `Error evaluating expression: ${error instanceof Error ? error.message : String(error)}`,
+        0,
+        expression
+      );
+    }
+  }
+  /** Clear the AST cache */
+  static clearCache() {
+    astCache.clear();
+  }
+  /** Get cache statistics */
+  static getCacheStats() {
+    return {
+      size: astCache.size,
+      maxSize: MAX_AST_CACHE_SIZE
+    };
+  }
+};
+
+// packages/dynamic-forms/internal/src/lib/core/expressions/parser/static-check.ts
+var CONDITION_SCOPE_VARIABLES = /* @__PURE__ */ new Set([
+  "fieldValue",
+  "formValue",
+  "fieldPath",
+  "customFunctions",
+  "groupValue",
+  "rootFormValue",
+  "arrayIndex",
+  "arrayPath",
+  "externalData",
+  "fieldState",
+  "formFieldState"
+]);
+function findStaticExpressionProblems(ast, scope) {
+  const problems = /* @__PURE__ */ new Set();
+  const visit2 = (node, locals) => {
+    switch (node.type) {
+      case "Identifier":
+        if (!scope.has(node.name) && !locals.has(node.name)) problems.add(`'${node.name}' is not available in expressions`);
+        return;
+      case "MemberAccess":
+        visit2(node.object, locals);
+        return;
+      case "ComputedMemberAccess":
+        visit2(node.object, locals);
+        visit2(node.property, locals);
+        return;
+      case "CallExpression":
+        if (node.callee.type === "MemberAccess") {
+          if (!ALLOWED_METHOD_NAMES.has(node.callee.property)) problems.add(`method '${node.callee.property}' is not allowed`);
+        } else {
+          problems.add(`'${describeCallee(node.callee)}(...)' is a direct function call; only allowed methods can be called`);
+        }
+        visit2(node.callee.type === "MemberAccess" ? node.callee.object : node.callee, locals);
+        node.arguments.forEach((arg) => visit2(arg, locals));
+        return;
+      case "BinaryOp":
+        visit2(node.left, locals);
+        visit2(node.right, locals);
+        return;
+      case "UnaryOp":
+        visit2(node.operand, locals);
+        return;
+      case "Conditional":
+        visit2(node.test, locals);
+        visit2(node.consequent, locals);
+        visit2(node.alternate, locals);
+        return;
+      case "ArrayLiteral":
+        node.elements.forEach((element) => visit2(element, locals));
+        return;
+      case "ObjectLiteral":
+        node.properties.forEach((property) => visit2(property.value, locals));
+        return;
+      case "ArrowFunction":
+        visit2(node.body, /* @__PURE__ */ new Set([...locals, ...node.params]));
+        return;
+      case "Literal":
+        return;
+    }
+  };
+  visit2(ast, /* @__PURE__ */ new Set());
+  return [...problems];
+}
+function describeCallee(node) {
+  return node.type === "Identifier" ? node.name : "expression";
+}
+function findFieldExpressionProblems(field) {
+  const found = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  const check = (expression, path) => {
+    let problems;
+    try {
+      problems = findStaticExpressionProblems(ExpressionParser.parse(expression), CONDITION_SCOPE_VARIABLES);
+    } catch (e) {
+      problems = [e instanceof Error ? e.message : String(e)];
+    }
+    if (problems.length > 0) found.push({ path, expression, message: problems.join("; ") });
+  };
+  const visit2 = (node, path) => {
+    if (node === null || typeof node !== "object" || seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      node.forEach((item, i) => visit2(item, `${path}[${i}]`));
+      return;
+    }
+    const record = node;
+    const type = record["type"];
+    if ((type === "javascript" || type === "derivation") && typeof record["expression"] === "string") {
+      check(record["expression"], path);
+    }
+    if ((type === "and" || type === "or") && Array.isArray(record["conditions"]) && record["conditions"].length === 0) {
+      found.push({ path, message: `an empty '${type}' group never fires` });
+    }
+    for (const [key, value] of Object.entries(record)) {
+      if (key !== "fields") visit2(value, path ? `${path}.${key}` : key);
+    }
+  };
+  if (field !== null && typeof field === "object" && typeof field["derivation"] === "string") {
+    check(field["derivation"], "derivation");
+  }
+  visit2(field, "");
+  return found;
+}
+
 // internal/dynamic-forms-validation/validate/src/tools/validate-config.tool.ts
 var formConfigSchemas = {
   material: MatFormConfigSchema,
@@ -7371,11 +8442,22 @@ function preValidateConfig(config) {
       message: `Cannot mix page and non-page fields at top level. Found non-page fields: ${nonPageFields.join(", ")}. FIX: Move these fields INSIDE ${firstPageKey ? `the "${firstPageKey}" page` : "the first page"}'s fields array. In multi-page mode, hidden fields and other non-page fields must be placed inside a page (usually the first one). See: ngforge_quick_lookup topic="multi-page-gotchas"`
     });
   }
+  const reportedExpressions = /* @__PURE__ */ new Set();
   function checkField(field, path, parentType) {
     if (!field || typeof field !== "object") return;
     const f = field;
     const fieldType = f["type"];
     const fieldKey = f["key"];
+    for (const problem of findFieldExpressionProblems(field)) {
+      const problemPath = `${path}.${problem.path}`;
+      if (reportedExpressions.has(problemPath)) continue;
+      reportedExpressions.add(problemPath);
+      errors.push({
+        path: problemPath,
+        ruleId: "core/expression-syntax",
+        message: problem.expression === void 0 ? `${problem.message[0].toUpperCase()}${problem.message.slice(1)}: an empty group evaluates to false.` : `Expression '${problem.expression}' can never work: ${problem.message}. Expressions support property access, operators, ternaries and allowed methods only; use a custom function for anything else.`
+      });
+    }
     const validators = f["validators"];
     if (Array.isArray(validators)) {
       validators.forEach((validator, vIdx) => {
@@ -8113,6 +9195,7 @@ function parseConfigInput(config) {
 }
 
 // internal/dynamic-forms-validation/reporting/fix-suggestions.ts
+var EXPRESSION_SYNTAX_SUGGESTION = "Rewrite with property access, operators, `??`, ternaries and allowed methods, for example `(formValue.a ?? 0) + 1` instead of `parseInt(formValue.a)`, or move the logic into a custom function.";
 var FIX_SUGGESTIONS = {
   options: "Move `options` from `props: { options: [...] }` to field level: `{ key, type, options: [...] }`",
   label: "Remove `label` from this container field (page/group/row/array). Use a `text` field inside for headings.",
@@ -8148,6 +9231,7 @@ function pathSegments(path) {
   return path.split(/[.[\]]+/).filter((segment) => segment.length > 0 && !/^\d+$/.test(segment));
 }
 function getFixSuggestion(error) {
+  if (error.ruleId === "core/expression-syntax") return EXPRESSION_SYNTAX_SUGGESTION;
   for (const segment of pathSegments(error.path).reverse()) {
     if (FIX_SUGGESTIONS[segment]) {
       return FIX_SUGGESTIONS[segment];
@@ -8288,6 +9372,11 @@ function rule(id, summary, why) {
 var RULES = Object.freeze(
   Object.fromEntries(
     [
+      rule(
+        "core/expression-syntax",
+        "Write conditions and derivations the expression parser can run",
+        "An expression is a string, so the compiler never sees it. One using a global, a direct call or unparseable syntax evaluates to false or undefined at runtime instead of failing."
+      ),
       rule(
         "core/hidden-minimal",
         "Keep hidden fields to `key`, `type`, `value` and `className`",
@@ -8538,7 +9627,7 @@ function registerResources(server) {
 }
 
 // packages/dynamic-form-mcp/src/tools/lookup.tool.ts
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 
 // packages/dynamic-form-mcp/src/tools/data/lookup-topics.ts
 var TOPICS = {
@@ -11840,11 +12929,11 @@ Patterns: field-placement, logic-matrix, context-api, containers, multi-page-got
 Use topic="list" to see all available topics with descriptions.
 Use ngforge_search query="your question" to find topics by keyword.`,
     {
-      topic: z59.string().describe(
+      topic: z61.string().describe(
         'Topic to look up: field types (input, select, hidden, group, row, array, container, page), wrappers (wrappers, css, section, arraySection), concepts (validation, conditional, derivation, property-derivation, options-format), patterns (golden-path, pitfalls, multi-page-gotchas), or "list" to see all topics'
       ),
-      depth: z59.enum(["brief", "full", "schema"]).default("full").describe("brief=quick syntax (~20 lines), full=complete docs with examples, schema=include JSON schema"),
-      uiIntegration: z59.enum(UI_INTEGRATIONS2).optional().describe("Filter UI-specific info (only with depth=schema). material, bootstrap, primeng, ionic")
+      depth: z61.enum(["brief", "full", "schema"]).default("full").describe("brief=quick syntax (~20 lines), full=complete docs with examples, schema=include JSON schema"),
+      uiIntegration: z61.enum(UI_INTEGRATIONS2).optional().describe("Filter UI-specific info (only with depth=schema). material, bootstrap, primeng, ionic")
     },
     async ({ topic, depth, uiIntegration }) => {
       const normalizedTopic = topic.toLowerCase().trim();
@@ -11892,7 +12981,7 @@ ${nextSteps}`;
 }
 
 // packages/dynamic-form-mcp/src/tools/examples.tool.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 var PATTERNS = {
   // ========== MINIMAL PATTERNS (NEW) ==========
   "minimal-multipage": {
@@ -13973,21 +15062,24 @@ const megaFormConfig = {
           key: 'sourceA',
           type: 'input',
           label: 'Source A',
-          value: '10'
+          value: 10,
+          props: { type: 'number' }
         },
         {
           key: 'sourceB',
           type: 'input',
           label: 'Source B',
-          value: '20'
+          value: 20,
+          props: { type: 'number' }
         },
         {
           key: 'derived',
           type: 'input',
           label: 'Derived (A + B)',
           readonly: true,
+          props: { type: 'number' },
           // Self-targeting derivation - no targetField needed
-          derivation: 'parseInt(formValue.sourceA || 0) + parseInt(formValue.sourceB || 0)'
+          derivation: '(formValue.sourceA ?? 0) + (formValue.sourceB ?? 0)'
         },
 
         // CONDITIONAL VISIBILITY
@@ -14157,10 +15249,10 @@ Standard patterns: derivation, property-derivation, multi-page, conditional, val
 Use pattern="list" to see all available patterns.
 Use depth="minimal" for code-only output (no markdown).`,
     {
-      pattern: z60.string().optional().describe(
+      pattern: z62.string().optional().describe(
         'Pattern to get: minimal-multipage, minimal-array, minimal-simplified-array, minimal-conditional, minimal-validation, minimal-hidden, derivation, property-derivation, multi-page, conditional, validation, complete, mega. Use "list" to see all.'
       ),
-      depth: z60.enum(["minimal", "brief", "full", "explained"]).default("full").describe(
+      depth: z62.enum(["minimal", "brief", "full", "explained"]).default("full").describe(
         "minimal=code only (~20-50 lines), brief=code+summary, full=code+comments (default), explained=code+detailed explanation"
       )
     },
@@ -14227,7 +15319,7 @@ function extractCode(markdown) {
 // packages/dynamic-form-mcp/src/tools/validate.tool.ts
 import { access } from "node:fs/promises";
 import { dirname as dirname2, join as join2, parse, resolve } from "node:path";
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 var UI_INTEGRATIONS3 = ["material", "bootstrap", "primeng", "ionic"];
 async function projectDisabledRules(filePath) {
   return (await loadProjectRules(await nearestManifest(dirname2(filePath)))).disabled;
@@ -14299,10 +15391,10 @@ Example errors you'll see:
 - "options MUST be at FIELD level, NOT inside props"
 - "containers only support 'hidden' logic type"`,
     {
-      config: z61.union([z61.string(), z61.object({}).passthrough()]).describe(
+      config: z63.union([z63.string(), z63.object({}).passthrough()]).describe(
         "File path (.ts/.js) OR JSON string OR JSON object. Auto-detects: paths ending in .ts/.js or starting with / are treated as files."
       ),
-      uiIntegration: z61.enum(UI_INTEGRATIONS3).default("material").describe("UI library to validate against (material, bootstrap, primeng, ionic). Defaults to material.")
+      uiIntegration: z63.enum(UI_INTEGRATIONS3).default("material").describe("UI library to validate against (material, bootstrap, primeng, ionic). Defaults to material.")
     },
     async ({ config, uiIntegration }) => {
       try {
@@ -14399,7 +15491,7 @@ If validating JSON, ensure:
 }
 
 // packages/dynamic-form-mcp/src/tools/scaffold.tool.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 var UI_INTEGRATIONS4 = ["material", "bootstrap", "primeng", "ionic"];
 function parseFieldDefs(fields) {
   return fields.map((f) => {
@@ -14654,12 +15746,12 @@ Examples:
 - With groups: pages=0 groups=["address","billing"]
 - With hidden: hidden=["userId:abc123","source:web"]`,
     {
-      pages: z62.number().min(0).max(10).default(0).describe("Number of pages (0 = single-page form, 1-10 = multi-page wizard)"),
-      arrays: z62.array(z62.string()).optional().describe('Array field names for dynamic lists, e.g., ["contacts", "addresses"]'),
-      groups: z62.array(z62.string()).optional().describe('Group field names for nested objects, e.g., ["address", "billing"]'),
-      hidden: z62.array(z62.string()).optional().describe('Hidden fields as "name:value" pairs, e.g., ["userId:abc", "version:1"]'),
-      fields: z62.array(z62.string()).optional().describe('Basic fields as "name:type" pairs, e.g., ["email:input", "country:select", "age:slider"]'),
-      uiIntegration: z62.enum(UI_INTEGRATIONS4).default("material").describe("UI library (for future UI-specific props). Defaults to material.")
+      pages: z64.number().min(0).max(10).default(0).describe("Number of pages (0 = single-page form, 1-10 = multi-page wizard)"),
+      arrays: z64.array(z64.string()).optional().describe('Array field names for dynamic lists, e.g., ["contacts", "addresses"]'),
+      groups: z64.array(z64.string()).optional().describe('Group field names for nested objects, e.g., ["address", "billing"]'),
+      hidden: z64.array(z64.string()).optional().describe('Hidden fields as "name:value" pairs, e.g., ["userId:abc", "version:1"]'),
+      fields: z64.array(z64.string()).optional().describe('Basic fields as "name:type" pairs, e.g., ["email:input", "country:select", "age:slider"]'),
+      uiIntegration: z64.enum(UI_INTEGRATIONS4).default("material").describe("UI library (for future UI-specific props). Defaults to material.")
     },
     async ({ pages, arrays = [], groups = [], hidden = [], fields = [] }) => {
       const fieldDefs = parseFieldDefs(fields);
@@ -14701,7 +15793,7 @@ Examples:
 }
 
 // packages/dynamic-form-mcp/src/tools/search.tool.ts
-import { z as z63 } from "zod";
+import { z as z65 } from "zod";
 var searchIndex = null;
 function getTopicSubcategory(key) {
   const fieldTypes = ["input", "select", "slider", "radio", "checkbox", "textarea", "datepicker", "toggle", "text", "hidden"];
@@ -14862,7 +15954,7 @@ Use this when you don't know the exact topic name.
 
 New to ng-forge? Start with: ngforge_lookup topic="workflow"`,
     {
-      query: z63.string().describe("Natural language or keywords to search for")
+      query: z65.string().describe("Natural language or keywords to search for")
     },
     async ({ query }) => {
       const index = buildIndex();