form0-core 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "form0-core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -12,7 +12,7 @@
     "SECURITY.md"
   ],
   "scripts": {
-    "test": "node tests/form0-core.test.js && node tests/conditions.test.js && node tests/numeric-field-schema.test.js && node tests/dataset-descriptors.test.js && node tests/structured-record.test.js && node tests/title-fields.test.js && node tests/builtin-metadata.test.js && node tests/builtin-import-isolation.test.js && node tests/builtin-catalog-examples.test.js && node tests/date-builtins.test.js && node tests/calculation-expression-utils.test.js && node tests/calculation-editor.test.js && node tests/form-event-editor.test.js && node tests/form-authoring.test.js && node tests/calculation-dependency-engine.test.js && node tests/calculation-diagnostics.characterization.test.js && node tests/calculation-diagnostics.test.js && node tests/calculation-missing-result.test.js && node tests/evaluator-reentry.test.js && node tests/event-compatibility.characterization.test.js && node tests/event-hermes.test.js && node tests/event-async-isolation.test.js && node tests/managed-events.test.js && node tests/security-test.js",
+    "test": "node tests/form0-core.test.js && node tests/conditions.test.js && node tests/condition-scope.test.js && node tests/numeric-field-schema.test.js && node tests/dataset-descriptors.test.js && node tests/structured-record.test.js && node tests/title-fields.test.js && node tests/builtin-metadata.test.js && node tests/builtin-import-isolation.test.js && node tests/builtin-catalog-examples.test.js && node tests/date-builtins.test.js && node tests/calculation-expression-utils.test.js && node tests/calculation-editor.test.js && node tests/form-event-editor.test.js && node tests/form-authoring.test.js && node tests/calculation-dependency-engine.test.js && node tests/calculation-diagnostics.characterization.test.js && node tests/calculation-diagnostics.test.js && node tests/calculation-missing-result.test.js && node tests/evaluator-reentry.test.js && node tests/event-compatibility.characterization.test.js && node tests/event-hermes.test.js && node tests/event-async-isolation.test.js && node tests/managed-events.test.js && node tests/security-test.js",
     "format": "prettier --write \"src/**/*.{js,jsx}\" \"tests/**/*.{js,jsx}\" \"scripts/**/*.{js,mjs}\" package.json README.md EVENT_CONTRACT.md SECURITY.md SUPPORT.md CONTRIBUTING.md eslint.config.js .github/workflows/ci.yml .github/workflows/publish.yml",
     "format:check": "prettier --check \"src/**/*.{js,jsx}\" \"tests/**/*.{js,jsx}\" \"scripts/**/*.{js,mjs}\" package.json README.md EVENT_CONTRACT.md SECURITY.md SUPPORT.md CONTRIBUTING.md eslint.config.js .github/workflows/ci.yml .github/workflows/publish.yml",
     "lint:check": "eslint src tests",

package/src/engine/condition-context.js

@@ -0,0 +1,90 @@
+import { flattenFields } from '../utilities/field-helpers.js';
+import { ContextResolver } from './context-resolver.js';
+
+export const CONDITION_PROPERTIES = [
+  'visible_conditions',
+  'required_conditions',
+  'read_only_conditions',
+];
+
+/** Visit every reference, independently of boolean short-circuiting. */
+export function forEachConditionReference(conditions, visit) {
+  if (Array.isArray(conditions)) {
+    conditions.forEach((condition) => forEachConditionReference(condition, visit));
+    return;
+  }
+  if (!conditions || typeof conditions !== 'object') return;
+  if (conditions.field_id) visit(conditions);
+  if (conditions.and) forEachConditionReference(conditions.and, visit);
+  if (conditions.or) forEachConditionReference(conditions.or, visit);
+}
+
+/** Engine-private index, built once and shared by all three condition maps. */
+export function createConditionContext(schema, contextResolver = null, warningSystem = null) {
+  const fields = flattenFields(schema.elements);
+  const allFields = Object.create(null);
+  for (const field of fields) {
+    if (field.key) allFields[field.key] = field;
+    if (field.data_name) allFields[field.data_name] = field;
+  }
+  return {
+    fields,
+    allFields,
+    contextResolver: contextResolver || new ContextResolver(schema),
+    warningSystem,
+  };
+}
+
+export function getConditionReferenceIssues(owner, property, conditions, allFields, resolver) {
+  const issues = [];
+  const executionContext = {
+    type: 'condition',
+    fieldName: owner.data_name,
+    conditionProperty: property,
+    parentPath: [...(resolver.elementOwnership.get(owner.data_name)?.parentPath || [])],
+  };
+  forEachConditionReference(conditions, (condition) => {
+    const reference = condition.field_id;
+    const field = allFields[reference];
+    if (!field) {
+      issues.push({
+        reason: 'not_found',
+        reference,
+        executionContext,
+        message: `Condition references unknown field "${reference}" in field "${owner.data_name}"`,
+      });
+      return;
+    }
+    const access = resolver.resolveFieldAccessInfo(executionContext, field.data_name);
+    if (access.level === 'accessible') return;
+    const ownerPath = resolver.formatRepeatableSectionPath(executionContext.parentPath);
+    const referencePath = resolver.formatRepeatableSectionPath(access.fieldInfo?.parentPath || []);
+    issues.push({
+      reason: access.level === 'not_found' ? 'not_found' : 'restricted',
+      reference: field.data_name,
+      executionContext,
+      message: `Field "${owner.data_name}" ${property} references "${reference}" outside its record scope (owner: ${ownerPath}; reference: ${referencePath})`,
+    });
+  });
+  return issues;
+}
+
+export function assertConditionReferences(conditions, owner, property, context) {
+  const issues = getConditionReferenceIssues(
+    owner,
+    property,
+    conditions,
+    context.allFields,
+    context.contextResolver
+  );
+  if (!issues.length) return;
+  for (const issue of issues) {
+    const warning = context.contextResolver.generateAccessWarning(
+      issue.executionContext,
+      issue.reference,
+      issue.reason
+    );
+    context.warningSystem?.emitWarning({ ...warning, message: issue.message });
+  }
+  throw new Error(issues.map((issue) => issue.message).join('\n'));
+}

package/src/engine/conditions.js

@@ -1,4 +1,4 @@
-import { flattenFields } from '../utilities/field-helpers.js';
+import { assertConditionReferences, createConditionContext } from './condition-context.js';
 
 const valuesEqual = (a, b) => {
   if (Array.isArray(a) && Array.isArray(b)) {
@@ -81,37 +81,50 @@ function normalizeConditionValue(field, value) {
   return value;
 }
 
-export function evaluateConditions(conditions, values, allFields) {
+export function evaluateConditions(conditions, values, allFields, scope = null) {
+  if (scope) {
+    assertConditionReferences(conditions, scope.owner, scope.property, scope.context);
+  }
+  return evaluateConditionExpression(conditions, values, allFields);
+}
+
+function evaluateConditionExpression(conditions, values, allFields) {
   if (Array.isArray(conditions)) {
-    return conditions.every((c) => evaluateConditions(c, values, allFields));
+    return conditions.every((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   if (conditions.and) {
-    return conditions.and.every((c) => evaluateConditions(c, values, allFields));
+    return conditions.and.every((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   if (conditions.or) {
-    return conditions.or.some((c) => evaluateConditions(c, values, allFields));
+    return conditions.or.some((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   // Map field_id (key) to data_name for value lookup
   const field = allFields ? allFields[conditions.field_id] : undefined;
   const dataName = field ? field.data_name : undefined;
   const val = normalizeConditionValue(field, dataName ? values[dataName] : undefined);
-  // Debug log: show what is being checked
-  //console.log('[evaluateConditions] field_id:', conditions.field_id, 'data_name:', dataName, 'value in values:', val, 'expected:', conditions.value, 'operator:', conditions.operator);
   const fn = OPERATORS[conditions.operator];
   return fn ? fn(val, conditions.value) : false;
 }
 
+function evaluateElementCondition(owner, property, values, context) {
+  return evaluateConditions(owner[property], values, context.allFields, {
+    owner,
+    property,
+    context,
+  });
+}
+
 /**
  * Recursively evaluates visibility for both fields and sections in bottom-up order
  * @param {Array} elements - Form elements to evaluate
  * @param {Object} values - Current form values
  * @param {Object} visible - Visibility state object to populate
- * @param {Object} allFields - Map of all fields by key for condition evaluation
+ * @param {Object} context - Shared field index and ownership resolver
  */
-function evaluateVisibilityRecursive(elements, values, visible, allFields) {
+function evaluateVisibilityRecursive(elements, values, visible, context) {
   elements.forEach((element) => {
     if (
       element.type === 'Section' ||
@@ -120,7 +133,7 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
     ) {
       // First evaluate children (bottom-up approach)
       if (element.elements && element.elements.length > 0) {
-        evaluateVisibilityRecursive(element.elements, values, visible, allFields);
+        evaluateVisibilityRecursive(element.elements, values, visible, context);
 
         // Check if any child is visible
         const hasVisibleChild = element.elements.some(
@@ -133,7 +146,12 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
         } else {
           // At least one child visible → respect explicit section visibility settings
           if (element.visible_conditions) {
-            const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+            const isVisible = evaluateElementCondition(
+              element,
+              'visible_conditions',
+              values,
+              context
+            );
             visible[element.data_name] = isVisible;
           } else {
             visible[element.data_name] = element.visible === true;
@@ -142,7 +160,12 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
       } else {
         // Empty section fallback (though schema validation should prevent this)
         if (element.visible_conditions) {
-          const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+          const isVisible = evaluateElementCondition(
+            element,
+            'visible_conditions',
+            values,
+            context
+          );
           visible[element.data_name] = isVisible;
         } else {
           visible[element.data_name] = element.visible === true;
@@ -151,7 +174,7 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
     } else {
       // Regular field - existing logic
       if (element.visible_conditions) {
-        const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+        const isVisible = evaluateElementCondition(element, 'visible_conditions', values, context);
         visible[element.data_name] = isVisible;
       } else {
         visible[element.data_name] = element.visible === true;
@@ -160,34 +183,24 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
   });
 }
 
-export function evaluateVisibility(schema, values, visible) {
-  // Build allFields map by key using flattened fields for condition evaluation
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const fields = flattenFields(schema.elements);
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-
-  // Use recursive approach for single-pass visibility evaluation
-  evaluateVisibilityRecursive(schema.elements, values, visible, allFields);
+export function evaluateVisibility(
+  schema,
+  values,
+  visible,
+  context = createConditionContext(schema)
+) {
+  evaluateVisibilityRecursive(schema.elements, values, visible, context);
 }
 
-export function evaluateRequirement(schema, values, required) {
-  const fields = flattenFields(schema.elements);
-  // Build allFields map by key
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-  fields.forEach((field) => {
+export function evaluateRequirement(
+  schema,
+  values,
+  required,
+  context = createConditionContext(schema)
+) {
+  context.fields.forEach((field) => {
     if (field.required_conditions) {
-      const isRequired = evaluateConditions(field.required_conditions, values, allFields);
+      const isRequired = evaluateElementCondition(field, 'required_conditions', values, context);
       required[field.data_name] = isRequired;
     } else {
       required[field.data_name] = field.required === true;
@@ -195,19 +208,15 @@ export function evaluateRequirement(schema, values, required) {
   });
 }
 
-export function evaluateReadOnly(schema, values, read_only) {
-  const fields = flattenFields(schema.elements);
-  // Build allFields map by key
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-  fields.forEach((field) => {
+export function evaluateReadOnly(
+  schema,
+  values,
+  read_only,
+  context = createConditionContext(schema)
+) {
+  context.fields.forEach((field) => {
     if (field.read_only_conditions) {
-      const isReadOnly = evaluateConditions(field.read_only_conditions, values, allFields);
+      const isReadOnly = evaluateElementCondition(field, 'read_only_conditions', values, context);
       read_only[field.data_name] = isReadOnly;
     } else {
       read_only[field.data_name] = field.read_only === true;

package/src/engine/context-resolver.js

@@ -1,5 +1,5 @@
 /**
- * Context-aware field resolution for calculations and events
+ * Context-aware field resolution for calculations, conditions and events
  * Determines which fields are accessible based on execution context
  * Reuses tree-building logic from record-transformer.js
  */
@@ -10,6 +10,7 @@ export class ContextResolver {
   constructor(schema) {
     // Maps to store field context information (similar to record-transformer.js)
     this.fieldOwnership = new Map(); // Field data_name -> { preferredKey, field, parentPath }
+    this.elementOwnership = new Map(); // Includes containers in their containing record context.
     this.repeatableSectionTree = new Map(); // RepeatableSection data_name -> tree info
     this.sectionFields = new Set(); // Section field names (organizational only)
 
@@ -26,6 +27,12 @@ export class ContextResolver {
     if (!Array.isArray(elements)) return;
 
     elements.forEach((element) => {
+      const preferredKey =
+        typeof element.key === 'string' && element.key.trim() !== ''
+          ? element.key
+          : element.data_name;
+      const ownership = { preferredKey, field: element, parentPath: [...parentPath] };
+      this.elementOwnership.set(element.data_name, ownership);
       if (element.type === 'Section' || element.type === 'BuildingPlanSection') {
         this.sectionFields.add(element.data_name);
         // Recursively process Section children with same parentPath
@@ -34,8 +41,6 @@ export class ContextResolver {
           this.buildFieldContext(element.elements, parentPath);
         }
       } else if (element.type === 'RepeatableSection') {
-        const preferredKey =
-          element.key && element.key.trim() !== '' ? element.key : element.data_name;
         const currentPath = [...parentPath, preferredKey];
 
         // Store this RepeatableSection in the tree
@@ -54,13 +59,7 @@ export class ContextResolver {
         }
       } else {
         // This is a regular field - determine its ownership
-        const preferredFieldKey =
-          element.key && element.key.trim() !== '' ? element.key : element.data_name;
-        this.fieldOwnership.set(element.data_name, {
-          preferredKey: preferredFieldKey,
-          field: element,
-          parentPath: [...parentPath], // Copy the current path
-        });
+        this.fieldOwnership.set(element.data_name, ownership);
       }
     });
   }
@@ -146,6 +145,19 @@ export class ContextResolver {
   checkRepeatableSectionAccessInfo(executionContext, fieldName, fieldInfo) {
     const { type: contextType, eventType, fieldName: contextFieldName } = executionContext;
 
+    if (contextType === 'condition') {
+      const owner = this.elementOwnership.get(contextFieldName);
+      if (owner) {
+        return this.resolveRepeatableSectionRelationship(
+          owner.parentPath,
+          fieldInfo.parentPath,
+          fieldName,
+          fieldInfo,
+          executionContext
+        );
+      }
+    }
+
     if (contextType === 'calculation') {
       // CalculatedField can only access fields in same RepeatableSection context
       const calculationFieldInfo = this.fieldOwnership.get(contextFieldName);
@@ -318,6 +330,10 @@ export class ContextResolver {
   buildRestrictedAccessSuggestion(executionContext, fieldName, fieldInfo, code) {
     const { type: contextType, eventType } = executionContext;
 
+    if (contextType === 'condition') {
+      return `Conditions can only reference fields in their containing record or its ancestors. Field '${fieldName}' belongs to: ${this.formatRepeatableSectionPath(fieldInfo.parentPath)}`;
+    }
+
     if (contextType === 'calculation') {
       if (code === 'different_repeatable_section') {
         return `CalculatedField can only access fields in the same RepeatableSection or ancestor contexts. Field '${fieldName}' is in RepeatableSection: ${this.formatRepeatableSectionPath(fieldInfo.parentPath)}`;

package/src/engine/form-engine.js

@@ -4,7 +4,8 @@ import { evaluateRequirement } from './conditions.js';
 import { evaluateReadOnly } from './conditions.js';
 import { validateFields } from './field-validation.js';
 import { calculationBuiltins, eventBuiltins } from '../builtins/registry.js';
-import { validateSchema } from '../schema/schema-validator.js';
+import { validateSchemaWithContext } from '../schema/schema-validator.js';
+import { createConditionContext } from './condition-context.js';
 import { flattenFields } from '../utilities/field-helpers.js';
 import { DEFAULT_SECURITY_CONFIG } from '../security/config.js';
 import { EventManager } from './events.js';
@@ -77,7 +78,8 @@ export function createFormEngine({
 }) {
   const { schema: preparedSchema, buildingPlanMeta } = expandBuildingPlanSchema(schema);
 
-  validateSchema(preparedSchema.form);
+  const contextResolver = new ContextResolver(preparedSchema.form);
+  validateSchemaWithContext(preparedSchema.form, contextResolver);
 
   const { form } = preparedSchema;
   const values = { ...initialValues };
@@ -147,9 +149,9 @@ export function createFormEngine({
   const allHelpers = { ...calculationBuiltins, ...helpers };
 
   // Initialize context resolution system
-  const contextResolver = new ContextResolver(form);
   const calculationPlan = buildCalculationDependencyPlan(form, contextResolver);
   const sharedWarningSystem = warningSystem || new WarningSystem();
+  const conditionContext = createConditionContext(form, contextResolver, sharedWarningSystem);
   const calculationDiagnostics = createCalculationDiagnostics(
     diagnostics,
     onDiagnostics,
@@ -196,9 +198,9 @@ export function createFormEngine({
         calculationPlan,
         calculationDiagnostics
       );
-      evaluateRequirement(form, values, required);
-      evaluateVisibility(form, values, visible);
-      evaluateReadOnly(form, values, read_only);
+      evaluateRequirement(form, values, required, conditionContext);
+      evaluateVisibility(form, values, visible, conditionContext);
+      evaluateReadOnly(form, values, read_only, conditionContext);
       validateFields(form, values, errors);
     } catch (error) {
       calculationDiagnostics.abort(frame);

package/src/engine/managed-events.js

@@ -9,8 +9,14 @@ function copy(value, seen = new Map()) {
   if (value === null || typeof value !== 'object') return value;
   if (seen.has(value)) return seen.get(value);
   if (value instanceof Date) return new Date(value.getTime());
+  // Media controls retain native binary handles. Copy their immutable data and standard metadata
+  // without serializing custom properties or loading the bytes into JavaScript memory.
+  if (typeof File === 'function' && value instanceof File)
+    return new File([value], value.name, { type: value.type, lastModified: value.lastModified });
+  if (typeof Blob === 'function' && value instanceof Blob)
+    return Blob.prototype.slice.call(value, 0, value.size, value.type);
   if (!Array.isArray(value) && ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
-    throw new Error('Event data must use plain objects, arrays or dates.');
+    throw new Error('Event data must use plain objects, arrays, dates or native media handles.');
   const result = Array.isArray(value) ? [] : {};
   seen.set(value, result);
   for (const key of Object.keys(value)) {

package/src/engine/warning-system.js

@@ -179,6 +179,10 @@ export class WarningSystem {
       return `CalculatedField '${fieldName}'`;
     }
 
+    if (type === 'condition') {
+      return `${executionContext.conditionProperty} on '${fieldName}'`;
+    }
+
     if (type === 'event') {
       if (fieldName) {
         return `Event '${eventType}' on field '${fieldName}'`;

package/src/schema/operators.js

@@ -1,4 +1,5 @@
 import { FIELD_TYPES } from '../utilities/field-types.js';
+import { forEachConditionReference } from '../engine/condition-context.js';
 
 // Define which operators are valid for each field type
 const FIELD_TYPE_OPERATORS = {
@@ -188,26 +189,7 @@ export function validateFieldConditions(field, conditions, allFields = {}) {
     return { isValid: false, errors };
   }
 
-  // Skip validation for container fields
-  if (
-    field.type === 'Section' ||
-    field.type === 'LabelField' ||
-    field.type === 'RepeatableSection'
-  ) {
-    return { isValid: true, errors: [] };
-  }
-
   const validateCondition = (condition) => {
-    if (condition.and) {
-      condition.and.forEach(validateCondition);
-      return;
-    }
-
-    if (condition.or) {
-      condition.or.forEach(validateCondition);
-      return;
-    }
-
     // Use field_id (normalized to key by ensure-keys.js)
     if (condition.operator && condition.field_id) {
       // Find the target field being referenced
@@ -236,11 +218,7 @@ export function validateFieldConditions(field, conditions, allFields = {}) {
     }
   };
 
-  if (Array.isArray(conditions)) {
-    conditions.forEach(validateCondition);
-  } else {
-    validateCondition(conditions);
-  }
+  forEachConditionReference(conditions, validateCondition);
 
   return { isValid: errors.length === 0, errors };
 }

package/src/schema/schema-validator.js

@@ -4,6 +4,8 @@ import { isSupportedFieldType } from '../utilities/field-types.js';
 import { validateFieldConditions } from './operators.js';
 import { validateFormAIMetadata } from './ai-metadata-validator.js';
 import { buildDatasetDescriptors } from '../utilities/dataset-descriptors.js';
+import { ContextResolver } from '../engine/context-resolver.js';
+import { CONDITION_PROPERTIES, getConditionReferenceIssues } from '../engine/condition-context.js';
 
 const toNonEmptyString = (value) =>
   typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
@@ -72,6 +74,11 @@ const validateScopedTitleFields = (form, errors) => {
 };
 
 export function validateSchema(form) {
+  return validateSchemaWithContext(form, new ContextResolver(form));
+}
+
+// Internal entrypoint lets engine construction reuse its ownership index.
+export function validateSchemaWithContext(form, contextResolver) {
   const fields = flattenFields(form.elements);
   const seenDataNames = new Set();
   const seenKeys = new Set();
@@ -85,7 +92,7 @@ export function validateSchema(form) {
   }
 
   // Create a map of all fields by key and data_name for condition validation
-  const allFields = {};
+  const allFields = Object.create(null);
   fields.forEach((field) => {
     if (field.key) {
       allFields[field.key] = field;
@@ -145,25 +152,18 @@ export function validateSchema(form) {
       errors.push(...fieldValidation.errors);
     }
 
-    // Validate conditions for all field types
-    if (field.visible_conditions) {
-      const validation = validateFieldConditions(field, field.visible_conditions, allFields);
-      if (!validation.isValid) {
-        errors.push(...validation.errors);
-      }
-    }
-
-    if (field.required_conditions) {
-      const validation = validateFieldConditions(field, field.required_conditions, allFields);
-      if (!validation.isValid) {
-        errors.push(...validation.errors);
-      }
-    }
-
-    if (field.read_only_conditions) {
-      const validation = validateFieldConditions(field, field.read_only_conditions, allFields);
-      if (!validation.isValid) {
-        errors.push(...validation.errors);
+    for (const property of CONDITION_PROPERTIES) {
+      if (!field[property]) continue;
+      const conditionErrors = validateFieldConditions(field, field[property], allFields).errors;
+      errors.push(...conditionErrors);
+      for (const issue of getConditionReferenceIssues(
+        field,
+        property,
+        field[property],
+        allFields,
+        contextResolver
+      )) {
+        if (!conditionErrors.includes(issue.message)) errors.push(issue.message);
       }
     }