@halleyassist/rule-templater 0.0.14 → 0.0.16

package/README.md

@@ -305,6 +305,25 @@ const result = parsed.prepare({ EVENT: { value: 'test' } });
 // Result: EventIs(tset)
 ```
 
+### `VariableValidate`
+
+BNF-backed validators for each supported variable type.
+
+**Example:**
+```javascript
+const { VariableValidate } = require('@halleyassist/rule-templater');
+
+const result = VariableValidate.validate({
+    value: { from: '08:00', to: '12:00', ago: [2, 'HOURS'] },
+    type: 'time period ago'
+});
+
+console.log(result.valid);
+// true
+```
+
+Use `VariableValidate.validateValue(type, value)` to validate a raw value against a specific variable type.
+
 ## Variable Types
 
 The following variable types are supported:
@@ -316,6 +335,7 @@ The following variable types are supported:
 - `time period`
 - `time period ago`
 - `time value`
+- `number time`
 - `string array`
 - `number array`
 - `boolean array`

package/dist/rule-templater.browser.js

@@ -3645,12 +3645,66 @@ exports.Grammars = require("./Grammars");
 
 },{"./Grammars":8,"./Parser":9,"./ParsingError":10,"./TokenError":12}],14:[function(require,module,exports){
 module.exports = require('./RuleTemplate.production.js');
-},{"./RuleTemplate.production.js":16}],15:[function(require,module,exports){
-module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]}]
-},{}],16:[function(require,module,exports){
+},{"./RuleTemplate.production.js":17}],15:[function(require,module,exports){
+const {Grammars} = require('ebnf');
+
+const grammar = `
+    TEMPLATE_BEGIN       ::= "\${"
+    TEMPLATE_END         ::= "}"
+    PIPE                 ::= "|"
+    IDENT                ::= [A-Za-z_][A-Za-z0-9_]*
+    DOT                  ::= "."
+
+    template_value       ::= TEMPLATE_BEGIN WS* template_expr WS* TEMPLATE_END
+
+    template_expr        ::= template_path (WS* template_pipe WS* template_filter_call)*
+
+    template_pipe        ::= PIPE
+
+    template_path        ::= IDENT (WS* DOT WS* IDENT)*
+
+    template_filter_call ::= template_filter_name (WS* BEGIN_ARGUMENT WS* template_filter_args? WS* END_ARGUMENT)?
+
+    template_filter_name ::= IDENT
+
+    template_filter_args ::= template_filter_arg (WS* "," WS* template_filter_arg)*
+
+    template_filter_arg  ::= value | template_value
+
+    number_atom          ::= number | template_value
+    number_time_atom     ::= number_time | template_value WS+ unit | template_value
+    tod_atom             ::= number_tod | template_value
+    dow_atom             ::= dow | template_value
+    between_time_only_atom ::= between_time_only | template_value
+    between_tod_only_atom  ::= between_tod_only | template_value
+
+    string_atom          ::= string
+    boolean_atom         ::= false | true
+    time_value_atom      ::= number_tod
+    time_period_atom     ::= time_value_atom WS* "TO" WS* time_value_atom
+    time_period_ago_atom ::= time_value_atom WS* "TO" WS* time_value_atom WS+ AGO WS+ number WS+ unit
+
+    object_atom          ::= json_object
+    json_value           ::= string | number | false | true | null | json_array | json_object
+    json_member          ::= string NAME_SEPARATOR json_value
+    json_object          ::= BEGIN_OBJECT (json_member (VALUE_SEPARATOR json_member)*)? END_OBJECT
+    json_array           ::= BEGIN_ARRAY (json_value (VALUE_SEPARATOR json_value)*)? END_ARRAY
+
+    string_array         ::= BEGIN_ARRAY (string (VALUE_SEPARATOR string)*)? END_ARRAY
+    number_array         ::= BEGIN_ARRAY (number (VALUE_SEPARATOR number)*)? END_ARRAY
+    boolean_array        ::= BEGIN_ARRAY (boolean_atom (VALUE_SEPARATOR boolean_atom)*)? END_ARRAY
+    object_array         ::= BEGIN_ARRAY (json_object (VALUE_SEPARATOR json_object)*)? END_ARRAY
+`
+
+module.exports = Grammars.W3C.getRules(grammar);
+
+},{"ebnf":13}],16:[function(require,module,exports){
+module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]},{"name":"string_atom","bnf":[["string"]]},{"name":"boolean_atom","bnf":[["false"],["true"]]},{"name":"time_value_atom","bnf":[["number_tod"]]},{"name":"time_period_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom"]]},{"name":"time_period_ago_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom","WS+","AGO","WS+","number","WS+","unit"]]},{"name":"object_atom","bnf":[["json_object"]]},{"name":"json_value","bnf":[["string"],["number"],["false"],["true"],["null"],["json_array"],["json_object"]]},{"name":"json_member","bnf":[["string","NAME_SEPARATOR","json_value"]]},{"name":"%json_object[2][2]","bnf":[["VALUE_SEPARATOR","json_member"]],"fragment":true},{"name":"%json_object[2]","bnf":[["json_member","%json_object[2][2]*"]],"fragment":true},{"name":"json_object","bnf":[["BEGIN_OBJECT","%json_object[2]?","END_OBJECT"]]},{"name":"%json_array[2][2]","bnf":[["VALUE_SEPARATOR","json_value"]],"fragment":true},{"name":"%json_array[2]","bnf":[["json_value","%json_array[2][2]*"]],"fragment":true},{"name":"json_array","bnf":[["BEGIN_ARRAY","%json_array[2]?","END_ARRAY"]]},{"name":"%string_array[2][2]","bnf":[["VALUE_SEPARATOR","string"]],"fragment":true},{"name":"%string_array[2]","bnf":[["string","%string_array[2][2]*"]],"fragment":true},{"name":"string_array","bnf":[["BEGIN_ARRAY","%string_array[2]?","END_ARRAY"]]},{"name":"%number_array[2][2]","bnf":[["VALUE_SEPARATOR","number"]],"fragment":true},{"name":"%number_array[2]","bnf":[["number","%number_array[2][2]*"]],"fragment":true},{"name":"number_array","bnf":[["BEGIN_ARRAY","%number_array[2]?","END_ARRAY"]]},{"name":"%boolean_array[2][2]","bnf":[["VALUE_SEPARATOR","boolean_atom"]],"fragment":true},{"name":"%boolean_array[2]","bnf":[["boolean_atom","%boolean_array[2][2]*"]],"fragment":true},{"name":"boolean_array","bnf":[["BEGIN_ARRAY","%boolean_array[2]?","END_ARRAY"]]},{"name":"%object_array[2][2]","bnf":[["VALUE_SEPARATOR","json_object"]],"fragment":true},{"name":"%object_array[2]","bnf":[["json_object","%object_array[2][2]*"]],"fragment":true},{"name":"object_array","bnf":[["BEGIN_ARRAY","%object_array[2]?","END_ARRAY"]]}]
+},{}],17:[function(require,module,exports){
 // Note: We are coupled closely with the ebnf grammar structure of rule-parser
 const TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
       TemplateFilters = require('./TemplateFilters'),
+    VariableValidate = require('./VariableValidate'),
       RuleParser = require('@halleyassist/rule-parser'),
       RuleParserRules = RuleParser.ParserRules,
       {Parser} = require('ebnf');
@@ -3897,6 +3951,14 @@ class RuleTemplate {
             // Validate type if provided
             if (type && !VariableTypes.includes(type)) {
                 errors.push(`Invalid variable type '${type}' for variable '${varName}'`);
+                continue;
+            }
+
+            if (type) {
+                const validation = VariableValidate.validate(varData);
+                if (!validation.valid) {
+                    errors.push(`Invalid value for variable '${varName}': ${validation.error}`);
+                }
             }
         }
         
@@ -4017,6 +4079,11 @@ class RuleTemplate {
             }
         }
 
+        const validation = VariableValidate.validate(varData);
+        if (!validation.valid) {
+            throw new Error(`Invalid value for variable '${varName}': ${validation.error}`);
+        }
+
         return this._serializeVarData(varData, varName);
     }
 
@@ -4047,6 +4114,10 @@ class RuleTemplate {
             return ret;
         }
 
+        if (type === 'object' || type === 'string array' || type === 'number array' || type === 'boolean array' || type === 'object array') {
+            return JSON.stringify(value);
+        }
+
         return String(value);
     }
 
@@ -4073,10 +4144,11 @@ class RuleTemplate {
 RuleTemplate.ParserRules = ParserRules;
 RuleTemplate.VariableTypes = VariableTypes;
 RuleTemplate.TemplateFilters = TemplateFilters;
+RuleTemplate.VariableValidate = VariableValidate;
 
 module.exports = RuleTemplate;
 
-},{"./RuleTemplate.production.ebnf.js":15,"./TemplateFilters":17,"@halleyassist/rule-parser":2,"ebnf":13}],17:[function(require,module,exports){
+},{"./RuleTemplate.production.ebnf.js":16,"./TemplateFilters":18,"./VariableValidate":19,"@halleyassist/rule-parser":2,"ebnf":13}],18:[function(require,module,exports){
 /*
 Template filters are functions that transform variable values.
 They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
@@ -4236,5 +4308,405 @@ const TemplateFilters = {
 }
 
 module.exports = TemplateFilters;
-},{}]},{},[14])(14)
+},{}],19:[function(require,module,exports){
+const { Parser } = require('ebnf');
+const TemplateGrammar = require('./RuleTemplate.ebnf');
+const TemplateFilters = require('./TemplateFilters');
+const RuleParser = require('@halleyassist/rule-parser');
+const RuleParserRules = RuleParser.ParserRules;
+
+const VariableTypes = [
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'time period',
+    'time period ago',
+    'time value',
+    'number time',
+    'string array',
+    'number array',
+    'boolean array',
+    'object array'
+];
+
+let ParserCache = null;
+
+const ValidationRules = [...RuleParserRules];
+for (const rule of TemplateGrammar) {
+    const idx = ValidationRules.findIndex(existingRule => existingRule.name === rule.name);
+    if (idx !== -1) {
+        ValidationRules[idx] = rule;
+    } else {
+        ValidationRules.push(rule);
+    }
+}
+
+class VariableValidate {
+    static validate(variableData) {
+        if (!variableData || typeof variableData !== 'object' || Array.isArray(variableData)) {
+            return {
+                valid: false,
+                error: 'Variable data must be an object with value and type properties'
+            };
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(variableData, 'type')) {
+            return {
+                valid: false,
+                error: 'Variable data must include a type property'
+            };
+        }
+
+        let normalizedVarData;
+        try {
+            normalizedVarData = VariableValidate._normalizeVarData(variableData);
+        } catch (error) {
+            return {
+                valid: false,
+                error: error.message
+            };
+        }
+
+        return VariableValidate.validateValue(normalizedVarData.type, normalizedVarData.value);
+    }
+
+    static validateValue(type, value) {
+        const validator = VariableValidate.validators[type];
+        if (!validator) {
+            return {
+                valid: false,
+                error: `Unsupported variable type '${type}'`
+            };
+        }
+
+        try {
+            return validator(value);
+        } catch (error) {
+            return {
+                valid: false,
+                error: error.message
+            };
+        }
+    }
+
+    static isValid(type, value) {
+        return VariableValidate.validateValue(type, value).valid;
+    }
+
+    static _validateWithRule(value, startRule, options = {}) {
+        const parser = VariableValidate._getParser();
+        const normalized = options.normalize ? options.normalize(value) : value;
+
+        if (typeof normalized !== 'string' || !normalized.length) {
+            return {
+                valid: false,
+                error: options.emptyMessage || `Expected ${startRule} input`
+            };
+        }
+
+        try {
+            parser.getAST(normalized, startRule);
+        } catch (error) {
+            return {
+                valid: false,
+                error: options.parseMessage || error.message
+            };
+        }
+
+        if (options.semanticCheck) {
+            const semanticError = options.semanticCheck(value, normalized);
+            if (semanticError) {
+                return {
+                    valid: false,
+                    error: semanticError
+                };
+            }
+        }
+
+        return { valid: true };
+    }
+
+    static _getParser() {
+        if (!ParserCache) {
+            ParserCache = new Parser(ValidationRules, { debug: false });
+        }
+
+        return ParserCache;
+    }
+
+    static _normalizeVarData(variableData) {
+        const normalizedVarData = VariableValidate._cloneVarData(variableData);
+
+        if (!Object.prototype.hasOwnProperty.call(normalizedVarData, 'value')) {
+            throw new Error('Variable data must include a value property');
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(normalizedVarData, 'filters')) {
+            return normalizedVarData;
+        }
+
+        if (!Array.isArray(normalizedVarData.filters)) {
+            throw new Error('Variable data filters must be an array');
+        }
+
+        for (const filterName of normalizedVarData.filters) {
+            if (!TemplateFilters[filterName]) {
+                throw new Error(`Unknown filter '${filterName}'`);
+            }
+
+            TemplateFilters[filterName](normalizedVarData);
+        }
+
+        return normalizedVarData;
+    }
+
+    static _cloneVarData(variableData) {
+        const cloned = Object.assign({}, variableData);
+        if (Array.isArray(cloned.filters)) {
+            cloned.filters = cloned.filters.slice();
+        }
+
+        if (cloned.value && typeof cloned.value === 'object') {
+            if (Array.isArray(cloned.value)) {
+                cloned.value = cloned.value.slice();
+            } else {
+                cloned.value = Object.assign({}, cloned.value);
+            }
+        }
+
+        return cloned;
+    }
+
+    static _serializeString(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeNumber(value) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            return null;
+        }
+
+        return String(value);
+    }
+
+    static _serializeBoolean(value) {
+        if (typeof value !== 'boolean') {
+            return null;
+        }
+
+        return value ? 'true' : 'false';
+    }
+
+    static _serializeTimeValue(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return value.trim();
+    }
+
+    static _serializeTimePeriod(value) {
+        if (!VariableValidate._isPlainObject(value) || typeof value.from !== 'string' || typeof value.to !== 'string') {
+            return null;
+        }
+
+        return `${value.from.trim()} TO ${value.to.trim()}`;
+    }
+
+    static _serializeTimePeriodAgo(value) {
+        if (!VariableValidate._isPlainObject(value) || typeof value.from !== 'string' || typeof value.to !== 'string') {
+            return null;
+        }
+
+        if (!Array.isArray(value.ago) || value.ago.length !== 2) {
+            return null;
+        }
+
+        const [amount, unit] = value.ago;
+        if (typeof amount !== 'number' || !Number.isFinite(amount) || typeof unit !== 'string') {
+            return null;
+        }
+
+        return `${value.from.trim()} TO ${value.to.trim()} AGO ${amount} ${unit.trim()}`;
+    }
+
+    static _serializeNumberTime(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return value.trim();
+    }
+
+    static _serializeJsonObject(value) {
+        if (!VariableValidate._isJsonObject(value)) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeTypedArray(value, predicate) {
+        if (!Array.isArray(value) || !value.every(predicate)) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeObjectArray(value) {
+        if (!Array.isArray(value) || !value.every(item => VariableValidate._isJsonObject(item))) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _isPlainObject(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+
+    static _isJsonObject(value) {
+        if (!VariableValidate._isPlainObject(value)) {
+            return false;
+        }
+
+        return Object.values(value).every(entry => VariableValidate._isJsonValue(entry));
+    }
+
+    static _isJsonValue(value) {
+        if (value === null) {
+            return true;
+        }
+
+        if (typeof value === 'string' || typeof value === 'boolean') {
+            return true;
+        }
+
+        if (typeof value === 'number') {
+            return Number.isFinite(value);
+        }
+
+        if (Array.isArray(value)) {
+            return value.every(entry => VariableValidate._isJsonValue(entry));
+        }
+
+        if (VariableValidate._isPlainObject(value)) {
+            return Object.values(value).every(entry => VariableValidate._isJsonValue(entry));
+        }
+
+        return false;
+    }
+
+    static _validateTimeOfDay(value) {
+        if (typeof value !== 'string') {
+            return 'Time value must be a string in HH:MM format';
+        }
+
+        const match = value.trim().match(/^(\d{1,2}):(\d{1,2})$/);
+        if (!match) {
+            return 'Time value must be a string in HH:MM format';
+        }
+
+        const hours = Number(match[1]);
+        const minutes = Number(match[2]);
+
+        if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+            return 'Time value must contain hours 0-23 and minutes 0-59';
+        }
+
+        return null;
+    }
+}
+
+VariableValidate.VariableTypes = VariableTypes.slice();
+VariableValidate.validators = Object.freeze({
+    'string': (value) => VariableValidate._validateWithRule(value, 'string_atom', {
+        normalize: VariableValidate._serializeString,
+        emptyMessage: 'String variables must be JavaScript strings',
+        parseMessage: 'String variables must serialize to a valid quoted string literal'
+    }),
+    'number': (value) => VariableValidate._validateWithRule(value, 'number', {
+        normalize: VariableValidate._serializeNumber,
+        emptyMessage: 'Number variables must be finite numbers',
+        parseMessage: 'Number variables must serialize to a valid numeric literal'
+    }),
+    'boolean': (value) => VariableValidate._validateWithRule(value, 'boolean_atom', {
+        normalize: VariableValidate._serializeBoolean,
+        emptyMessage: 'Boolean variables must be JavaScript booleans',
+        parseMessage: 'Boolean variables must serialize to a valid boolean literal'
+    }),
+    'object': (value) => VariableValidate._validateWithRule(value, 'object_atom', {
+        normalize: VariableValidate._serializeJsonObject,
+        emptyMessage: 'Object variables must be plain JSON-compatible objects',
+        parseMessage: 'Object variables must serialize to valid JSON object syntax'
+    }),
+    'time period': (value) => VariableValidate._validateWithRule(value, 'time_period_atom', {
+        normalize: VariableValidate._serializeTimePeriod,
+        emptyMessage: 'Time period variables must be objects with string from/to properties',
+        parseMessage: 'Time period variables must serialize to FROM TO TO syntax',
+        semanticCheck: (rawValue) => {
+            const fromError = VariableValidate._validateTimeOfDay(rawValue?.from);
+            if (fromError) return `Invalid time period from value: ${fromError}`;
+
+            const toError = VariableValidate._validateTimeOfDay(rawValue?.to);
+            if (toError) return `Invalid time period to value: ${toError}`;
+
+            return null;
+        }
+    }),
+    'time period ago': (value) => VariableValidate._validateWithRule(value, 'time_period_ago_atom', {
+        normalize: VariableValidate._serializeTimePeriodAgo,
+        emptyMessage: 'Time period ago variables must be objects with from, to, and ago properties',
+        parseMessage: 'Time period ago variables must serialize to FROM TO TO AGO AMOUNT UNIT syntax',
+        semanticCheck: (rawValue) => {
+            const fromError = VariableValidate._validateTimeOfDay(rawValue?.from);
+            if (fromError) return `Invalid time period ago from value: ${fromError}`;
+
+            const toError = VariableValidate._validateTimeOfDay(rawValue?.to);
+            if (toError) return `Invalid time period ago to value: ${toError}`;
+
+            return null;
+        }
+    }),
+    'time value': (value) => VariableValidate._validateWithRule(value, 'time_value_atom', {
+        normalize: VariableValidate._serializeTimeValue,
+        emptyMessage: 'Time value variables must be strings in HH:MM format',
+        parseMessage: 'Time value variables must serialize to HH:MM syntax',
+        semanticCheck: (rawValue) => VariableValidate._validateTimeOfDay(rawValue)
+    }),
+    'number time': (value) => VariableValidate._validateWithRule(value, 'number_time', {
+        normalize: VariableValidate._serializeNumberTime,
+        emptyMessage: 'Number time variables must be strings like "2 hours"',
+        parseMessage: 'Number time variables must serialize to NUMBER UNIT syntax'
+    }),
+    'string array': (value) => VariableValidate._validateWithRule(value, 'string_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'string'),
+        emptyMessage: 'String array variables must be arrays of strings',
+        parseMessage: 'String array variables must serialize to a valid string array literal'
+    }),
+    'number array': (value) => VariableValidate._validateWithRule(value, 'number_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'number' && Number.isFinite(item)),
+        emptyMessage: 'Number array variables must be arrays of finite numbers',
+        parseMessage: 'Number array variables must serialize to a valid number array literal'
+    }),
+    'boolean array': (value) => VariableValidate._validateWithRule(value, 'boolean_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'boolean'),
+        emptyMessage: 'Boolean array variables must be arrays of booleans',
+        parseMessage: 'Boolean array variables must serialize to a valid boolean array literal'
+    }),
+    'object array': (value) => VariableValidate._validateWithRule(value, 'object_array', {
+        normalize: VariableValidate._serializeObjectArray,
+        emptyMessage: 'Object array variables must be arrays of plain JSON-compatible objects',
+        parseMessage: 'Object array variables must serialize to a valid object array literal'
+    })
+});
+
+module.exports = VariableValidate;
+},{"./RuleTemplate.ebnf":15,"./TemplateFilters":18,"@halleyassist/rule-parser":2,"ebnf":13}]},{},[14])(14)
 });

package/index.d.ts

@@ -14,8 +14,9 @@ export interface VariableValue {
         from: string;
         to: string;
         ago?: [number, string];
-    };
-    type?: 'string' | 'number' | 'boolean' | 'object' | 'time period' | 'time period ago' | 'time value' | 'string array' | 'number array' | 'boolean array' | 'object array';
+    } | Record<string, any> | string[] | number[] | boolean[] | Record<string, any>[];
+    filters?: string[];
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'time period' | 'time period ago' | 'time value' | 'number time' | 'string array' | 'number array' | 'boolean array' | 'object array';
 }
 
 export interface Variables {
@@ -27,6 +28,11 @@ export interface ValidationResult {
     errors: string[];
 }
 
+export interface VariableValidationResult {
+    valid: boolean;
+    error?: string;
+}
+
 export interface ASTNode {
     type: string;
     text?: string;
@@ -139,6 +145,14 @@ export class VariableTemplate {
     format(variableData: VariableValue | Variables): VariableValue;
 }
 
+export class VariableValidate {
+    static VariableTypes: string[];
+    static validators: Record<string, (value: any) => VariableValidationResult>;
+    static validate(variableData: VariableValue): VariableValidationResult;
+    static validateValue(type: string, value: any): VariableValidationResult;
+    static isValid(type: string, value: any): boolean;
+}
+
 export const ParserRules: any[];
 export const VariableTypes: string[];
 export const TemplateFilters: TemplateFiltersType;

package/index.js

@@ -1,10 +1,12 @@
 const RuleTemplate = require('./src/RuleTemplate');
 const GeneralTemplate = require('./src/GeneralTemplate');
 const VariableTemplate = require('./src/VariableTemplate');
+const VariableValidate = require('./src/VariableValidate');
 
 module.exports.RuleTemplate = RuleTemplate;
 module.exports.ParserRules = RuleTemplate.ParserRules;
 module.exports.VariableTypes = RuleTemplate.VariableTypes;
 module.exports.TemplateFilters = RuleTemplate.TemplateFilters;
+module.exports.VariableValidate = VariableValidate;
 module.exports.GeneralTemplate = GeneralTemplate;
 module.exports.VariableTemplate = VariableTemplate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleTemplate.production.js",
   "browser": "./dist/rule-templater.browser.js",

package/src/RuleTemplate.ebnf.js

@@ -29,6 +29,23 @@ const grammar = `
     dow_atom             ::= dow | template_value
     between_time_only_atom ::= between_time_only | template_value
     between_tod_only_atom  ::= between_tod_only | template_value
+
+    string_atom          ::= string
+    boolean_atom         ::= false | true
+    time_value_atom      ::= number_tod
+    time_period_atom     ::= time_value_atom WS* "TO" WS* time_value_atom
+    time_period_ago_atom ::= time_value_atom WS* "TO" WS* time_value_atom WS+ AGO WS+ number WS+ unit
+
+    object_atom          ::= json_object
+    json_value           ::= string | number | false | true | null | json_array | json_object
+    json_member          ::= string NAME_SEPARATOR json_value
+    json_object          ::= BEGIN_OBJECT (json_member (VALUE_SEPARATOR json_member)*)? END_OBJECT
+    json_array           ::= BEGIN_ARRAY (json_value (VALUE_SEPARATOR json_value)*)? END_ARRAY
+
+    string_array         ::= BEGIN_ARRAY (string (VALUE_SEPARATOR string)*)? END_ARRAY
+    number_array         ::= BEGIN_ARRAY (number (VALUE_SEPARATOR number)*)? END_ARRAY
+    boolean_array        ::= BEGIN_ARRAY (boolean_atom (VALUE_SEPARATOR boolean_atom)*)? END_ARRAY
+    object_array         ::= BEGIN_ARRAY (json_object (VALUE_SEPARATOR json_object)*)? END_ARRAY
 `
 
 module.exports = Grammars.W3C.getRules(grammar);

package/src/RuleTemplate.js

@@ -1,6 +1,7 @@
 // Note: We are coupled closely with the ebnf grammar structure of rule-parser
 const TemplateGrammar = require('./RuleTemplate.ebnf'),
       TemplateFilters = require('./TemplateFilters'),
+    VariableValidate = require('./VariableValidate'),
       RuleParser = require('@halleyassist/rule-parser'),
       RuleParserRules = RuleParser.ParserRules,
       {Parser} = require('ebnf');
@@ -247,6 +248,14 @@ class RuleTemplate {
             // Validate type if provided
             if (type && !VariableTypes.includes(type)) {
                 errors.push(`Invalid variable type '${type}' for variable '${varName}'`);
+                continue;
+            }
+
+            if (type) {
+                const validation = VariableValidate.validate(varData);
+                if (!validation.valid) {
+                    errors.push(`Invalid value for variable '${varName}': ${validation.error}`);
+                }
             }
         }
         
@@ -367,6 +376,11 @@ class RuleTemplate {
             }
         }
 
+        const validation = VariableValidate.validate(varData);
+        if (!validation.valid) {
+            throw new Error(`Invalid value for variable '${varName}': ${validation.error}`);
+        }
+
         return this._serializeVarData(varData, varName);
     }
 
@@ -397,6 +411,10 @@ class RuleTemplate {
             return ret;
         }
 
+        if (type === 'object' || type === 'string array' || type === 'number array' || type === 'boolean array' || type === 'object array') {
+            return JSON.stringify(value);
+        }
+
         return String(value);
     }
 
@@ -423,5 +441,6 @@ class RuleTemplate {
 RuleTemplate.ParserRules = ParserRules;
 RuleTemplate.VariableTypes = VariableTypes;
 RuleTemplate.TemplateFilters = TemplateFilters;
+RuleTemplate.VariableValidate = VariableValidate;
 
 module.exports = RuleTemplate;

package/src/RuleTemplate.production.ebnf.js

@@ -1 +1 @@
-module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]}]
+module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]},{"name":"string_atom","bnf":[["string"]]},{"name":"boolean_atom","bnf":[["false"],["true"]]},{"name":"time_value_atom","bnf":[["number_tod"]]},{"name":"time_period_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom"]]},{"name":"time_period_ago_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom","WS+","AGO","WS+","number","WS+","unit"]]},{"name":"object_atom","bnf":[["json_object"]]},{"name":"json_value","bnf":[["string"],["number"],["false"],["true"],["null"],["json_array"],["json_object"]]},{"name":"json_member","bnf":[["string","NAME_SEPARATOR","json_value"]]},{"name":"%json_object[2][2]","bnf":[["VALUE_SEPARATOR","json_member"]],"fragment":true},{"name":"%json_object[2]","bnf":[["json_member","%json_object[2][2]*"]],"fragment":true},{"name":"json_object","bnf":[["BEGIN_OBJECT","%json_object[2]?","END_OBJECT"]]},{"name":"%json_array[2][2]","bnf":[["VALUE_SEPARATOR","json_value"]],"fragment":true},{"name":"%json_array[2]","bnf":[["json_value","%json_array[2][2]*"]],"fragment":true},{"name":"json_array","bnf":[["BEGIN_ARRAY","%json_array[2]?","END_ARRAY"]]},{"name":"%string_array[2][2]","bnf":[["VALUE_SEPARATOR","string"]],"fragment":true},{"name":"%string_array[2]","bnf":[["string","%string_array[2][2]*"]],"fragment":true},{"name":"string_array","bnf":[["BEGIN_ARRAY","%string_array[2]?","END_ARRAY"]]},{"name":"%number_array[2][2]","bnf":[["VALUE_SEPARATOR","number"]],"fragment":true},{"name":"%number_array[2]","bnf":[["number","%number_array[2][2]*"]],"fragment":true},{"name":"number_array","bnf":[["BEGIN_ARRAY","%number_array[2]?","END_ARRAY"]]},{"name":"%boolean_array[2][2]","bnf":[["VALUE_SEPARATOR","boolean_atom"]],"fragment":true},{"name":"%boolean_array[2]","bnf":[["boolean_atom","%boolean_array[2][2]*"]],"fragment":true},{"name":"boolean_array","bnf":[["BEGIN_ARRAY","%boolean_array[2]?","END_ARRAY"]]},{"name":"%object_array[2][2]","bnf":[["VALUE_SEPARATOR","json_object"]],"fragment":true},{"name":"%object_array[2]","bnf":[["json_object","%object_array[2][2]*"]],"fragment":true},{"name":"object_array","bnf":[["BEGIN_ARRAY","%object_array[2]?","END_ARRAY"]]}]

package/src/RuleTemplate.production.js

@@ -1,6 +1,7 @@
 // Note: We are coupled closely with the ebnf grammar structure of rule-parser
 const TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
       TemplateFilters = require('./TemplateFilters'),
+    VariableValidate = require('./VariableValidate'),
       RuleParser = require('@halleyassist/rule-parser'),
       RuleParserRules = RuleParser.ParserRules,
       {Parser} = require('ebnf');
@@ -247,6 +248,14 @@ class RuleTemplate {
             // Validate type if provided
             if (type && !VariableTypes.includes(type)) {
                 errors.push(`Invalid variable type '${type}' for variable '${varName}'`);
+                continue;
+            }
+
+            if (type) {
+                const validation = VariableValidate.validate(varData);
+                if (!validation.valid) {
+                    errors.push(`Invalid value for variable '${varName}': ${validation.error}`);
+                }
             }
         }
         
@@ -367,6 +376,11 @@ class RuleTemplate {
             }
         }
 
+        const validation = VariableValidate.validate(varData);
+        if (!validation.valid) {
+            throw new Error(`Invalid value for variable '${varName}': ${validation.error}`);
+        }
+
         return this._serializeVarData(varData, varName);
     }
 
@@ -397,6 +411,10 @@ class RuleTemplate {
             return ret;
         }
 
+        if (type === 'object' || type === 'string array' || type === 'number array' || type === 'boolean array' || type === 'object array') {
+            return JSON.stringify(value);
+        }
+
         return String(value);
     }
 
@@ -423,5 +441,6 @@ class RuleTemplate {
 RuleTemplate.ParserRules = ParserRules;
 RuleTemplate.VariableTypes = VariableTypes;
 RuleTemplate.TemplateFilters = TemplateFilters;
+RuleTemplate.VariableValidate = VariableValidate;
 
 module.exports = RuleTemplate;

package/src/VariableValidate.js

@@ -0,0 +1,399 @@
+const { Parser } = require('ebnf');
+const TemplateGrammar = require('./RuleTemplate.ebnf');
+const TemplateFilters = require('./TemplateFilters');
+const RuleParser = require('@halleyassist/rule-parser');
+const RuleParserRules = RuleParser.ParserRules;
+
+const VariableTypes = [
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'time period',
+    'time period ago',
+    'time value',
+    'number time',
+    'string array',
+    'number array',
+    'boolean array',
+    'object array'
+];
+
+let ParserCache = null;
+
+const ValidationRules = [...RuleParserRules];
+for (const rule of TemplateGrammar) {
+    const idx = ValidationRules.findIndex(existingRule => existingRule.name === rule.name);
+    if (idx !== -1) {
+        ValidationRules[idx] = rule;
+    } else {
+        ValidationRules.push(rule);
+    }
+}
+
+class VariableValidate {
+    static validate(variableData) {
+        if (!variableData || typeof variableData !== 'object' || Array.isArray(variableData)) {
+            return {
+                valid: false,
+                error: 'Variable data must be an object with value and type properties'
+            };
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(variableData, 'type')) {
+            return {
+                valid: false,
+                error: 'Variable data must include a type property'
+            };
+        }
+
+        let normalizedVarData;
+        try {
+            normalizedVarData = VariableValidate._normalizeVarData(variableData);
+        } catch (error) {
+            return {
+                valid: false,
+                error: error.message
+            };
+        }
+
+        return VariableValidate.validateValue(normalizedVarData.type, normalizedVarData.value);
+    }
+
+    static validateValue(type, value) {
+        const validator = VariableValidate.validators[type];
+        if (!validator) {
+            return {
+                valid: false,
+                error: `Unsupported variable type '${type}'`
+            };
+        }
+
+        try {
+            return validator(value);
+        } catch (error) {
+            return {
+                valid: false,
+                error: error.message
+            };
+        }
+    }
+
+    static isValid(type, value) {
+        return VariableValidate.validateValue(type, value).valid;
+    }
+
+    static _validateWithRule(value, startRule, options = {}) {
+        const parser = VariableValidate._getParser();
+        const normalized = options.normalize ? options.normalize(value) : value;
+
+        if (typeof normalized !== 'string' || !normalized.length) {
+            return {
+                valid: false,
+                error: options.emptyMessage || `Expected ${startRule} input`
+            };
+        }
+
+        try {
+            parser.getAST(normalized, startRule);
+        } catch (error) {
+            return {
+                valid: false,
+                error: options.parseMessage || error.message
+            };
+        }
+
+        if (options.semanticCheck) {
+            const semanticError = options.semanticCheck(value, normalized);
+            if (semanticError) {
+                return {
+                    valid: false,
+                    error: semanticError
+                };
+            }
+        }
+
+        return { valid: true };
+    }
+
+    static _getParser() {
+        if (!ParserCache) {
+            ParserCache = new Parser(ValidationRules, { debug: false });
+        }
+
+        return ParserCache;
+    }
+
+    static _normalizeVarData(variableData) {
+        const normalizedVarData = VariableValidate._cloneVarData(variableData);
+
+        if (!Object.prototype.hasOwnProperty.call(normalizedVarData, 'value')) {
+            throw new Error('Variable data must include a value property');
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(normalizedVarData, 'filters')) {
+            return normalizedVarData;
+        }
+
+        if (!Array.isArray(normalizedVarData.filters)) {
+            throw new Error('Variable data filters must be an array');
+        }
+
+        for (const filterName of normalizedVarData.filters) {
+            if (!TemplateFilters[filterName]) {
+                throw new Error(`Unknown filter '${filterName}'`);
+            }
+
+            TemplateFilters[filterName](normalizedVarData);
+        }
+
+        return normalizedVarData;
+    }
+
+    static _cloneVarData(variableData) {
+        const cloned = Object.assign({}, variableData);
+        if (Array.isArray(cloned.filters)) {
+            cloned.filters = cloned.filters.slice();
+        }
+
+        if (cloned.value && typeof cloned.value === 'object') {
+            if (Array.isArray(cloned.value)) {
+                cloned.value = cloned.value.slice();
+            } else {
+                cloned.value = Object.assign({}, cloned.value);
+            }
+        }
+
+        return cloned;
+    }
+
+    static _serializeString(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeNumber(value) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            return null;
+        }
+
+        return String(value);
+    }
+
+    static _serializeBoolean(value) {
+        if (typeof value !== 'boolean') {
+            return null;
+        }
+
+        return value ? 'true' : 'false';
+    }
+
+    static _serializeTimeValue(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return value.trim();
+    }
+
+    static _serializeTimePeriod(value) {
+        if (!VariableValidate._isPlainObject(value) || typeof value.from !== 'string' || typeof value.to !== 'string') {
+            return null;
+        }
+
+        return `${value.from.trim()} TO ${value.to.trim()}`;
+    }
+
+    static _serializeTimePeriodAgo(value) {
+        if (!VariableValidate._isPlainObject(value) || typeof value.from !== 'string' || typeof value.to !== 'string') {
+            return null;
+        }
+
+        if (!Array.isArray(value.ago) || value.ago.length !== 2) {
+            return null;
+        }
+
+        const [amount, unit] = value.ago;
+        if (typeof amount !== 'number' || !Number.isFinite(amount) || typeof unit !== 'string') {
+            return null;
+        }
+
+        return `${value.from.trim()} TO ${value.to.trim()} AGO ${amount} ${unit.trim()}`;
+    }
+
+    static _serializeNumberTime(value) {
+        if (typeof value !== 'string') {
+            return null;
+        }
+
+        return value.trim();
+    }
+
+    static _serializeJsonObject(value) {
+        if (!VariableValidate._isJsonObject(value)) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeTypedArray(value, predicate) {
+        if (!Array.isArray(value) || !value.every(predicate)) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _serializeObjectArray(value) {
+        if (!Array.isArray(value) || !value.every(item => VariableValidate._isJsonObject(item))) {
+            return null;
+        }
+
+        return JSON.stringify(value);
+    }
+
+    static _isPlainObject(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+
+    static _isJsonObject(value) {
+        if (!VariableValidate._isPlainObject(value)) {
+            return false;
+        }
+
+        return Object.values(value).every(entry => VariableValidate._isJsonValue(entry));
+    }
+
+    static _isJsonValue(value) {
+        if (value === null) {
+            return true;
+        }
+
+        if (typeof value === 'string' || typeof value === 'boolean') {
+            return true;
+        }
+
+        if (typeof value === 'number') {
+            return Number.isFinite(value);
+        }
+
+        if (Array.isArray(value)) {
+            return value.every(entry => VariableValidate._isJsonValue(entry));
+        }
+
+        if (VariableValidate._isPlainObject(value)) {
+            return Object.values(value).every(entry => VariableValidate._isJsonValue(entry));
+        }
+
+        return false;
+    }
+
+    static _validateTimeOfDay(value) {
+        if (typeof value !== 'string') {
+            return 'Time value must be a string in HH:MM format';
+        }
+
+        const match = value.trim().match(/^(\d{1,2}):(\d{1,2})$/);
+        if (!match) {
+            return 'Time value must be a string in HH:MM format';
+        }
+
+        const hours = Number(match[1]);
+        const minutes = Number(match[2]);
+
+        if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+            return 'Time value must contain hours 0-23 and minutes 0-59';
+        }
+
+        return null;
+    }
+}
+
+VariableValidate.VariableTypes = VariableTypes.slice();
+VariableValidate.validators = Object.freeze({
+    'string': (value) => VariableValidate._validateWithRule(value, 'string_atom', {
+        normalize: VariableValidate._serializeString,
+        emptyMessage: 'String variables must be JavaScript strings',
+        parseMessage: 'String variables must serialize to a valid quoted string literal'
+    }),
+    'number': (value) => VariableValidate._validateWithRule(value, 'number', {
+        normalize: VariableValidate._serializeNumber,
+        emptyMessage: 'Number variables must be finite numbers',
+        parseMessage: 'Number variables must serialize to a valid numeric literal'
+    }),
+    'boolean': (value) => VariableValidate._validateWithRule(value, 'boolean_atom', {
+        normalize: VariableValidate._serializeBoolean,
+        emptyMessage: 'Boolean variables must be JavaScript booleans',
+        parseMessage: 'Boolean variables must serialize to a valid boolean literal'
+    }),
+    'object': (value) => VariableValidate._validateWithRule(value, 'object_atom', {
+        normalize: VariableValidate._serializeJsonObject,
+        emptyMessage: 'Object variables must be plain JSON-compatible objects',
+        parseMessage: 'Object variables must serialize to valid JSON object syntax'
+    }),
+    'time period': (value) => VariableValidate._validateWithRule(value, 'time_period_atom', {
+        normalize: VariableValidate._serializeTimePeriod,
+        emptyMessage: 'Time period variables must be objects with string from/to properties',
+        parseMessage: 'Time period variables must serialize to FROM TO TO syntax',
+        semanticCheck: (rawValue) => {
+            const fromError = VariableValidate._validateTimeOfDay(rawValue?.from);
+            if (fromError) return `Invalid time period from value: ${fromError}`;
+
+            const toError = VariableValidate._validateTimeOfDay(rawValue?.to);
+            if (toError) return `Invalid time period to value: ${toError}`;
+
+            return null;
+        }
+    }),
+    'time period ago': (value) => VariableValidate._validateWithRule(value, 'time_period_ago_atom', {
+        normalize: VariableValidate._serializeTimePeriodAgo,
+        emptyMessage: 'Time period ago variables must be objects with from, to, and ago properties',
+        parseMessage: 'Time period ago variables must serialize to FROM TO TO AGO AMOUNT UNIT syntax',
+        semanticCheck: (rawValue) => {
+            const fromError = VariableValidate._validateTimeOfDay(rawValue?.from);
+            if (fromError) return `Invalid time period ago from value: ${fromError}`;
+
+            const toError = VariableValidate._validateTimeOfDay(rawValue?.to);
+            if (toError) return `Invalid time period ago to value: ${toError}`;
+
+            return null;
+        }
+    }),
+    'time value': (value) => VariableValidate._validateWithRule(value, 'time_value_atom', {
+        normalize: VariableValidate._serializeTimeValue,
+        emptyMessage: 'Time value variables must be strings in HH:MM format',
+        parseMessage: 'Time value variables must serialize to HH:MM syntax',
+        semanticCheck: (rawValue) => VariableValidate._validateTimeOfDay(rawValue)
+    }),
+    'number time': (value) => VariableValidate._validateWithRule(value, 'number_time', {
+        normalize: VariableValidate._serializeNumberTime,
+        emptyMessage: 'Number time variables must be strings like "2 hours"',
+        parseMessage: 'Number time variables must serialize to NUMBER UNIT syntax'
+    }),
+    'string array': (value) => VariableValidate._validateWithRule(value, 'string_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'string'),
+        emptyMessage: 'String array variables must be arrays of strings',
+        parseMessage: 'String array variables must serialize to a valid string array literal'
+    }),
+    'number array': (value) => VariableValidate._validateWithRule(value, 'number_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'number' && Number.isFinite(item)),
+        emptyMessage: 'Number array variables must be arrays of finite numbers',
+        parseMessage: 'Number array variables must serialize to a valid number array literal'
+    }),
+    'boolean array': (value) => VariableValidate._validateWithRule(value, 'boolean_array', {
+        normalize: (rawValue) => VariableValidate._serializeTypedArray(rawValue, item => typeof item === 'boolean'),
+        emptyMessage: 'Boolean array variables must be arrays of booleans',
+        parseMessage: 'Boolean array variables must serialize to a valid boolean array literal'
+    }),
+    'object array': (value) => VariableValidate._validateWithRule(value, 'object_array', {
+        normalize: VariableValidate._serializeObjectArray,
+        emptyMessage: 'Object array variables must be arrays of plain JSON-compatible objects',
+        parseMessage: 'Object array variables must serialize to a valid object array literal'
+    })
+});
+
+module.exports = VariableValidate;