@mathscan/math-exercise-engine 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -7,6 +7,41 @@ import { IToken } from 'chevrotain';
 import { RefAttributes } from 'react';
 import { z } from 'zod';
 
+/**
+ * AST Node Types
+ *
+ * These are the internal AST representation types used during parsing.
+ */
+export declare const AST_TYPES: {
+    /** Regular text without special formatting */
+    readonly FREE_TEXT: "FreeText";
+    /** Explicit spacing element */
+    readonly SPACE: "Space";
+    /** Text with optional character-range highlighting */
+    readonly HIGHLIGHTED_TEXT: "HighlightedText";
+    /** Inline input widget (string or numeric) */
+    readonly INLINE_INPUT: "InlineInput";
+    /** Question/instruction text block */
+    readonly TEXT_BLOCK: "TextBlock";
+    /** Line containing inline elements */
+    readonly LINE_BLOCK: "LineBlock";
+    /** Drag-and-drop options tool */
+    readonly DRAG_OPTIONS: "DragOptions";
+    /** Numeric keypad input tool */
+    readonly NUMERIC_KEYPAD: "NumericKeypad";
+    /** Simple answer matching validation */
+    readonly SIMPLE_VALIDATION: "SimpleValidation";
+    /** Expression-based validation */
+    readonly EXPRESSION_VALIDATION: "ExpressionValidation";
+    /** Root exercise document */
+    readonly EXERCISE_DOCUMENT: "ExerciseDocument";
+};
+
+/**
+ * Type helper to get all AST type values as a union type
+ */
+export declare type ASTType = typeof AST_TYPES[keyof typeof AST_TYPES];
+
 /**
  * Compile DSL text directly to JSON (convenience function)
  *
@@ -41,8 +76,8 @@ export declare function compileWithAST(dsl: string): {
         validation: {
             type: "SimpleValidation";
         } | {
-            type: "ExpressionValidation";
             expression: string;
+            type: "ExpressionValidation";
         };
         type: "ExerciseDocument";
         lines: {
@@ -54,7 +89,7 @@ export declare function compileWithAST(dsl: string): {
                 type: "Space";
             } | {
                 value: string;
-                type: "NumberText";
+                type: "HighlightedText";
                 highlight?: [number, number] | undefined;
             } | {
                 length: number;
@@ -79,13 +114,13 @@ export declare function compileWithAST(dsl: string): {
             options: string[];
         } | {
             type: "NumericKeypad";
-            includeDecimal: boolean;
-            includeNegative: boolean;
+            includeOperators?: boolean | undefined;
+            includeDecimal?: boolean | undefined;
         })[] | undefined;
     };
     json: {
         validation: {
-            mode: "expression" | "simple";
+            mode: "simple" | "expression";
             expression?: string | undefined;
             answers?: Record<string, string | number> | undefined;
             variables?: string[] | undefined;
@@ -105,7 +140,8 @@ export declare function compileWithAST(dsl: string): {
             options: string[];
         } | {
             type: "numeric-keypad";
-            includeDecimal: boolean;
+            includeOperators?: boolean | undefined;
+            includeDecimal?: boolean | undefined;
         }>;
         id?: string | undefined;
         meta?: {
@@ -138,20 +174,15 @@ export declare function createExpressionValidation(expression: string): Expressi
 export declare function createFreeText(value: string): FreeTextInline;
 
 /**
- * @deprecated Use createStringInput or createNumericInput instead
+ * Create a highlighted text inline element
  */
-export declare function createInlineInput(name: string, inputType: "string" | "numeric", lengthOrDigits: number, answer?: string | number): InlineInputWidget;
+export declare function createHighlightedText(value: string, highlight?: [number, number]): HighlightedTextInline;
 
 /**
  * Create a line block
  */
 export declare function createLineBlock(inlines: any[]): LineBlock;
 
-/**
- * Create a number text inline element
- */
-export declare function createNumberText(value: string, highlight?: [number, number]): NumberTextInline;
-
 /**
  * Create a numeric inline input widget (W_N_I)
  */
@@ -160,7 +191,7 @@ export declare function createNumericInput(name: string, digits: number, answer?
 /**
  * Create a numeric keypad tool
  */
-export declare function createNumericKeypad(includeDecimal?: boolean, includeNegative?: boolean): NumericKeypadTool;
+export declare function createNumericKeypad(includeOperators?: boolean, includeDecimal?: boolean): NumericKeypadTool;
 
 /**
  * Create a simple validation node
@@ -261,9 +292,9 @@ export declare type ExerciseDocument = z.infer<typeof ExerciseDocumentSchema>;
  *     {
  *       type: "LineBlock",
  *       inlines: [
- *         { type: "NumberText", value: "151 000", highlight: [0, 3] },
+ *         { type: "HighlightedText", value: "151 000", highlight: [0, 3] },
  *         { type: "InlineInput", name: "x", length: 1 },
- *         { type: "NumberText", value: "54 000", highlight: [0, 3] }
+ *         { type: "HighlightedText", value: "54 000", highlight: [0, 3] }
  *       ]
  *     }
  *   ],
@@ -305,16 +336,16 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
         }, {
             type: "Space";
         }>, z.ZodObject<{
-            type: z.ZodLiteral<"NumberText">;
+            type: z.ZodLiteral<"HighlightedText">;
             value: z.ZodString;
             highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
         }, "strip", z.ZodTypeAny, {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         }, {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
             type: z.ZodLiteral<"InlineInput">;
@@ -362,7 +393,7 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             type: "Space";
         } | {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         } | {
             length: number;
@@ -386,7 +417,7 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             type: "Space";
         } | {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         } | {
             length: number;
@@ -413,16 +444,16 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
         options: string[];
     }>, z.ZodObject<{
         type: z.ZodLiteral<"NumericKeypad">;
-        includeDecimal: z.ZodDefault<z.ZodBoolean>;
-        includeNegative: z.ZodDefault<z.ZodBoolean>;
+        includeOperators: z.ZodOptional<z.ZodBoolean>;
+        includeDecimal: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         type: "NumericKeypad";
-        includeDecimal: boolean;
-        includeNegative: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }, {
         type: "NumericKeypad";
+        includeOperators?: boolean | undefined;
         includeDecimal?: boolean | undefined;
-        includeNegative?: boolean | undefined;
     }>]>, "many">>;
     validation: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"SimpleValidation">;
@@ -434,18 +465,18 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
         type: z.ZodLiteral<"ExpressionValidation">;
         expression: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        type: "ExpressionValidation";
         expression: string;
-    }, {
         type: "ExpressionValidation";
+    }, {
         expression: string;
+        type: "ExpressionValidation";
     }>]>;
 }, "strip", z.ZodTypeAny, {
     validation: {
         type: "SimpleValidation";
     } | {
-        type: "ExpressionValidation";
         expression: string;
+        type: "ExpressionValidation";
     };
     type: "ExerciseDocument";
     lines: {
@@ -457,7 +488,7 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             type: "Space";
         } | {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         } | {
             length: number;
@@ -482,15 +513,15 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
         options: string[];
     } | {
         type: "NumericKeypad";
-        includeDecimal: boolean;
-        includeNegative: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     })[] | undefined;
 }, {
     validation: {
         type: "SimpleValidation";
     } | {
-        type: "ExpressionValidation";
         expression: string;
+        type: "ExpressionValidation";
     };
     type: "ExerciseDocument";
     lines: {
@@ -502,7 +533,7 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             type: "Space";
         } | {
             value: string;
-            type: "NumberText";
+            type: "HighlightedText";
             highlight?: [number, number] | undefined;
         } | {
             length: number;
@@ -527,8 +558,8 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
         options: string[];
     } | {
         type: "NumericKeypad";
+        includeOperators?: boolean | undefined;
         includeDecimal?: boolean | undefined;
-        includeNegative?: boolean | undefined;
     })[] | undefined;
 }>;
 
@@ -573,13 +604,16 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
         options: string[];
     }>, z.ZodObject<{
         type: z.ZodLiteral<"numeric-keypad">;
-        includeDecimal: z.ZodBoolean;
+        includeOperators: z.ZodOptional<z.ZodBoolean>;
+        includeDecimal: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }, {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>]>>;
     validation: z.ZodObject<{
         mode: z.ZodEnum<["simple", "expression"]>;
@@ -587,12 +621,12 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
         expression: z.ZodOptional<z.ZodString>;
         variables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
     }, {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -615,7 +649,7 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     validation: {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -635,7 +669,8 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
         options: string[];
     } | {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>;
     id?: string | undefined;
     meta?: {
@@ -646,7 +681,7 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
     } | undefined;
 }, {
     validation: {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -666,7 +701,8 @@ export declare const ExerciseJSONSchema: z.ZodObject<{
         options: string[];
     } | {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>;
     id?: string | undefined;
     meta?: {
@@ -737,11 +773,11 @@ export declare const ExpressionValidationSchema: z.ZodObject<{
     type: z.ZodLiteral<"ExpressionValidation">;
     expression: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "ExpressionValidation";
     expression: string;
-}, {
     type: "ExpressionValidation";
+}, {
     expression: string;
+    type: "ExpressionValidation";
 }>;
 
 /**
@@ -814,6 +850,53 @@ export declare const GroupItemSchema: z.ZodObject<{
     items: any[];
 }>;
 
+export declare type HighlightedText = z.infer<typeof HighlightedTextSchema>;
+
+export declare type HighlightedTextInline = z.infer<typeof HighlightedTextInlineSchema>;
+
+/**
+ * Highlighted text inline schema - text with optional highlighting
+ *
+ * highlight: [start, end] character positions for visual emphasis
+ *
+ * @example
+ * {
+ *   type: "HighlightedText",
+ *   value: "151 000",
+ *   highlight: [0, 3]  // Highlights "151"
+ * }
+ */
+export declare const HighlightedTextInlineSchema: z.ZodObject<{
+    type: z.ZodLiteral<"HighlightedText">;
+    value: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "HighlightedText";
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "HighlightedText";
+    highlight?: [number, number] | undefined;
+}>;
+
+export declare const HighlightedTextSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"highlighted-text">;
+    value: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "highlighted-text";
+    id: string;
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "highlighted-text";
+    id: string;
+    highlight?: [number, number] | undefined;
+}>;
+
 export declare type InlineInputJSON = z.infer<typeof InlineInputJSONSchema>;
 
 export declare const InlineInputJSONSchema: z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
@@ -927,16 +1010,16 @@ export declare const InlineNodeSchema: z.ZodUnion<[z.ZodObject<{
 }, {
     type: "Space";
 }>, z.ZodObject<{
-    type: z.ZodLiteral<"NumberText">;
+    type: z.ZodLiteral<"HighlightedText">;
     value: z.ZodString;
     highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
 }, "strip", z.ZodTypeAny, {
     value: string;
-    type: "NumberText";
+    type: "HighlightedText";
     highlight?: [number, number] | undefined;
 }, {
     value: string;
-    type: "NumberText";
+    type: "HighlightedText";
     highlight?: [number, number] | undefined;
 }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
     type: z.ZodLiteral<"InlineInput">;
@@ -998,6 +1081,13 @@ export declare function isGroupItem(item: LayoutItem): item is Extract<LayoutIte
     type: 'group';
 }>;
 
+/**
+ * Type guard for HighlightedText
+ */
+export declare function isHighlightedText(item: LayoutItem): item is Extract<LayoutItem, {
+    type: 'highlighted-text';
+}>;
+
 export declare function isInlineInput(value: unknown): value is InlineInputWidget;
 
 /**
@@ -1018,20 +1108,6 @@ export declare function isLinebreak(item: LayoutItem): item is Extract<LayoutIte
     type: 'linebreak';
 }>;
 
-/**
- * Type guard for NumberText
- */
-export declare function isNumberText(item: LayoutItem): item is Extract<LayoutItem, {
-    type: 'number-text';
-}>;
-
-/**
- * @deprecated Use isInlineInputJSON instead
- */
-export declare function isNumericInputJSON(widget: WidgetJSON): widget is Extract<WidgetJSON, {
-    type: 'inline-input';
-}>;
-
 export declare function isNumericKeypad(value: unknown): value is NumericKeypadTool;
 
 /**
@@ -1081,18 +1157,46 @@ export declare function isValidationNode(value: unknown): value is ValidationNod
 export declare function isValidExpression(expression: string): boolean;
 
 /**
- * @deprecated Use isWidgetRef instead
+ * Type guard for WidgetRef
  */
-export declare function isWidgetPlaceholder(item: LayoutItem): item is Extract<LayoutItem, {
+export declare function isWidgetRef(item: LayoutItem): item is Extract<LayoutItem, {
     type: 'widget-ref';
 }>;
 
 /**
- * Type guard for WidgetRef
+ * JSON Layout Item Types
+ *
+ * These are the types used in the JSON output format.
+ */
+export declare const JSON_TYPES: {
+    /** Question/instruction text */
+    readonly QUESTION_TEXT: "question-text";
+    /** Regular text element */
+    readonly TEXT: "text";
+    /** Spacing element */
+    readonly SPACE: "space";
+    /** Text with optional highlighting */
+    readonly HIGHLIGHTED_TEXT: "highlighted-text";
+    /** Reference to a widget */
+    readonly WIDGET_REF: "widget-ref";
+    /** Line break element */
+    readonly LINEBREAK: "linebreak";
+    /** Grouped layout items */
+    readonly GROUP: "group";
+    /** Operator symbol */
+    readonly OPERATOR: "operator";
+    /** Inline input widget (string or numeric) */
+    readonly INLINE_INPUT: "inline-input";
+    /** Drag-and-drop options widget */
+    readonly DRAG_OPTIONS: "drag-options";
+    /** Numeric keypad widget */
+    readonly NUMERIC_KEYPAD: "numeric-keypad";
+};
+
+/**
+ * Type helper to get all JSON type values as a union type
  */
-export declare function isWidgetRef(item: LayoutItem): item is Extract<LayoutItem, {
-    type: 'widget-ref';
-}>;
+export declare type JSONType = typeof JSON_TYPES[keyof typeof JSON_TYPES];
 
 export declare type LayoutItem = z.infer<typeof LayoutItemSchema>;
 
@@ -1109,6 +1213,7 @@ export declare interface LayoutRendererProps {
     values: Record<string, string>;
     droppedInputs: Set<string>;
     onChange: (widgetId: string, value: string, fromDrop?: boolean) => void;
+    onInputFocus?: (widgetId: string) => void;
 }
 
 /**
@@ -1132,9 +1237,9 @@ export declare type LineBlock = z.infer<typeof LineBlockSchema>;
  * {
  *   type: "LineBlock",
  *   inlines: [
- *     { type: "NumberText", value: "151 000", highlight: [0, 3] },
+ *     { type: "HighlightedText", value: "151 000", highlight: [0, 3] },
  *     { type: "InlineInput", name: "x", length: 1 },
- *     { type: "NumberText", value: "54 000", highlight: [0, 3] }
+ *     { type: "HighlightedText", value: "54 000", highlight: [0, 3] }
  *   ]
  * }
  */
@@ -1156,16 +1261,16 @@ export declare const LineBlockSchema: z.ZodObject<{
     }, {
         type: "Space";
     }>, z.ZodObject<{
-        type: z.ZodLiteral<"NumberText">;
+        type: z.ZodLiteral<"HighlightedText">;
         value: z.ZodString;
         highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     }, "strip", z.ZodTypeAny, {
         value: string;
-        type: "NumberText";
+        type: "HighlightedText";
         highlight?: [number, number] | undefined;
     }, {
         value: string;
-        type: "NumberText";
+        type: "HighlightedText";
         highlight?: [number, number] | undefined;
     }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
         type: z.ZodLiteral<"InlineInput">;
@@ -1213,7 +1318,7 @@ export declare const LineBlockSchema: z.ZodObject<{
         type: "Space";
     } | {
         value: string;
-        type: "NumberText";
+        type: "HighlightedText";
         highlight?: [number, number] | undefined;
     } | {
         length: number;
@@ -1237,7 +1342,7 @@ export declare const LineBlockSchema: z.ZodObject<{
         type: "Space";
     } | {
         value: string;
-        type: "NumberText";
+        type: "HighlightedText";
         highlight?: [number, number] | undefined;
     } | {
         length: number;
@@ -1267,64 +1372,20 @@ export declare const LinebreakSchema: z.ZodObject<{
     id: string;
 }>;
 
-export declare type NumberText = z.infer<typeof NumberTextSchema>;
-
-export declare type NumberTextInline = z.infer<typeof NumberTextInlineSchema>;
-
-/**
- * Number text inline schema - styled numbers with optional highlighting
- *
- * highlight: [start, end] character positions for visual emphasis
- *
- * @example
- * {
- *   type: "NumberText",
- *   value: "151 000",
- *   highlight: [0, 3]  // Highlights "151"
- * }
- */
-export declare const NumberTextInlineSchema: z.ZodObject<{
-    type: z.ZodLiteral<"NumberText">;
-    value: z.ZodString;
-    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
-}, "strip", z.ZodTypeAny, {
-    value: string;
-    type: "NumberText";
-    highlight?: [number, number] | undefined;
-}, {
-    value: string;
-    type: "NumberText";
-    highlight?: [number, number] | undefined;
-}>;
-
-export declare const NumberTextSchema: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"number-text">;
-    value: z.ZodString;
-    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
-}, "strip", z.ZodTypeAny, {
-    value: string;
-    type: "number-text";
-    id: string;
-    highlight?: [number, number] | undefined;
-}, {
-    value: string;
-    type: "number-text";
-    id: string;
-    highlight?: [number, number] | undefined;
-}>;
-
 export declare type NumericKeypadJSON = z.infer<typeof NumericKeypadJSONSchema>;
 
 export declare const NumericKeypadJSONSchema: z.ZodObject<{
     type: z.ZodLiteral<"numeric-keypad">;
-    includeDecimal: z.ZodBoolean;
+    includeOperators: z.ZodOptional<z.ZodBoolean>;
+    includeDecimal: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }, {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }>;
 
 export declare type NumericKeypadTool = z.infer<typeof NumericKeypadToolSchema>;
@@ -1340,22 +1401,21 @@ export declare type NumericKeypadTool = z.infer<typeof NumericKeypadToolSchema>;
  * @example
  * {
  *   type: "NumericKeypad",
- *   includeDecimal: false,
- *   includeNegative: true
+ *   includeOperators: true
  * }
  */
 export declare const NumericKeypadToolSchema: z.ZodObject<{
     type: z.ZodLiteral<"NumericKeypad">;
-    includeDecimal: z.ZodDefault<z.ZodBoolean>;
-    includeNegative: z.ZodDefault<z.ZodBoolean>;
+    includeOperators: z.ZodOptional<z.ZodBoolean>;
+    includeDecimal: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "NumericKeypad";
-    includeDecimal: boolean;
-    includeNegative: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }, {
     type: "NumericKeypad";
+    includeOperators?: boolean | undefined;
     includeDecimal?: boolean | undefined;
-    includeNegative?: boolean | undefined;
 }>;
 
 export declare type OperatorItem = z.infer<typeof OperatorItemSchema>;
@@ -1365,13 +1425,13 @@ export declare const OperatorItemSchema: z.ZodObject<{
     type: z.ZodLiteral<"operator">;
     operator: z.ZodEnum<["+", "-", "×", "÷", "=", "<", ">", "?"]>;
 }, "strip", z.ZodTypeAny, {
+    operator: "+" | "-" | "×" | "÷" | "=" | "<" | ">" | "?";
     type: "operator";
     id: string;
-    operator: "+" | "-" | "×" | "÷" | "=" | "<" | ">" | "?";
 }, {
+    operator: "+" | "-" | "×" | "÷" | "=" | "<" | ">" | "?";
     type: "operator";
     id: string;
-    operator: "+" | "-" | "×" | "÷" | "=" | "<" | ">" | "?";
 }>;
 
 export declare const OperatorSchema: z.ZodEnum<["+", "-", "×", "÷", "=", "<", ">", "?"]>;
@@ -1595,16 +1655,16 @@ export declare const ToolNodeSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObjec
     options: string[];
 }>, z.ZodObject<{
     type: z.ZodLiteral<"NumericKeypad">;
-    includeDecimal: z.ZodDefault<z.ZodBoolean>;
-    includeNegative: z.ZodDefault<z.ZodBoolean>;
+    includeOperators: z.ZodOptional<z.ZodBoolean>;
+    includeDecimal: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "NumericKeypad";
-    includeDecimal: boolean;
-    includeNegative: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }, {
     type: "NumericKeypad";
+    includeOperators?: boolean | undefined;
     includeDecimal?: boolean | undefined;
-    includeNegative?: boolean | undefined;
 }>]>;
 
 /**
@@ -1664,7 +1724,7 @@ export declare function validateBooleanExpression(expression: string): string |
  */
 export declare function validateExerciseJSON(data: unknown): {
     validation: {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -1684,7 +1744,8 @@ export declare function validateExerciseJSON(data: unknown): {
         options: string[];
     } | {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>;
     id?: string | undefined;
     meta?: {
@@ -1713,7 +1774,7 @@ export declare function validateExerciseJSON(data: unknown): {
  */
 export declare function validateExerciseJSONSafe(data: unknown): z.SafeParseReturnType<{
     validation: {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -1733,7 +1794,8 @@ export declare function validateExerciseJSONSafe(data: unknown): z.SafeParseRetu
         options: string[];
     } | {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>;
     id?: string | undefined;
     meta?: {
@@ -1744,7 +1806,7 @@ export declare function validateExerciseJSONSafe(data: unknown): z.SafeParseRetu
     } | undefined;
 }, {
     validation: {
-        mode: "expression" | "simple";
+        mode: "simple" | "expression";
         expression?: string | undefined;
         answers?: Record<string, string | number> | undefined;
         variables?: string[] | undefined;
@@ -1764,7 +1826,8 @@ export declare function validateExerciseJSONSafe(data: unknown): z.SafeParseRetu
         options: string[];
     } | {
         type: "numeric-keypad";
-        includeDecimal: boolean;
+        includeOperators?: boolean | undefined;
+        includeDecimal?: boolean | undefined;
     }>;
     id?: string | undefined;
     meta?: {
@@ -1823,7 +1886,8 @@ export declare function validateWidgetJSON(data: unknown): {
     options: string[];
 } | {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 };
 
 /**
@@ -1845,7 +1909,8 @@ export declare function validateWidgetJSONSafe(data: unknown): z.SafeParseReturn
     options: string[];
 } | {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }, {
     length: number;
     type: "inline-input";
@@ -1859,7 +1924,8 @@ export declare function validateWidgetJSONSafe(data: unknown): z.SafeParseReturn
     options: string[];
 } | {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }>;
 
 /**
@@ -1878,12 +1944,12 @@ export declare const ValidationJSONSchema: z.ZodObject<{
     expression: z.ZodOptional<z.ZodString>;
     variables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    mode: "expression" | "simple";
+    mode: "simple" | "expression";
     expression?: string | undefined;
     answers?: Record<string, string | number> | undefined;
     variables?: string[] | undefined;
 }, {
-    mode: "expression" | "simple";
+    mode: "simple" | "expression";
     expression?: string | undefined;
     answers?: Record<string, string | number> | undefined;
     variables?: string[] | undefined;
@@ -1904,11 +1970,11 @@ export declare const ValidationNodeSchema: z.ZodDiscriminatedUnion<"type", [z.Zo
     type: z.ZodLiteral<"ExpressionValidation">;
     expression: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "ExpressionValidation";
     expression: string;
-}, {
     type: "ExpressionValidation";
+}, {
     expression: string;
+    type: "ExpressionValidation";
 }>]>;
 
 /**
@@ -1966,18 +2032,19 @@ export declare const WidgetJSONSchema: z.ZodUnion<[z.ZodDiscriminatedUnion<"inpu
     options: string[];
 }>, z.ZodObject<{
     type: z.ZodLiteral<"numeric-keypad">;
-    includeDecimal: z.ZodBoolean;
+    includeOperators: z.ZodOptional<z.ZodBoolean>;
+    includeDecimal: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }, {
     type: "numeric-keypad";
-    includeDecimal: boolean;
+    includeOperators?: boolean | undefined;
+    includeDecimal?: boolean | undefined;
 }>]>;
 
-declare type WidgetRef = z.infer<typeof WidgetRefSchema>;
-export { WidgetRef as WidgetPlaceholder }
-export { WidgetRef }
+export declare type WidgetRef = z.infer<typeof WidgetRefSchema>;
 
 export declare const WidgetRefSchema: z.ZodObject<{
     id: z.ZodString;
@@ -2006,6 +2073,8 @@ export declare interface WidgetRendererProps {
     value: string;
     isDropped?: boolean;
     onChange: (widgetId: string, value: string, fromDrop?: boolean) => void;
+    onInputFocus?: (widgetId: string) => void;
+    onKeypadChange?: (value: string) => void;
 }
 
 /**