@qoretechnologies/reqraft 0.10.46-pr.95.ge595a13 → 0.10.46

package/dist/helpers/validations.js

@@ -23,7 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasAllDependenciesFullfilled = exports.validateOptionWithRequiredGroups = exports.getTypeFromValue = exports.getValueOrDefaultValue = exports.isValueSet = exports.maybeParseYaml = exports.validateField = exports.validateFieldWithResult = exports.readArgValue = exports._validateField = void 0;
+exports.hasAllDependenciesFullfilled = exports.parseDependency = exports.getUnresolvedRequiredOptions = exports.getUnresolvedRequiredOptionReason = exports.validateOptionWithRequiredGroups = exports.getTypeFromValue = exports.getValueOrDefaultValue = exports.isValueSet = exports.maybeParseYaml = exports.validateField = exports.validateFieldWithResult = exports.readArgValue = exports._validateField = exports.setExpressionCatalogueReader = exports.cronExpressionFromValue = void 0;
 var colors_1 = require("@qoretechnologies/reqore/dist/helpers/colors");
 var cron_validator_1 = require("cron-validator");
 var js_yaml_1 = __importDefault(require("js-yaml"));
@@ -35,9 +35,74 @@ var isNaN_1 = __importDefault(require("lodash/isNaN"));
 var isNumber_1 = __importDefault(require("lodash/isNumber"));
 var isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
 var size_1 = __importDefault(require("lodash/size"));
+var uniqWith_1 = __importDefault(require("lodash/uniqWith"));
 var common_1 = require("./common");
+var optionUiTypes_1 = require("./optionUiTypes");
 var options_1 = require("./options");
+var providerValue_1 = require("./providerValue");
 var templates_1 = require("./templates");
+/** The five cron fields, in order, as a schedule hash may name them. */
+var CRON_FIELDS = [
+    ['minutes', 'minute'],
+    ['hours', 'hour'],
+    ['days', 'day'],
+    ['months', 'month'],
+    ['dow', 'weekday'],
+];
+/**
+ * A five-field cron expression, from either representation a caller may hold.
+ *
+ * A schedule reaches the form in one of two shapes, and both are legitimate: a
+ * joined string (`"0 0 1 1 *"`), or the hash a Qorus job carries
+ * (`{minutes, hours, days, months, dow}` — also accepted under the singular
+ * `minute`/`hour`/`day`/`month`/`weekday` spellings). The renderer already
+ * accepted both; validation did not, and fed the hash straight to
+ * `isValidCron`, which calls `.trim()` on it.
+ *
+ * Returns `undefined` for anything that is neither, so the caller reports an
+ * invalid value rather than throwing.
+ */
+var cronExpressionFromValue = function (value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    var hash = value;
+    var parts = CRON_FIELDS.map(function (_a) {
+        var _b;
+        var plural = _a[0], singular = _a[1];
+        var field = (_b = hash[plural]) !== null && _b !== void 0 ? _b : hash[singular];
+        return field === undefined || field === null || field === '' ? '*' : String(field);
+    });
+    // An object with none of the five keys is not a schedule — every part
+    // defaulting to `*` would otherwise turn any object at all into "* * * * *"
+    return parts.every(function (part) { return part === '*'; }) &&
+        !CRON_FIELDS.some(function (_a) {
+            var plural = _a[0], singular = _a[1];
+            return plural in hash || singular in hash;
+        })
+        ? undefined
+        : parts.join(' ');
+};
+exports.cronExpressionFromValue = cronExpressionFromValue;
+var expressionCatalogueReader;
+var setExpressionCatalogueReader = function (reader) {
+    expressionCatalogueReader = reader;
+};
+exports.setExpressionCatalogueReader = setExpressionCatalogueReader;
+var readExpressionCatalogue = function (field) { var _a, _b; return (_b = (_a = field === null || field === void 0 ? void 0 : field.expressions) !== null && _a !== void 0 ? _a : expressionCatalogueReader === null || expressionCatalogueReader === void 0 ? void 0 : expressionCatalogueReader()) !== null && _b !== void 0 ? _b : []; };
+// permissive patterns for the semantic string formats — mirror the qore DataProvider
+// QoreStringFormatDataType server backstop (email/uuid/hostname/ipv4/ipv6/phone)
+var SEMANTIC_FORMAT_PATTERNS = {
+    email: /^[^@\s]+@[^@\s]+$/,
+    uuid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+    hostname: /^[A-Za-z0-9.-]+$/,
+    ipv4: /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/,
+    ipv6: /^([0-9A-Fa-f]{0,4}:){2,7}[0-9A-Fa-f]{0,4}$/,
+    phone: /^\+?[0-9 ().-]{3,}$/,
+};
 var validResult = function () { return ({ isValid: true, reasons: [] }); };
 var invalidResult = function (reason, childReasons) {
     if (childReasons === void 0) { childReasons = []; }
@@ -74,7 +139,7 @@ var isValueDefined = function (type, value) {
     return value !== undefined && value !== '';
 };
 var _validateField = function (type, value, field, canBeNull) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     if (!type) {
         if (value === undefined || value === null) {
             return invalidResult('Missing value');
@@ -90,13 +155,6 @@ var _validateField = function (type, value, field, canBeNull) {
     if (canBeNull && (value === null || value === undefined)) {
         return validResult();
     }
-    // Expression values (`is_expression`) carry the AST `{ exp, args }` instead
-    // of a typed literal — validate that an expression is chosen, not the
-    // base type. (`isFunction` is set by FormEngine for expression options.)
-    if (field === null || field === void 0 ? void 0 : field.isFunction) {
-        var ast = (_a = value === null || value === void 0 ? void 0 : value.value) !== null && _a !== void 0 ? _a : value;
-        return resultFromBoolean(!!(ast === null || ast === void 0 ? void 0 : ast.exp), 'Expression operation is required');
-    }
     // Strip type parameters e.g. hash<string, int> → hash
     var pos = type.indexOf('<');
     if (pos > 0) {
@@ -108,6 +166,16 @@ var _validateField = function (type, value, field, canBeNull) {
         var hasValue = !!(0, templates_1.getTemplateValue)(value);
         return resultFromBoolean(hasKey && hasValue, 'Template must include key and value');
     }
+    // Expression values (`is_expression`) carry the AST `{ exp, args }` instead of
+    // a typed literal, so the declared type says nothing about them — validate
+    // them as the expression they are, arguments and all. (`isFunction` is set by
+    // FormEngine, and by the option recursion below, for expression options.)
+    if (field === null || field === void 0 ? void 0 : field.isFunction) {
+        // The AST is normally the value itself; a caller that still holds the
+        // option envelope hands over `{ value: ast }`, so accept both.
+        var ast = (_a = value === null || value === void 0 ? void 0 : value.value) !== null && _a !== void 0 ? _a : value;
+        return (0, exports.validateFieldWithResult)('expression', { value: ast }, (0, lodash_1.omit)(field, ['isFunction']), canBeNull);
+    }
     // Check if the field has required groups
     if (field === null || field === void 0 ? void 0 : field.required_groups) {
         if (!isValueDefined(type, value) &&
@@ -115,6 +183,12 @@ var _validateField = function (type, value, field, canBeNull) {
             return validResult();
         }
     }
+    // An interface type names another Qorus object by its name, so a non-empty
+    // string is the whole contract. `connection` is the exception: it carries
+    // enablement and authentication state of its own, checked below.
+    if ((0, optionUiTypes_1.isOptionInterfaceUiType)(type) && type !== 'connection') {
+        return (0, exports.validateFieldWithResult)('string', value, field);
+    }
     switch (type) {
         case 'richtext': {
             if (!value || !(0, size_1.default)(value)) {
@@ -151,28 +225,53 @@ var _validateField = function (type, value, field, canBeNull) {
             }
             return withContext((0, exports.validateFieldWithResult)('string', value, field), 'Connection string validation failed');
         }
+        // semantic string formats — permissive patterns mirror the qore DataProvider
+        // QoreStringFormatDataType backstop; a server-supplied validation_regex, if
+        // present, is also enforced
+        case 'email':
+        case 'uuid':
+        case 'hostname':
+        case 'ipv4':
+        case 'ipv6':
+        case 'phone': {
+            if (value === undefined || value === null || value === '' || typeof value !== 'string') {
+                return invalidResult('Value must be a non-empty text');
+            }
+            if ((field === null || field === void 0 ? void 0 : field.validation_regex) && !value.match(field.validation_regex)) {
+                return invalidResult('Value does not match the required format');
+            }
+            return resultFromBoolean(SEMANTIC_FORMAT_PATTERNS[type].test(value), "Value is not a valid ".concat(type));
+        }
         case 'binary': {
             if (typeof value !== 'string') {
                 return invalidResult('Binary value must be a string');
             }
-            var hex = value.trim().replace(/^0x/i, '');
-            if (hex.length === 0) {
+            var trimmed = value.trim();
+            if (trimmed.length === 0) {
                 return invalidResult('Binary value is empty');
             }
-            if (hex.length % 2 !== 0) {
-                return invalidResult('Binary hex length must be even');
+            // the canonical wire form is base64 (matching the server decode); a "data:<mime>;base64,..." URL
+            // and legacy "0x"-prefixed hex are also accepted
+            if (/^data:[^;]+;base64,/.test(trimmed)) {
+                return validResult();
             }
-            if (!/^[0-9a-fA-F]+$/.test(hex)) {
-                return invalidResult('Binary value must contain only hex characters');
+            if (/^0x/i.test(trimmed)) {
+                var hex = trimmed.replace(/^0x/i, '');
+                return resultFromBoolean(hex.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(hex), 'Binary hex value is invalid');
             }
-            return validResult();
+            return resultFromBoolean(/^[A-Za-z0-9+/]+={0,2}$/.test(trimmed), 'Binary value must be base64, a data: URL, or 0x-prefixed hex');
         }
         case 'string':
         case 'mapper':
         case 'workflow':
         case 'service':
         case 'job':
+        case 'softstring':
+        case 'select-string':
+        case 'file-string':
+        case 'file-as-string':
         case 'long-string':
+        case 'method-name':
         case 'code-editor':
         case 'data': {
             if (value === undefined || value === null || value === '' || typeof value !== 'string') {
@@ -234,6 +333,109 @@ var _validateField = function (type, value, field, canBeNull) {
                 : withContext(contentResult, 'File content is invalid').reasons), true);
             return reasons.length ? invalidResult(reasons) : validResult();
         }
+        case 'collection-documents': {
+            // The value is an array of rows in mixed lifecycle states.
+            // A row is valid when it's either:
+            //   1. Server-managed: has `ai_documentid` (number) + `name`.
+            //   2. Client-managed: has `name` + `content` (base64) — i.e.
+            //      a fresh upload that hasn't landed yet.
+            // Failed rows count as valid for form-level purposes (the
+            // user can Retry; the form shouldn't block save just because
+            // an upload errored). Empty list is valid here — the
+            // top-level required check (`field.required`) handles "must
+            // pick at least one" gating.
+            if (value === undefined || value === null) {
+                return validResult();
+            }
+            if (!Array.isArray(value)) {
+                return invalidResult('Value must be a list of documents');
+            }
+            var reasons_1 = [];
+            value.forEach(function (row, idx) {
+                if (!row || typeof row !== 'object') {
+                    reasons_1.push("Row ".concat(idx + 1, " is not an object"));
+                    return;
+                }
+                if (typeof row.name !== 'string' || !row.name) {
+                    reasons_1.push("Row ".concat(idx + 1, " is missing a name"));
+                    return;
+                }
+                var hasServerId = typeof row.ai_documentid === 'number';
+                var hasContent = typeof row.content === 'string' && !!row.content;
+                if (!hasServerId && !hasContent) {
+                    reasons_1.push("Row ".concat(idx + 1, " (\"").concat(row.name, "\") has neither uploaded ") +
+                        "content nor a server document id");
+                }
+            });
+            return reasons_1.length ? invalidResult(undefined, reasons_1) : validResult();
+        }
+        case 'array-of-pairs': {
+            var valid = true;
+            var reasons = [];
+            // Check if every pair has key & value
+            // assigned properly
+            if (!Array.isArray(value)) {
+                return invalidResult('Value must be a list');
+            }
+            if (!(value === null || value === void 0 ? void 0 : value.every(function (pair) {
+                return pair[field.fields[0]] !== '' && pair[field.fields[1]] !== '';
+            }))) {
+                valid = false;
+                reasons.push('All pairs must include both fields');
+            }
+            // Get a list of unique values
+            var uniqueValues = (0, uniqWith_1.default)(value, function (cur, prev) { return cur[field.fields[0]] === prev[field.fields[0]]; });
+            // Check if there are any duplicates
+            if ((0, size_1.default)(uniqueValues) !== (0, size_1.default)(value)) {
+                valid = false;
+                reasons.push('Pairs must use unique keys');
+            }
+            return valid ? validResult() : invalidResult(undefined, reasons);
+        }
+        case 'class-connectors': {
+            if (!Array.isArray(value) || value.length === 0) {
+                return invalidResult('At least one connector is required');
+            }
+            var valid = true;
+            var reasons = [];
+            // Check if every pair has name, input method and output method
+            // assigned properly
+            if (!(value === null || value === void 0 ? void 0 : value.every(function (pair) {
+                return !!pair.name && pair.name !== '' && !!pair.method && pair.method !== '';
+            }))) {
+                valid = false;
+                reasons.push('Each connector must have a name and method');
+            }
+            // Get a list of unique values
+            var uniqueValues = (0, uniqWith_1.default)(value, function (cur, prev) { return cur.name === prev.name; });
+            // Check if there are any duplicates
+            if ((0, size_1.default)(uniqueValues) !== (0, size_1.default)(value)) {
+                valid = false;
+                reasons.push('Connector names must be unique');
+            }
+            return valid ? validResult() : invalidResult(undefined, reasons);
+        }
+        // Classes check
+        case 'class-array': {
+            if (!(Array.isArray(value) && value.length > 0)) {
+                return invalidResult('At least one class must be provided');
+            }
+            var valid = true;
+            var reasons = [];
+            // Check if the fields are not empty
+            if (!(value === null || value === void 0 ? void 0 : value.every(function (pair) { return !!pair.name && pair.name !== ''; }))) {
+                valid = false;
+                reasons.push('Each class must have a name');
+            }
+            // Get a list of unique values
+            var uniqueValues = (0, uniqWith_1.default)(value, function (cur, prev) { return "".concat(cur.prefix).concat(cur.name) === "".concat(prev.prefix).concat(prev.name); });
+            // Check if there are any duplicates
+            if ((0, size_1.default)(uniqueValues) !== (0, size_1.default)(value)) {
+                valid = false;
+                reasons.push('Class names must be unique');
+            }
+            return valid ? validResult() : invalidResult(undefined, reasons);
+        }
         case 'number': {
             return resultFromBoolean(!(0, isNaN_1.default)(value) && ((0, exports.getTypeFromValue)(value) === 'float' || (0, exports.getTypeFromValue)(value) === 'int'), 'Value must be a number');
         }
@@ -241,15 +443,25 @@ var _validateField = function (type, value, field, canBeNull) {
             return resultFromBoolean(!Number.isNaN(value) && (0, exports.getTypeFromValue)(value) === 'int', 'Value must be an integer');
         case 'float':
             return resultFromBoolean(!(0, isNaN_1.default)(value) && ((0, exports.getTypeFromValue)(value) === 'float' || (0, exports.getTypeFromValue)(value) === 'int'), 'Value must be a float');
+        case 'select-array':
         case 'multi-select':
         case 'array':
         case 'file-tree':
             return resultFromBoolean(value && value.length > 0, 'At least one value is required');
-        case 'cron':
+        case 'cron': {
             if (!value) {
                 return invalidResult('Cron value is required');
             }
-            return resultFromBoolean((0, cron_validator_1.isValidCron)(value, { alias: true }), 'Cron expression is invalid');
+            var expression = (0, exports.cronExpressionFromValue)(value);
+            // A value that is neither a cron string nor a schedule hash is INVALID,
+            // not a crash: `isValidCron` calls `.trim()` on whatever it is given, so
+            // passing it a hash threw a TypeError out of validation and took the
+            // whole form down through the host's error boundary.
+            if (expression === undefined) {
+                return invalidResult('Cron expression is invalid');
+            }
+            return resultFromBoolean((0, cron_validator_1.isValidCron)(expression, { alias: true }), 'Cron expression is invalid');
+        }
         case 'date':
             return resultFromBoolean(value !== undefined &&
                 value !== null &&
@@ -293,7 +505,14 @@ var _validateField = function (type, value, field, canBeNull) {
             }
             if ((field === null || field === void 0 ? void 0 : field.ui_element_type) || (field === null || field === void 0 ? void 0 : field.element_type)) {
                 for (var i = 0; i < parsedValue.length; i++) {
-                    var itemResult = (0, exports.validateFieldWithResult)(field.ui_element_type || field.element_type, parsedValue[i].value, field);
+                    var itemResult = (0, exports.validateFieldWithResult)(field.ui_element_type || field.element_type, 
+                    // An element arrives bare OR in a `{value, type}` envelope: the
+                    // envelope is what the editor writes, the bare form is what storage
+                    // holds. Reaching straight for `.value` failed every stored element
+                    // as empty, so a reloaded alert rule reported its delivery action
+                    // invalid while showing all six options set -- and threw outright on
+                    // a null element.
+                    (0, options_1.getListElementValue)(parsedValue[i]), field);
                     if (!itemResult.isValid) {
                         return withContext(itemResult, "List item ".concat(i, " is invalid"));
                     }
@@ -301,27 +520,409 @@ var _validateField = function (type, value, field, canBeNull) {
             }
             return validResult();
         }
-        case 'auto':
-        case 'any': {
-            var yamlCorrect = true;
-            var parsedData = void 0;
-            try {
-                parsedData = js_yaml_1.default.load(value);
+        case 'list-of-hashes': {
+            var parsedValue = (0, exports.maybeParseYaml)(value);
+            if (!parsedValue || !(0, isArray_1.default)(parsedValue)) {
+                return invalidResult('Value must be a list of hashes');
+            }
+            for (var i = 0; i < parsedValue.length; i++) {
+                var item = parsedValue[i];
+                if (!(0, size_1.default)(item)) {
+                    return invalidResult("Hash at index ".concat(i, " must not be empty"));
+                }
+                var itemResult = (0, exports.validateFieldWithResult)('hash', item);
+                if (!itemResult.isValid) {
+                    return withContext(itemResult, "Hash at index ".concat(i, " is invalid"));
+                }
+            }
+            return validResult();
+        }
+        case 'mapper-code': {
+            if (!value) {
+                return invalidResult('Mapper code is required');
+            }
+            // Split the value
+            var _r = value.split('::'), code = _r[0], method = _r[1];
+            // Both fields need to be strings & filled
+            var codeResult = (0, exports.validateFieldWithResult)('string', code);
+            if (!codeResult.isValid) {
+                return withContext(codeResult, 'Mapper code is invalid');
+            }
+            var methodResult = (0, exports.validateFieldWithResult)('string', method);
+            if (!methodResult.isValid) {
+                return withContext(methodResult, 'Mapper method is invalid');
+            }
+            return validResult();
+        }
+        case 'var-action': {
+            var varAction = value;
+            if ((varAction === null || varAction === void 0 ? void 0 : varAction.var_type) !== 'localvar' &&
+                (varAction === null || varAction === void 0 ? void 0 : varAction.var_type) !== 'globalvar' &&
+                (varAction === null || varAction === void 0 ? void 0 : varAction.var_type) !== 'autovar') {
+                return invalidResult('Variable type is invalid');
+            }
+            var nameResult = (0, exports.validateFieldWithResult)('string', varAction.var_name, {
+                has_to_have_value: true,
+            });
+            if (!nameResult.isValid) {
+                return withContext(nameResult, 'Variable name is invalid');
+            }
+            var actionResult = (0, exports.validateFieldWithResult)('string', varAction.action_type, {
+                has_to_have_value: true,
+            });
+            if (!actionResult.isValid) {
+                return withContext(actionResult, 'Variable action type is invalid');
+            }
+            // If the action type is transaction, the transaction_action needs to be set
+            if (varAction.action_type === 'transaction') {
+                var transactionResult = (0, exports.validateFieldWithResult)('string', varAction.transaction_action, {
+                    has_to_have_value: true,
+                });
+                if (!transactionResult.isValid) {
+                    return withContext(transactionResult, 'Transaction action is invalid');
+                }
+                return validResult();
+            }
+            // If the variable data is missing
+            if (!((_d = field === null || field === void 0 ? void 0 : field.variableData) === null || _d === void 0 ? void 0 : _d.value)) {
+                return invalidResult('Variable data is missing');
+            }
+            // Get the variable data
+            var variableData = __assign(__assign({}, value), field.variableData.value);
+            return withContext((0, exports.validateFieldWithResult)(varAction.action_type, variableData, field), 'Variable action is invalid');
+        }
+        case 'type-selector':
+        case 'data-provider':
+        case 'api-call':
+        case 'search-single':
+        case 'send-message':
+        case 'search':
+        case 'update':
+        case 'delete':
+        case 'create': {
+            var newValue = (0, providerValue_1.maybeBuildOptionProvider)(value);
+            if (!newValue) {
+                return invalidResult('Provider value is invalid');
+            }
+            // Api call only supports  requests / response
+            if (type === 'api-call' && !value.supports_request) {
+                return invalidResult('API call must support requests');
+            }
+            // If the provider is from FSM variables, it needs pass this
+            if ((field === null || field === void 0 ? void 0 : field.isVariable) &&
+                !(newValue.supports_read ||
+                    newValue.supports_create ||
+                    newValue.supports_update ||
+                    newValue.supports_delete ||
+                    newValue.supports_request ||
+                    newValue.supports_messages ||
+                    newValue.transaction_management)) {
+                return invalidResult('Variable provider must support at least one action');
+            }
+            // Send message only supports messages
+            if (type === 'send-message' &&
+                (!newValue.supports_messages || !newValue.message_id || !newValue.message)) {
+                return invalidResult('Send message provider must include message id and content');
+            }
+            if (newValue.message_id) {
+                var messageIdResult = (0, exports.validateFieldWithResult)('string', newValue.message_id);
+                if (!messageIdResult.isValid) {
+                    return withContext(messageIdResult, 'Message id is invalid');
+                }
+                if (!newValue.message) {
+                    return invalidResult('Message content is missing');
+                }
+                var messageResult = (0, exports.validateFieldWithResult)(newValue.message.type, newValue.message.value);
+                if (!messageResult.isValid) {
+                    return withContext(messageResult, 'Message content is invalid');
+                }
+            }
+            if (newValue.use_args) {
+                if (((_e = newValue.args) === null || _e === void 0 ? void 0 : _e.type) !== 'nothing') {
+                    if (!newValue.args) {
+                        return invalidResult('Arguments are missing');
+                    }
+                    var argsResult = (0, exports.validateFieldWithResult)(newValue.args.type === 'hash' ? 'system-options' : newValue.args.type, newValue.args.value);
+                    if (!argsResult.isValid) {
+                        return withContext(argsResult, 'Arguments are invalid');
+                    }
+                }
+            }
+            if ((type === 'search-single' || type === 'search') &&
+                (0, size_1.default)(newValue.search_args) !== 0 &&
+                !(0, exports.validateFieldWithResult)('system-options-with-operators', newValue.search_args).isValid) {
+                return invalidResult('Search arguments are invalid');
+            }
+            var isUpdateOrCreate = type === 'update' || type === 'create';
+            if (isUpdateOrCreate) {
+                var areNormalArgsInvalid = "".concat(type, "_args") in newValue &&
+                    ((0, size_1.default)(newValue["".concat(type, "_args")]) === 0 ||
+                        !(0, exports.validateFieldWithResult)('system-options', newValue["".concat(type, "_args")]).isValid);
+                var areFreeFormArgsInvalid = "".concat(type, "_args_freeform") in newValue &&
+                    ((0, size_1.default)(newValue["".concat(type, "_args_freeform")]) === 0 ||
+                        !(0, exports.validateFieldWithResult)('list-of-hashes', newValue["".concat(type, "_args_freeform")]).isValid);
+                if ("".concat(type, "_args") in newValue && areNormalArgsInvalid && areFreeFormArgsInvalid) {
+                    return invalidResult('Update/create arguments are invalid');
+                }
+                if ("".concat(type, "_args_freeform") in newValue && areFreeFormArgsInvalid && areNormalArgsInvalid) {
+                    return invalidResult('Update/create arguments are invalid');
+                }
+            }
+            if ((newValue === null || newValue === void 0 ? void 0 : newValue.type) === 'factory') {
+                if (newValue.optionsChanged) {
+                    return invalidResult('Factory options are not saved');
+                }
+                var options = true;
+                if (newValue.options) {
+                    options = (0, exports.validateFieldWithResult)('system-options', newValue.options).isValid;
+                }
+                // Type path and name are required
+                return resultFromBoolean(!!(newValue.type && newValue.name && options), 'Factory provider is incomplete');
+            }
+            if (newValue.record_requires_search_options && newValue.searchOptionsChanged) {
+                return invalidResult('Search options must be saved');
+            }
+            if (newValue.search_options &&
+                !(0, exports.validateFieldWithResult)('system-options', newValue.search_options).isValid) {
+                return invalidResult('Search options are invalid');
+            }
+            return resultFromBoolean(!!(newValue.type && newValue.name), 'Provider type and name required');
+        }
+        case 'context-selector': {
+            if ((0, lodash_1.isString)(value)) {
+                var cont = value.split(':');
+                var contextResult = (0, exports.validateFieldWithResult)('string', cont[0]);
+                if (!contextResult.isValid) {
+                    return withContext(contextResult, 'Context selector prefix is invalid');
+                }
+                var nameResult = (0, exports.validateFieldWithResult)('string', cont[1]);
+                if (!nameResult.isValid) {
+                    return withContext(nameResult, 'Context selector name is invalid');
+                }
+                return validResult();
+            }
+            return resultFromBoolean(!!(value === null || value === void 0 ? void 0 : value.iface_kind) && !!(value === null || value === void 0 ? void 0 : value.name), 'Context selector requires iface_kind and name');
+        }
+        case 'service-event': {
+            var typeResult = (0, exports.validateFieldWithResult)('type-selector', value);
+            if (!typeResult.isValid) {
+                return withContext(typeResult, 'Service event type is invalid');
+            }
+            if (!(0, size_1.default)(value.handlers) ||
+                !(0, every_1.default)(value.handlers, function (handler) { return (handler.type === 'fsm' || handler.type === 'method') && handler.value; })) {
+                return invalidResult('Service event handlers are invalid');
+            }
+            return validResult();
+        }
+        case 'service-events': {
+            if (!(0, isArray_1.default)(value) || !(0, size_1.default)(value)) {
+                return invalidResult('At least one service event is required');
+            }
+            for (var i = 0; i < value.length; i++) {
+                var serviceEventResult = (0, exports.validateFieldWithResult)('service-event', value[i]);
+                if (!serviceEventResult.isValid) {
+                    return withContext(serviceEventResult, "Service event ".concat(i, " is invalid"));
+                }
+            }
+            return validResult();
+        }
+        case 'service-webhook': {
+            if (!(0, exports.validateFieldWithResult)('string', value === null || value === void 0 ? void 0 : value.name).isValid ||
+                !(0, exports.validateFieldWithResult)('string', value === null || value === void 0 ? void 0 : value['rest-method']).isValid ||
+                !(0, exports.validateFieldWithResult)('string', value === null || value === void 0 ? void 0 : value.auth).isValid) {
+                return invalidResult('Webhook name, method and auth are required');
+            }
+            if (value.handler) {
+                if (value.handler.type !== 'fsm' && value.handler.type !== 'method') {
+                    return invalidResult('Webhook handler type is invalid');
+                }
+                var handlerResult = (0, exports.validateFieldWithResult)('string', value.handler.value);
+                if (!handlerResult.isValid) {
+                    return withContext(handlerResult, 'Webhook handler value is invalid');
+                }
+            }
+            return validResult();
+        }
+        case 'service-webhooks': {
+            if (!(0, isArray_1.default)(value) || !(0, size_1.default)(value)) {
+                return invalidResult('At least one webhook is required');
             }
-            catch (e) {
-                yamlCorrect = false;
+            for (var i = 0; i < value.length; i++) {
+                var webhookResult = (0, exports.validateFieldWithResult)('service-webhook', value[i]);
+                if (!webhookResult.isValid) {
+                    return withContext(webhookResult, "Service webhook ".concat(i, " is invalid"));
+                }
             }
-            if (!yamlCorrect) {
-                return invalidResult('Value is not valid YAML');
+            return validResult();
+        }
+        case 'auto':
+        case 'any': {
+            // Only a STRING has YAML in it. An `auto` field's value is usually
+            // already the structure it describes -- a hash the form's hash editor
+            // wrote, a list from a list editor -- and `jsyaml.load()` stringifies
+            // whatever it is handed first: an object becomes `"[object Object]"`,
+            // which YAML then reads as the flow sequence `["object Object"]`. So the
+            // auto-detected type came back `list`, the value was validated as a list,
+            // and every hash stored in an `auto` field was reported *"Value must be a
+            // list"* -- an invalid marker on a value that is fine. A list fared no
+            // better: `[1, 2]` stringified to `"1,2"` and detected as a string.
+            //
+            // Every other branch that accepts either shape already parses through
+            // `maybeParseYaml`, which passes a non-string straight through; this one
+            // reached for `jsyaml` directly. It cannot use `maybeParseYaml` as-is
+            // because that reports a YAML error as an absent value, and "not valid
+            // YAML" and "empty" are different answers here.
+            var parsedData = value;
+            if ((0, lodash_1.isString)(value)) {
+                try {
+                    parsedData = js_yaml_1.default.load(value);
+                }
+                catch (e) {
+                    return invalidResult('Value is not valid YAML');
+                }
             }
             if (parsedData) {
                 return withContext((0, exports.validateFieldWithResult)((0, exports.getTypeFromValue)(parsedData), value), 'Auto-detected type is invalid');
             }
             return invalidResult('Value is empty');
         }
-        case 'options': {
+        case 'processor': {
+            if (!value || !value['processor-input-type'] || !value['processor-output-type']) {
+                return invalidResult('Processor input and output types are required');
+            }
+            // Validate the input and output types
+            if (value === null || value === void 0 ? void 0 : value['processor-input-type']) {
+                var inputResult = (0, exports.validateFieldWithResult)('type-selector', value === null || value === void 0 ? void 0 : value['processor-input-type']);
+                if (!inputResult.isValid) {
+                    return withContext(inputResult, 'Processor input type is invalid');
+                }
+            }
+            if (value === null || value === void 0 ? void 0 : value['processor-output-type']) {
+                var outputResult = (0, exports.validateFieldWithResult)('type-selector', value === null || value === void 0 ? void 0 : value['processor-output-type']);
+                if (!outputResult.isValid) {
+                    return withContext(outputResult, 'Processor output type is invalid');
+                }
+            }
+            return validResult();
+        }
+        case 'processor-mappings': {
+            // processor-mappings is an array of field mappings
+            // Each mapping must have an outputPath (the target field being mapped)
+            // and either an inputPath (source field) or options configured
+            if (!(0, isArray_1.default)(value)) {
+                return canBeNull ? validResult() : invalidResult('Processor mappings must be a list');
+            }
+            for (var i = 0; i < value.length; i++) {
+                var mapping = value[i];
+                if (!mapping || !(0, isPlainObject_1.default)(mapping)) {
+                    return invalidResult("Mapping at index ".concat(i, " is invalid"));
+                }
+                // outputPath is always required - it identifies which output field is being mapped
+                var outputPathResult = (0, exports.validateFieldWithResult)('string', mapping.outputPath);
+                if (!outputPathResult.isValid) {
+                    return withContext(outputPathResult, "Mapping ".concat(i, " output path is invalid"));
+                }
+                // A mapping must have either an inputPath or options (or both)
+                var hasInputPath = mapping.inputPath && mapping.inputPath !== '';
+                var hasOptions = mapping.options && (0, size_1.default)(mapping.options) > 0;
+                if (!hasInputPath && !hasOptions) {
+                    return invalidResult("Mapping for \"".concat(mapping.outputPath, "\" must have an input path or options configured"));
+                }
+            }
+            return validResult();
+        }
+        case 'tool-catalog': {
+            // tool-catalog is a flat string[] of selectors; each selector is one of:
+            //   "*"                         — all tools from every source
+            //   "system:*"                  — all Qorus system tools
+            //   "system:<tool>"             — a specific system tool
+            //   "<connection>"              — all tools from a connection
+            //   "<connection>/<tool>"       — a specific tool from a connection
+            if (!(0, isArray_1.default)(value)) {
+                return canBeNull ? validResult() : invalidResult('Tool catalog must be a list');
+            }
+            for (var i = 0; i < value.length; i++) {
+                var selector = value[i];
+                if (typeof selector !== 'string' || selector.length === 0) {
+                    return invalidResult("Tool selector at index ".concat(i, " must be a non-empty string"));
+                }
+            }
+            return validResult();
+        }
+        case 'fsm-list': {
+            if (!(0, isArray_1.default)(value)) {
+                return invalidResult('FSM list must be an array');
+            }
+            for (var i = 0; i < value.length; i++) {
+                var itemResult = (0, exports.validateFieldWithResult)('string', (_f = value[i]) === null || _f === void 0 ? void 0 : _f.name);
+                if (!itemResult.isValid) {
+                    return withContext(itemResult, "FSM entry ".concat(i, " name is invalid"));
+                }
+            }
+            return validResult();
+        }
+        case 'api-manager': {
+            if (!value) {
+                return invalidResult('API manager value is missing');
+            }
+            var factoryResult = (0, exports.validateFieldWithResult)('string', value.factory);
+            if (!factoryResult.isValid) {
+                return withContext(factoryResult, 'API manager factory is invalid');
+            }
+            var endpointsResult = (0, exports.validateFieldWithResult)('api-endpoints', value.endpoints);
+            if (!endpointsResult.isValid) {
+                return withContext(endpointsResult, 'API manager endpoints are invalid');
+            }
+            return validResult();
+        }
+        case 'api-endpoints': {
+            if (!(0, isArray_1.default)(value) || !(0, size_1.default)(value)) {
+                return invalidResult('At least one API endpoint is required');
+            }
+            for (var i = 0; i < value.length; i++) {
+                var endpointResult = (0, exports.validateFieldWithResult)('string', (_g = value[i]) === null || _g === void 0 ? void 0 : _g.value);
+                if (!endpointResult.isValid) {
+                    return withContext(endpointResult, "Endpoint ".concat(i, " value is invalid"));
+                }
+                var authorizationResult = (0, exports.validateFieldWithResult)('api-endpoint-authorization', (_h = value[i]) === null || _h === void 0 ? void 0 : _h.authorization, undefined, true);
+                if (!authorizationResult.isValid) {
+                    return withContext(authorizationResult, "Endpoint ".concat(i, " authorization is invalid"));
+                }
+            }
+            return validResult();
+        }
+        case 'api-endpoint-authorization': {
+            if (!value) {
+                return canBeNull ? validResult() : invalidResult('Authorization override is missing');
+            }
+            if (typeof value !== 'object' || (0, isArray_1.default)(value)) {
+                return invalidResult('Authorization override must be an object');
+            }
+            if (value.mode !== undefined && !['merge', 'replace'].includes(value.mode)) {
+                return invalidResult('Authorization mode must be merge or replace');
+            }
+            if (value.allow_anonymous !== undefined && typeof value.allow_anonymous !== 'boolean') {
+                return invalidResult('Authorization allow_anonymous must be a boolean');
+            }
+            if (value.roles !== undefined) {
+                if (!(0, isArray_1.default)(value.roles)) {
+                    return invalidResult('Authorization roles must be a list');
+                }
+                for (var i = 0; i < value.roles.length; i++) {
+                    var roleResult = (0, exports.validateFieldWithResult)('string', value.roles[i]);
+                    if (!roleResult.isValid) {
+                        return withContext(roleResult, "Authorization role ".concat(i, " is invalid"));
+                    }
+                }
+            }
+            return validResult();
+        }
+        case 'options':
+        case 'pipeline-options':
+        case 'mapper-options':
+        case 'system-options': {
             var getIsValid = function (options, optionSchema) {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b, _c, _d;
                 if (optionSchema === void 0) { optionSchema = {}; }
                 if (!options || (0, size_1.default)(options) === 0) {
                     if (!canBeNull) {
@@ -329,35 +930,31 @@ var _validateField = function (type, value, field, canBeNull) {
                     }
                     return validResult();
                 }
-                if (optionSchema) {
-                    for (var _i = 0, _g = Object.entries(optionSchema); _i < _g.length; _i++) {
-                        var _h = _g[_i], option = _h[0], optionData = _h[1];
-                        if (optionData.required &&
-                            (!(options === null || options === void 0 ? void 0 : options[option]) || ((_a = options === null || options === void 0 ? void 0 : options[option]) === null || _a === void 0 ? void 0 : _a.value) === undefined)) {
-                            return invalidResult("Option ".concat(option, " is required"));
-                        }
-                        if (!((_b = options === null || options === void 0 ? void 0 : options[option]) === null || _b === void 0 ? void 0 : _b.value) &&
-                            optionData.required_groups &&
-                            !(0, exports.validateOptionWithRequiredGroups)(options, optionSchema, optionData.required_groups)) {
-                            return invalidResult("Option ".concat(option, " requires a value"));
-                        }
-                    }
+                // Check if all required options are resolved by the current values
+                var unresolvedRequiredOption = (0, exports.getUnresolvedRequiredOptions)(optionSchema, options)[0];
+                if (unresolvedRequiredOption) {
+                    return unresolvedRequiredOption.validation
+                        ? withContext(unresolvedRequiredOption.validation, "Option ".concat(unresolvedRequiredOption.name, " is invalid"))
+                        : invalidResult((0, exports.getUnresolvedRequiredOptionReason)(unresolvedRequiredOption, optionSchema));
                 }
-                for (var _j = 0, _k = Object.keys(options); _j < _k.length; _j++) {
-                    var option = _k[_j];
-                    if (((_c = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _c === void 0 ? void 0 : _c.depends_on) &&
+                for (var _i = 0, _e = Object.keys(options); _i < _e.length; _i++) {
+                    var option = _e[_i];
+                    var optionData = options[option];
+                    var optionType = ((typeof optionData === 'object' ? optionData === null || optionData === void 0 ? void 0 : optionData.type : undefined) ||
+                        ((_a = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _a === void 0 ? void 0 : _a.ui_type) ||
+                        ((_b = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _b === void 0 ? void 0 : _b.type));
+                    var optionValue = optionData && typeof optionData === 'object' ? optionData.value : optionData;
+                    if (!((_c = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _c === void 0 ? void 0 : _c.required) &&
+                        !isValueDefined(optionType, optionValue)) {
+                        continue;
+                    }
+                    if (((_d = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _d === void 0 ? void 0 : _d.depends_on) &&
                         !(0, exports.hasAllDependenciesFullfilled)(optionSchema[option].depends_on, options, optionSchema)) {
                         return invalidResult("Option ".concat(option, " dependencies are not fulfilled"));
                     }
-                    if (((_d = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _d === void 0 ? void 0 : _d.preselected) &&
-                        !((_e = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]) === null || _e === void 0 ? void 0 : _e.required) &&
-                        !((_f = options[option]) === null || _f === void 0 ? void 0 : _f.value)) {
-                        continue;
-                    }
-                    var optionData = options[option];
                     var optionResult = typeof optionData !== 'object'
                         ? (0, exports.validateFieldWithResult)((0, exports.getTypeFromValue)(optionData), optionData)
-                        : (0, exports.validateFieldWithResult)(optionData.type, optionData.value, __assign(__assign({}, (0, lodash_1.omit)(optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option], [])), { optionSchema: optionSchema, options: options, isFunction: optionData.is_expression }));
+                        : (0, exports.validateFieldWithResult)(optionData.type, optionData.value, __assign(__assign({}, optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[option]), { optionSchema: optionSchema, options: options, isFunction: optionData.is_expression }));
                     if (!optionResult.isValid) {
                         return withContext(optionResult, "Option ".concat(option, " is invalid"));
                     }
@@ -375,12 +972,45 @@ var _validateField = function (type, value, field, canBeNull) {
             }
             return getIsValid(value, field === null || field === void 0 ? void 0 : field.optionSchema);
         }
+        case 'system-options-with-operators': {
+            var isValid = function (val) {
+                if (!val || (0, size_1.default)(val) === 0) {
+                    if (canBeNull) {
+                        return validResult();
+                    }
+                    return invalidResult('Options with operators are required');
+                }
+                for (var _i = 0, _a = Object.keys(val); _i < _a.length; _i++) {
+                    var option = _a[_i];
+                    var optionData = val[option];
+                    var optionResult = typeof optionData !== 'object'
+                        ? (0, exports.validateFieldWithResult)((0, exports.getTypeFromValue)(optionData), optionData)
+                        : (0, exports.validateFieldWithResult)(optionData.type, optionData.value);
+                    if (!optionResult.isValid) {
+                        return withContext(optionResult, "Option ".concat(option, " is invalid"));
+                    }
+                    if (!optionData.op ||
+                        !(0, common_1.fixOperatorValue)(optionData.op).every(function (operator) { return (0, exports.validateFieldWithResult)('string', operator).isValid; })) {
+                        return invalidResult("Operators for option ".concat(option, " are invalid"));
+                    }
+                }
+                return validResult();
+            };
+            if ((0, isArray_1.default)(value)) {
+                for (var i = 0; i < value.length; i++) {
+                    var optionResult = isValid(value[i]);
+                    if (!optionResult.isValid) {
+                        return withContext(optionResult, "Option set ".concat(i, " is invalid"));
+                    }
+                }
+                return validResult();
+            }
+            return isValid(value);
+        }
         case 'byte-size': {
-            // Ported from qorus-ide validations (`sizeUnit` instead of the IDE's
-            // `size`, which would shadow the lodash import here).
             if (typeof value !== 'string')
                 return invalidResult('Byte size must be a string');
-            var _m = (0, common_1.splitByteSize)(value), bytes = _m[0], sizeUnit = _m[1];
+            var _s = (0, common_1.splitByteSize)(value), bytes = _s[0], sizeUnit = _s[1];
             var bytesResult = (0, exports.validateFieldWithResult)('number', bytes);
             if (!bytesResult.isValid) {
                 return withContext(bytesResult, 'Byte size numeric part is invalid');
@@ -400,7 +1030,8 @@ var _validateField = function (type, value, field, canBeNull) {
             }
             return validResult();
         }
-        case 'url': {
+        case 'url':
+        case 'uri': {
             var protocolResult = (0, exports.validateFieldWithResult)('string', (0, common_1.getProtocol)(value));
             if (!protocolResult.isValid) {
                 return withContext(protocolResult, 'URL protocol is invalid');
@@ -412,8 +1043,7 @@ var _validateField = function (type, value, field, canBeNull) {
             return validResult();
         }
         case 'schema-definition': {
-            // No IDE counterpart (the editor validates inline there); this is the
-            // minimal NEW_FIELD.md shape check so malformed definitions can't
+            // The minimal NEW_FIELD.md shape check, so malformed definitions can't
             // silently save through FormEngine.
             if (!(0, isPlainObject_1.default)(value)) {
                 return invalidResult('Schema definition must be an object');
@@ -424,33 +1054,52 @@ var _validateField = function (type, value, field, canBeNull) {
             return validResult();
         }
         case 'expression': {
-            // Ported from qorus-ide validations `'expression'` case. The catalogue
-            // is supplied via `field.expressions` (the ExpressionBuilder passes it),
-            // not a global store as in the IDE.
             var castedValue_1 = value;
-            var expressions = (_d = field === null || field === void 0 ? void 0 : field.expressions) !== null && _d !== void 0 ? _d : [];
-            // Expressions not loaded yet — skip validation until they're available.
-            if (!(0, size_1.default)(expressions)) {
-                return validResult();
-            }
+            var expressions = readExpressionCatalogue(field);
+            // Expressions validation is complicated and needs to follow the following rules
+            // 1. If the expression is empty, it is invalid
+            // 2. If the expression has a type, it means its a normal argument (sub expressions don't have type)
+            // 3. If the expression has no type and `exp` is present, it is a sub expression and must be validated as such
+            // 4. If there are no `args` we need to check if the expression actually has any required arguments or what is the `min_args` property
+            // 1. If the expression is empty
+            //
+            // Checked BEFORE the catalogue guard below, and deliberately: an
+            // expression with no value, or with no operation chosen, is incomplete on
+            // its own terms. Nothing in the catalogue can make it valid, so making
+            // these two answers wait for a network fetch meant the same option
+            // reported valid or invalid depending on whether that fetch had landed —
+            // the field's own "show invalid only" filter listed a different set of
+            // rows on a fast machine than on a slow one.
             if (!castedValue_1) {
                 return invalidResult('Expression value is empty');
             }
-            if (!((_e = castedValue_1.value) === null || _e === void 0 ? void 0 : _e.exp)) {
+            if (!((_j = castedValue_1.value) === null || _j === void 0 ? void 0 : _j.exp)) {
                 return invalidResult('Expression operation is required');
             }
+            // Everything past this point needs the expression's definition, which
+            // only the catalogue can supply. Until it loads there is nothing to check
+            // against, so an expression that names an operation is left alone rather
+            // than reported against a catalogue we do not have.
+            if (!(0, size_1.default)(expressions)) {
+                return validResult();
+            }
+            // Get the expression definition from the catalogue
             var expressionDefinition = expressions.find(function (expr) { var _a; return expr.name === ((_a = castedValue_1.value) === null || _a === void 0 ? void 0 : _a.exp); });
             if (!expressionDefinition) {
-                return invalidResult("Expression definition ".concat(String((_f = castedValue_1.value) === null || _f === void 0 ? void 0 : _f.exp), " not found"));
+                return invalidResult("Expression definition ".concat(String((_k = castedValue_1.value) === null || _k === void 0 ? void 0 : _k.exp), " not found"));
             }
-            var hasRequiredArgs = (_g = expressionDefinition.args) === null || _g === void 0 ? void 0 : _g.some(function (arg) { return arg.required; });
-            if (!hasRequiredArgs && (0, size_1.default)(((_h = castedValue_1.value) === null || _h === void 0 ? void 0 : _h.args) || []) === 0) {
+            // If the expression has no required args, we can consider it valid
+            var hasRequiredArgs = (_l = expressionDefinition.args) === null || _l === void 0 ? void 0 : _l.some(function (arg) { return arg.required; });
+            if (!hasRequiredArgs && (0, size_1.default)(((_m = castedValue_1.value) === null || _m === void 0 ? void 0 : _m.args) || []) === 0) {
                 return validResult();
             }
-            if ((0, size_1.default)(((_j = castedValue_1.value) === null || _j === void 0 ? void 0 : _j.args) || []) < (expressionDefinition.min_args || 1)) {
+            // If there are no args provided but the expression requires some (normal expressions require at least 1 arg
+            // because we checked for required args earlier), or min_args is set
+            if ((0, size_1.default)(((_o = castedValue_1.value) === null || _o === void 0 ? void 0 : _o.args) || []) < (expressionDefinition.min_args || 1)) {
                 return invalidResult('Not enough arguments provided');
             }
-            var args = (_l = (_k = castedValue_1.value) === null || _k === void 0 ? void 0 : _k.args) !== null && _l !== void 0 ? _l : [];
+            // Now we need to validate each argument, either as a normal value or as a sub-expression
+            var args = (_q = (_p = castedValue_1.value) === null || _p === void 0 ? void 0 : _p.args) !== null && _q !== void 0 ? _q : [];
             for (var index = 0; index < args.length; index++) {
                 var argValue = args[index];
                 var argDefinition = expressionDefinition.varargs
@@ -488,7 +1137,6 @@ var _validateField = function (type, value, field, canBeNull) {
     }
 };
 exports._validateField = _validateField;
-// Memoized version
 /**
  * Read one arg out of a hash, whichever of the two legitimate shapes it is in.
  *
@@ -509,6 +1157,7 @@ var readArgValue = function (arg) {
     return (0, isPlainObject_1.default)(arg) && 'value' in arg ? arg.value : arg;
 };
 exports.readArgValue = readArgValue;
+// Memoized version
 exports.validateFieldWithResult = (0, lodash_1.memoize)(exports._validateField, function (type, value, field, canBeNull) {
     return "".concat(type, "-").concat(JSON.stringify(value), "-").concat(JSON.stringify(field), "-").concat(canBeNull);
 });
@@ -566,6 +1215,9 @@ var getValueOrDefaultValue = function (value, defaultValue, canBeNull) {
     return undefined;
 };
 exports.getValueOrDefaultValue = getValueOrDefaultValue;
+/** Deliberately un-annotated: the inferred literal union is what callers assign
+ *  into their own narrower type aliases, and widening it to `string` breaks
+ *  them. */
 var getTypeFromValue = function (value) {
     switch (true) {
         case (0, lodash_1.isNull)(value):
@@ -595,36 +1247,151 @@ var validateOptionWithRequiredGroups = function (options, schema, groups) {
         var optionsInGroups = (0, options_1.getOptionsFromRequiredGroups)(schema, groups);
         return optionsInGroups.some(function (option) {
             var _a, _b, _c;
-            return isValueDefined(((_a = schema[option]) === null || _a === void 0 ? void 0 : _a.ui_type) || ((_b = schema[option]) === null || _b === void 0 ? void 0 : _b.type), (_c = options === null || options === void 0 ? void 0 : options[option]) === null || _c === void 0 ? void 0 : _c.value);
+            return isValueDefined(((_a = schema[option]) === null || _a === void 0 ? void 0 : _a.ui_type) ||
+                ((_b = schema[option]) === null || _b === void 0 ? void 0 : _b.type), (_c = options === null || options === void 0 ? void 0 : options[option]) === null || _c === void 0 ? void 0 : _c.value);
         });
     }
     return true;
 };
 exports.validateOptionWithRequiredGroups = validateOptionWithRequiredGroups;
+var getUnresolvedRequiredOptionReason = function (_a, optionSchema) {
+    var _b;
+    var name = _a.name, reason = _a.reason;
+    switch (reason) {
+        case 'dependency':
+            return "Option ".concat(name, " dependencies are not fulfilled");
+        case 'invalid':
+            return "Option ".concat(name, " is invalid");
+        default:
+            return ((_b = optionSchema === null || optionSchema === void 0 ? void 0 : optionSchema[name]) === null || _b === void 0 ? void 0 : _b.required)
+                ? "Option ".concat(name, " is required")
+                : "Option ".concat(name, " requires a value");
+    }
+};
+exports.getUnresolvedRequiredOptionReason = getUnresolvedRequiredOptionReason;
+/**
+ * List every required option that the given values do not resolve.
+ *
+ * `required` on an option schema means "the effective configuration must carry
+ * this option" — NOT "the user has to type it in". An option whose schema
+ * default or preselected value already resolves it needs no user input at all,
+ * which is why callers pass values that have been through `fixOptions()`
+ * (defaults, preselected values and rich-text default envelopes applied)
+ * rather than the raw values the server returned.
+ *
+ * This is the single owner of the "which required options still need input"
+ * question: `validateField('options', …)` uses it for form validity, and
+ * qorus-ide's `ConnectionManagementModal` uses it to decide whether a
+ * connection can be created — and its OAuth2 flow started — without showing a
+ * form at all.
+ */
+var getUnresolvedRequiredOptions = function (optionSchema, options) {
+    if (optionSchema === void 0) { optionSchema = {}; }
+    if (options === void 0) { options = {}; }
+    var unresolved = [];
+    for (var _i = 0, _a = Object.entries(optionSchema !== null && optionSchema !== void 0 ? optionSchema : {}); _i < _a.length; _i++) {
+        var _b = _a[_i], name_1 = _b[0], schemaEntry = _b[1];
+        var optionData = schemaEntry;
+        if (!(optionData === null || optionData === void 0 ? void 0 : optionData.required) && !(0, size_1.default)(optionData === null || optionData === void 0 ? void 0 : optionData.required_groups)) {
+            continue;
+        }
+        var optionField = options === null || options === void 0 ? void 0 : options[name_1];
+        var optionValue = optionField && typeof optionField === 'object' ? optionField.value : optionField;
+        var optionType = ((typeof optionField === 'object' ? optionField === null || optionField === void 0 ? void 0 : optionField.type : undefined) ||
+            optionData.ui_type ||
+            optionData.type);
+        // A dependent option cannot be considered resolved while its dependencies
+        // are not: the schema it will be validated against — and with it any
+        // default the server would send — is not final yet.
+        if (optionData.depends_on &&
+            !(0, exports.hasAllDependenciesFullfilled)(optionData.depends_on, options, optionSchema)) {
+            unresolved.push({ name: name_1, reason: 'dependency' });
+            continue;
+        }
+        if (!isValueDefined(optionType, optionValue)) {
+            // An option required only through a group is resolved by any sibling in
+            // that group carrying a value.
+            if (optionData.required ||
+                !(0, exports.validateOptionWithRequiredGroups)(options, optionSchema, optionData.required_groups)) {
+                unresolved.push({ name: name_1, reason: 'missing' });
+            }
+            continue;
+        }
+        var validation = typeof optionField !== 'object'
+            ? (0, exports.validateFieldWithResult)((0, exports.getTypeFromValue)(optionField), optionField)
+            : (0, exports.validateFieldWithResult)(optionField.type, optionField.value, __assign(__assign({}, optionData), { optionSchema: optionSchema, options: options, isFunction: optionField.is_expression }));
+        if (!validation.isValid) {
+            unresolved.push({ name: name_1, reason: 'invalid', validation: validation });
+        }
+    }
+    return unresolved;
+};
+exports.getUnresolvedRequiredOptions = getUnresolvedRequiredOptions;
+/**
+ * Split a dependency entry into the sibling it names and how its value is compared.
+ *
+ * Three forms: `name` (the sibling must simply have a value), `name=value` (it must
+ * have exactly that value) and `name!=value` (it must have a value, and not that
+ * one). The negative form is what lets a field say it applies to every variant of a
+ * record but one — spelling that as an `any-of` list of every other variant is both
+ * unreadable in the "Depends on" lock and silently wrong the moment a variant is
+ * added.
+ *
+ * `!=` deliberately requires the sibling to be answered: "not X" is a statement about
+ * an answer, so an unanswered sibling does not satisfy it and the field stays locked.
+ */
+var parseDependency = function (dependency) {
+    var neqIdx = dependency.indexOf('!=');
+    if (neqIdx !== -1) {
+        return {
+            name: dependency.substring(0, neqIdx),
+            op: '!=',
+            value: dependency.substring(neqIdx + 2),
+        };
+    }
+    var eqIdx = dependency.indexOf('=');
+    if (eqIdx !== -1) {
+        return {
+            name: dependency.substring(0, eqIdx),
+            op: '=',
+            value: dependency.substring(eqIdx + 1),
+        };
+    }
+    return { name: dependency };
+};
+exports.parseDependency = parseDependency;
+/** Whether one dependency entry holds against the current form values. */
+var isDependencyFulfilled = function (dependency, options, optionsSchema) {
+    var _a;
+    var _b = (0, exports.parseDependency)(dependency), name = _b.name, op = _b.op, value = _b.value;
+    if (op) {
+        var optValue = (_a = options === null || options === void 0 ? void 0 : options[name]) === null || _a === void 0 ? void 0 : _a.value;
+        if (optValue == null) {
+            return false;
+        }
+        return op === '=' ? String(optValue) === value : String(optValue) !== value;
+    }
+    return (options === null || options === void 0 ? void 0 : options[name])
+        ? (0, exports.validateField)(options[name].type, options[name].value, __assign(__assign({}, optionsSchema === null || optionsSchema === void 0 ? void 0 : optionsSchema[name]), { options: options, optionSchema: optionsSchema }))
+        : true;
+};
 var hasAllDependenciesFullfilled = function (dependencies, options, optionsSchema) {
     if ((0, size_1.default)(dependencies) === 0) {
         return true;
     }
     return dependencies.every(function (dependency) {
-        var _a;
+        // A nested list is an ANY. It used to look each entry up as a whole form-field
+        // name, so a `name=value` entry inside one found no field and returned `true`
+        // unconditionally — the any-of group was satisfied by anything at all, while
+        // CompactRow's lock rendered those same entries as real comparisons. Both halves
+        // now go through one parser, so the grammar cannot mean two things.
         if ((0, isArray_1.default)(dependency)) {
             return dependency.some(function (dep) {
-                return (options === null || options === void 0 ? void 0 : options[dep])
-                    ? (0, exports.validateField)(options[dep].type, options[dep].value, __assign(__assign({}, optionsSchema === null || optionsSchema === void 0 ? void 0 : optionsSchema[dep]), { options: options, optionSchema: optionsSchema }))
-                    : true;
+                return isDependencyFulfilled(dep, options, optionsSchema);
             });
         }
-        if ((0, lodash_1.isString)(dependency)) {
-            var eqIdx = dependency.indexOf('=');
-            if (eqIdx !== -1) {
-                var depName = dependency.substring(0, eqIdx);
-                var depValue = dependency.substring(eqIdx + 1);
-                var optValue = (_a = options === null || options === void 0 ? void 0 : options[depName]) === null || _a === void 0 ? void 0 : _a.value;
-                return optValue != null && String(optValue) === depValue;
-            }
-        }
-        return (options === null || options === void 0 ? void 0 : options[dependency])
-            ? (0, exports.validateField)(options[dependency].type, options[dependency].value, __assign(__assign({}, optionsSchema === null || optionsSchema === void 0 ? void 0 : optionsSchema[dependency]), { options: options, optionSchema: optionsSchema }))
+        return (0, lodash_1.isString)(dependency)
+            ? isDependencyFulfilled(dependency, options, optionsSchema)
             : true;
     });
 };