@relyio/cli 0.4.0 → 0.5.0

package/dist/index.js

@@ -3687,8 +3687,8 @@ function isCommonProtocol(protocol) {
   return commonProtocols.includes(protocol.toLowerCase());
 }
 var QUERY_ENDPOINT_SEGMENT, QUERY_ENDPOINT_PATTERN, PARAMETER_EXPRESSION_SOURCE, parameterExpressionMatcher, ANCHORED_PARAMETER_EXPRESSION, parseDefault, parseParameterExpression, collectParameterExpressions, endpointPathParameters, ParameterExpressionStringSchema, QUERY_PARAMETER_TYPES, QueryParameterTypeSchema, QueryParameterScalarSchema, QueryParameterSchema, typeOfDefault, declareQueryParameters, SEARCH_SCORE_SORT_KEYS, isSearchScoreSortKey, QUERY_SYSTEM_FIELDS, isQuerySystemField, QUERY_STORAGE_PATH_PREFIX, QUERY_SYSTEM_ROOTS, SEARCH_SELECT_COLUMNS, isSearchSelectColumn, parseDynamicParameter, ParameterizedLimitSchema, ParameterizedOffsetSchema, ScalarSchema, WhereOperatorObjectSchema, FilterOperatorObjectSchema, HavingOperatorObjectSchema, WhereValueSchema, WhereConditionSchema, SortConditionSchema, EnhancedIncludeObjectSchema, IncludeDefinitionSchema, SelectMappingSchema, FilterDefinitionSchema, FullTextSearchSchema, ContentTypesSchema, SearchBlockSchema, AggregationMetricSchema, QueryCardinalitySchema, QueryCachePolicySchema, FetchBlockSchema, AggregateBlockSchema, IncludeSubQueriesSchema, QueryDefinitionSchema, CACHE_POLICY_STRING, normalizeQueryCachePolicy, CONTENT_API_ROUTE_SEGMENTS, RESERVED_TYPE_IDS, getComponentIdFromType, ComponentSchema, ContentTypeSchema, SettingsGroupSchema, SchemaDefinitionSchema;
-var init_chunk_L6HCY63G = __esm({
-  "../../domain/schema/dist/chunk-L6HCY63G.js"() {
+var init_chunk_LKXAZEW4 = __esm({
+  "../../domain/schema/dist/chunk-LKXAZEW4.js"() {
     init_chunk_CE6CNF7I();
     init_chunk_QG7U6KYM();
     init_chunk_W6RFZ2TV();
@@ -5187,6 +5187,9 @@ function classifyCompatibility(diff2) {
   }
   return { level, safeToMerge, additionsOnly, breakingChanges };
 }
+function isCrossVersionCheckCode(code) {
+  return Object.hasOwn(CROSS_VERSION_CHECKS, code);
+}
 function isConditionObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5339,10 +5342,10 @@ function notComparedWarning(part, refusals) {
     suggestion: "Nothing to change for it: this deploy replaces the deployed definition, and the next deploy is compared against all of it"
   };
 }
-var USAGE_CONTAINERS, BaseValidator, ValidationUtils, NamingValidator, StructuralValidator, FieldConfigValidator, CrossReferenceValidator, ComponentValidator, ComponentFieldTypeValidator, ComponentValidationUtils, ComponentReusabilityValidator, ComponentFieldStructureValidator, ComponentUsageContextValidator, ComponentNestingValidator, FieldsetValidator, CONTENT_TYPE_PROPS, COMPONENT_PROPS, GROUP_PROPS, QUERY_BASIC_PROPS, QUERY_OPTIONAL_PROPS, QUERY_DSL_BLOCKS, LOCALE_PROPS, ROLE_PROPS, WORKFLOW_STAGE_PROPS, VIEW_PROPS, FIELDSET_PROPS, ASSET_TYPE_PROPS, ASSET_KIND_BLOCKS, ASSET_KIND_KEY_MARKER, FILE_LOCALIZATION_MARKER, FIELD_REQUIRED_CHANGE_KEY, SchemaDiffer, ADDED_LABEL, CROSS_VERSION_CHECKS, EvolutionValidator, HierarchicalContentValidator, FieldRulesValidator, LocalizationValidator, LocaleConfigValidator, SettingsGroupsValidator, SingletonContentTypesValidator, FORBIDDEN_TYPES, AssetTypesValidator, FieldUIValidator, BENEATH, ANY_JOIN, DslQueryValidator, DataIntegrityValidator, RolesValidator, EVOLUTION_VALIDATOR_KEY, CROSS_VERSION_CHECKS_SKIPPED, ValidationPipeline, SchemaValidator, FIELD_SECTIONS, OPERATION_TIER, DEPLOY_VALIDATION_CONFIG;
+var USAGE_CONTAINERS, BaseValidator, ValidationUtils, NamingValidator, StructuralValidator, FieldConfigValidator, CrossReferenceValidator, ComponentValidator, ComponentFieldTypeValidator, ComponentValidationUtils, ComponentReusabilityValidator, ComponentFieldStructureValidator, ComponentUsageContextValidator, ComponentNestingValidator, FieldsetValidator, CONTENT_TYPE_PROPS, COMPONENT_PROPS, GROUP_PROPS, QUERY_BASIC_PROPS, QUERY_OPTIONAL_PROPS, QUERY_DSL_BLOCKS, LOCALE_PROPS, ROLE_PROPS, WORKFLOW_STAGE_PROPS, VIEW_PROPS, FIELDSET_PROPS, ASSET_TYPE_PROPS, ASSET_KIND_BLOCKS, ASSET_KIND_KEY_MARKER, FILE_LOCALIZATION_MARKER, FIELD_REQUIRED_CHANGE_KEY, SchemaDiffer, ADDED_LABEL, CROSS_VERSION_CHECKS, CROSS_VERSION_CODES, EvolutionValidator, HierarchicalContentValidator, FieldRulesValidator, LocalizationValidator, LocaleConfigValidator, SettingsGroupsValidator, SingletonContentTypesValidator, FORBIDDEN_TYPES, AssetTypesValidator, FieldUIValidator, BENEATH, ANY_JOIN, DslQueryValidator, DataIntegrityValidator, RolesValidator, EVOLUTION_VALIDATOR_KEY, CROSS_VERSION_CHECKS_SKIPPED, ValidationPipeline, SchemaValidator, FIELD_SECTIONS, OPERATION_TIER, DEPLOY_VALIDATION_CONFIG;
 var init_dist2 = __esm({
   "../../domain/schema/dist/index.js"() {
-    init_chunk_L6HCY63G();
+    init_chunk_LKXAZEW4();
     init_chunk_EGQAMYAG();
     init_chunk_LDBRHF5K();
     init_chunk_GICJZDXP();
@@ -5651,32 +5654,7 @@ var init_dist2 = __esm({
         this.checkNamingConventions(name, type, path25, result);
       }
       validateFieldName(field, path25, result, reservedKeywords) {
-        if (!field.id) {
-          result.errors.push(
-            this.createError(
-              "MISSING_FIELD_ID",
-              "Field is missing required id property",
-              path25,
-              "error",
-              "Add an id property to the field",
-              true
-            )
-          );
-          return;
-        }
         const fieldId = field.id;
-        if (!ValidationUtils.isValidName(fieldId)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_FIELD_NAME",
-              `Field id '${fieldId}' is invalid. Must start with a letter and contain only letters, numbers, and underscores`,
-              `${path25}.id`,
-              "error",
-              'Use a valid identifier format (e.g., "myField", "my_field")',
-              true
-            )
-          );
-        }
         if (reservedKeywords.includes(fieldId.toLowerCase())) {
           const suggestion = ValidationUtils.findBestMatch(fieldId, [
             "my" + fieldId,
@@ -5760,31 +5738,13 @@ var init_dist2 = __esm({
       feature = "structural";
       async validate(index) {
         const result = this.createResult();
-        try {
-          SchemaDefinitionSchema.parse(index.schema);
-          this.validateContentTypeStructure(index, result);
-          this.validateComponentStructure(index, result);
-          this.validateQueryStructure(index, result);
-          this.validateSettingsStructure(index, result);
-        } catch (error2) {
-          if (error2 instanceof z.ZodError) {
-            this.convertZodErrors(error2, result);
-          } else {
-            result.errors.push(
-              this.createError(
-                "STRUCTURAL_VALIDATION_FAILED",
-                "Schema structural validation failed",
-                "root",
-                "error",
-                "Check schema format and required properties"
-              )
-            );
-          }
-        }
+        this.validateContentTypeStructure(index, result);
+        this.validateComponentStructure(index, result);
+        this.validateSettingsStructure(index, result);
         return result;
       }
       validateContentTypeStructure(index, result) {
-        if (!index.schema.contentTypes || index.contentTypes.ids.length === 0) {
+        if (index.contentTypes.ids.length === 0) {
           result.warnings.push(
             this.createError(
               "NO_CONTENT_TYPES",
@@ -5796,17 +5756,6 @@ var init_dist2 = __esm({
           );
         }
         for (const [typeId, contentType] of index.contentTypes.entries) {
-          if (!contentType.fields || contentType.fields.length === 0 && !contentType.fieldsets) {
-            result.warnings.push(
-              this.createError(
-                "EMPTY_CONTENT_TYPE",
-                `Content type '${typeId}' has no fields`,
-                `contentTypes.${typeId}`,
-                "warning",
-                "Add fields to make this content type useful"
-              )
-            );
-          }
           this.validateFieldsStructure(
             contentType.fields || [],
             `contentTypes.${typeId}.fields`,
@@ -5816,7 +5765,7 @@ var init_dist2 = __esm({
       }
       validateComponentStructure(index, result) {
         for (const [componentId, component] of index.components.entries) {
-          if (!component.fields || component.fields.length === 0) {
+          if (component.fields.length === 0) {
             result.errors.push(
               this.createError(
                 "EMPTY_COMPONENT",
@@ -5831,147 +5780,23 @@ var init_dist2 = __esm({
           }
         }
       }
-      validateQueryStructure(index, result) {
-        for (const [queryId, query] of Object.entries(index.schema.queries || {})) {
-          if (!query.endpoint) {
-            result.errors.push(
-              this.createError(
-                "MISSING_QUERY_ENDPOINT",
-                `Query '${queryId}' is missing endpoint`,
-                `queries.${queryId}`,
-                "error",
-                "All queries must have an endpoint property"
-              )
-            );
-          }
-          const blocks = queryBlocksOf(query);
-          if (blocks.length === 0) {
-            result.errors.push(
-              this.createError(
-                "MISSING_QUERY_TYPE",
-                `Query '${queryId}' must have one of: ${QUERY_BLOCKS_SPELLED}`,
-                `queries.${queryId}`,
-                "error",
-                `Add a ${QUERY_BLOCKS_SPELLED} block to define the query operation`
-              )
-            );
-          }
-          if (query.fetch) {
-            this.validateFetchStructure(query.fetch, queryId, result);
-          }
-          if (query.aggregate) {
-            this.validateAggregateStructure(query.aggregate, queryId, Boolean(query.fetch), result);
-          }
-          if (query.search) {
-            this.validateSearchStructure(query.search, queryId, result);
-          }
-        }
-      }
-      validateFetchStructure(fetch2, queryId, result) {
-        const basePath = `queries.${queryId}.fetch`;
-        if (!fetch2.contentType && !fetch2.singleton) {
-          result.errors.push(
-            this.createError(
-              "FETCH_MISSING_TARGET",
-              `Fetch operation in query '${queryId}' must specify contentType or singleton`,
-              basePath,
-              "error",
-              "Add contentType or singleton property to the fetch operation"
-            )
-          );
-        }
-        if (fetch2.contentType && fetch2.singleton) {
-          result.errors.push(
-            this.createError(
-              "FETCH_MULTIPLE_TARGETS",
-              `Fetch operation in query '${queryId}' cannot have both contentType and singleton`,
-              basePath,
-              "error",
-              "Use either contentType OR singleton, not both"
-            )
-          );
-        }
-      }
-      validateAggregateStructure(aggregate, queryId, hasFetch, result) {
-        const basePath = `queries.${queryId}.aggregate`;
-        if (!hasFetch && !aggregate.source) {
-          result.errors.push(
-            this.createError(
-              "AGGREGATE_MISSING_SOURCE",
-              `Aggregate operation in query '${queryId}' must specify source content type when not used with fetch`,
-              `${basePath}.source`,
-              "error",
-              "Add source property to specify which content type to aggregate, or use with a fetch block"
-            )
-          );
-        }
-      }
-      validateSearchStructure(search, queryId, result) {
-        const basePath = `queries.${queryId}.search`;
-        if (!search.contentType && !search.contentTypes) {
-          result.errors.push(
-            this.createError(
-              "SEARCH_MISSING_CONTENT_TYPE",
-              `Search operation in query '${queryId}' must specify contentType or contentTypes`,
-              basePath,
-              "error",
-              "Add contentType for single type search, or contentTypes for multi-type/global search"
-            )
-          );
-        }
-        if (!search.query) {
-          result.errors.push(
-            this.createError(
-              "SEARCH_MISSING_QUERY",
-              `Search operation in query '${queryId}' must specify a search query`,
-              `${basePath}.query`,
-              "error",
-              'Add query property with search string or parameter like "${q}"'
-            )
-          );
-        }
-      }
       validateSettingsStructure(index, result) {
         for (const [settingsId, settingsGroup] of index.settingsGroups.entries) {
-          if (!settingsGroup.fields || settingsGroup.fields.length === 0) {
-            result.warnings.push(
-              this.createError(
-                "EMPTY_SETTINGS_GROUP",
-                `Settings group '${settingsId}' has no fields`,
-                `settingsGroups.${settingsId}`,
-                "warning",
-                "Settings groups should have configuration fields"
-              )
-            );
-          } else {
-            this.validateFieldsStructure(
-              settingsGroup.fields,
-              `settingsGroups.${settingsId}.fields`,
-              result
-            );
-          }
+          this.validateFieldsStructure(
+            settingsGroup.fields,
+            `settingsGroups.${settingsId}.fields`,
+            result
+          );
         }
       }
       validateFieldsStructure(fields, basePath, result) {
-        for (const [index, field] of fields.entries()) {
-          const fieldIdentifier = field.id || `[${index}]`;
-          const fieldPath = `${basePath}.${fieldIdentifier}`;
-          if (!field.id) {
-            result.errors.push(
-              this.createError(
-                "MISSING_FIELD_ID",
-                `Field at index ${index} is missing id`,
-                fieldPath,
-                "error",
-                "All fields must have an id property"
-              )
-            );
-          }
+        for (const field of fields) {
+          const fieldPath = `${basePath}.${field.id}`;
           if (!field.type) {
             result.errors.push(
               this.createError(
                 "MISSING_FIELD_TYPE",
-                `Field '${field.id || `at index ${index}`}' is missing type`,
+                `Field '${field.id}' is missing type`,
                 fieldPath,
                 "error",
                 "All fields must have a type property"
@@ -6044,53 +5869,6 @@ var init_dist2 = __esm({
           }
         }
       }
-      convertZodErrors(zodError, result) {
-        for (const error2 of zodError.errors) {
-          const path25 = error2.path.join(".");
-          let message = error2.message;
-          let suggestion;
-          switch (error2.code) {
-            case "invalid_enum_value": {
-              const options = "options" in error2 ? error2.options : [];
-              message = `Invalid value. Expected one of: ${options.join(", ")}`;
-              suggestion = `Use one of the valid options: ${options.join(", ")}`;
-              break;
-            }
-            case "invalid_type": {
-              const expected = error2.expected;
-              const received = error2.received;
-              message = `Expected ${expected}, received ${received}`;
-              suggestion = `Change the value to be of type ${expected}`;
-              break;
-            }
-            case "too_small": {
-              const minimum = error2.minimum;
-              message = `Value is too small. Minimum: ${minimum}`;
-              suggestion = `Increase the value to at least ${minimum}`;
-              break;
-            }
-            case "too_big": {
-              const maximum = error2.maximum;
-              message = `Value is too large. Maximum: ${maximum}`;
-              suggestion = `Decrease the value to at most ${maximum}`;
-              break;
-            }
-            case "invalid_string": {
-              if (error2.validation === "email") {
-                message = "Invalid email format";
-                suggestion = "Provide a valid email address";
-              } else if (error2.validation === "url") {
-                message = "Invalid URL format";
-                suggestion = "Provide a valid URL starting with http:// or https://";
-              }
-              break;
-            }
-          }
-          result.errors.push(
-            this.createError("SCHEMA_VALIDATION_ERROR", message, path25 || "root", "error", suggestion)
-          );
-        }
-      }
     };
     FieldConfigValidator = class extends BaseValidator {
       feature = "fieldConfigurations";
@@ -6888,20 +6666,7 @@ var init_dist2 = __esm({
                       }
                     }
                 } else {
-                  if (contentTypeFields.has(field.id)) {
-                    result.errors.push(
-                      this.createError(
-                        "DUPLICATE_FIELD_NAME",
-                        `Duplicate field name '${field.id}' in content type '${contentTypeId}'`,
-                        `contentTypes.${contentTypeId}.fields.${field.id}`,
-                        "error",
-                        "Field names must be unique within a content type",
-                        true
-                      )
-                    );
-                  } else {
-                    contentTypeFields.set(field.id, field.type);
-                  }
+                  contentTypeFields.set(field.id, field.type);
                 }
               }
             }
@@ -6925,20 +6690,7 @@ var init_dist2 = __esm({
         for (const [componentId, component] of index.components.entries) {
           const fieldTypes = /* @__PURE__ */ new Map();
           if (component.fields)
-            for (const [index2, field] of component.fields.entries()) {
-              if (!field.id) {
-                result.errors.push(
-                  this.createError(
-                    "COMPONENT_FIELD_MISSING_ID",
-                    `Field at index ${index2} in component '${componentId}' is missing id`,
-                    `components.${componentId}.fields[${index2}]`,
-                    "error",
-                    "All component fields must have unique identifiers",
-                    true
-                  )
-                );
-                continue;
-              }
+            for (const field of component.fields) {
               if (!field.type) {
                 result.errors.push(
                   this.createError(
@@ -6985,7 +6737,7 @@ var init_dist2 = __esm({
           }
           for (const [index2, field] of fields.entries()) {
             const fieldPath = `components.${componentId}.fields.${field.id || `[${index2}]`}`;
-            if (!field.id || !field.type) {
+            if (!field.type) {
               result.errors.push(
                 this.createError(
                   "INCOMPLETE_FIELD_STRUCTURE",
@@ -7031,17 +6783,6 @@ var init_dist2 = __esm({
           if (component.fields)
             for (const field of component.fields) {
               const fieldPath = `components.${componentId}.fields.${field.id}`;
-              if (field.id && field.id.includes(".")) {
-                result.warnings.push(
-                  this.createError(
-                    "FIELD_NAME_SERIALIZATION_RISK",
-                    `Field '${field.id}' in component '${componentId}' contains dots which may cause serialization issues`,
-                    fieldPath,
-                    "warning",
-                    "Use underscores or camelCase instead of dots in field names"
-                  )
-                );
-              }
               if (field.id && field.id.length > 50) {
                 result.warnings.push(
                   this.createError(
@@ -7103,22 +6844,6 @@ var init_dist2 = __esm({
         for (const [componentId, component] of index.components.entries) {
           const usagePattern = componentUsagePatterns[componentId];
           if (!usagePattern) continue;
-          if (this.isSeoComponent(componentId, component)) {
-            for (const contentTypeId of usagePattern.usedInContentTypes) {
-              const contentType = index.schema.contentTypes?.[contentTypeId];
-              if (contentType && this.isNonPublicContentType(contentType)) {
-                result.warnings.push(
-                  this.createError(
-                    "SEO_COMPONENT_IN_PRIVATE_CONTENT",
-                    `SEO component '${componentId}' is used in non-public content type '${contentTypeId}'`,
-                    `contentTypes.${contentTypeId}`,
-                    "warning",
-                    "Consider whether SEO metadata is needed for internal/private content types"
-                  )
-                );
-              }
-            }
-          }
           if (this.isSystemComponent(componentId, component)) {
             for (const contentTypeId of usagePattern.usedInContentTypes) {
               result.warnings.push(
@@ -7278,20 +7003,6 @@ var init_dist2 = __esm({
         }
         return patterns;
       }
-      isSeoComponent(componentId, component) {
-        const seoKeywords = ["seo", "meta", "og", "twitter", "social"];
-        const componentName = componentId.toLowerCase();
-        return seoKeywords.some((keyword) => componentName.includes(keyword)) || (component.fields || []).some(
-          (field) => field.id && seoKeywords.some((keyword) => field.id.toLowerCase().includes(keyword))
-        );
-      }
-      isNonPublicContentType(contentType) {
-        const internalKeywords = ["admin", "system", "internal", "private", "draft"];
-        const ct = contentType;
-        const typeName = ct.id?.toLowerCase() || "";
-        const visibility = ct.metadata?.visibility;
-        return internalKeywords.some((keyword) => typeName.includes(keyword)) || visibility === "private";
-      }
       isSystemComponent(componentId, _component) {
         const systemKeywords = ["system", "admin", "internal", "config"];
         return systemKeywords.some((keyword) => componentId.toLowerCase().includes(keyword));
@@ -7305,15 +7016,12 @@ var init_dist2 = __esm({
           );
           return componentField ? {
             fieldName: componentField.id,
-            hasRules: (componentField.rules || []).length > 0,
-            isRequired: componentField.required || false
+            hasRules: (componentField.rules || []).length > 0
           } : null;
         }).filter(Boolean);
         if (usagePatterns.length < 2) return false;
         const firstPattern = usagePatterns[0];
-        return usagePatterns.some(
-          (pattern) => pattern && (pattern.hasRules !== firstPattern?.hasRules || pattern.isRequired !== firstPattern?.isRequired)
-        );
+        return usagePatterns.some((pattern) => pattern && pattern.hasRules !== firstPattern?.hasRules);
       }
     };
     ComponentNestingValidator = class extends BaseValidator {
@@ -8641,13 +8349,36 @@ var init_dist2 = __esm({
       settingsGroups: "settings groups"
     };
     CROSS_VERSION_CHECKS = {
-      FIELD_TYPE_CHANGE_FORBIDDEN: "a field's type change",
-      REFERENCE_TARGET_REMOVED: "a removed reference target",
-      MISSING_DEPRECATION_MARKER: "a replacement field beside an undeprecated one"
+      FIELD_TYPE_CHANGE_FORBIDDEN: {
+        names: "a field's type change",
+        severity: "error",
+        fixable: false
+      },
+      REFERENCE_TARGET_REMOVED: {
+        names: "a removed reference target",
+        severity: "error",
+        fixable: false
+      },
+      MISSING_DEPRECATION_MARKER: {
+        names: "a replacement field beside an undeprecated one",
+        severity: "warning",
+        fixable: true
+      }
     };
+    CROSS_VERSION_CODES = Object.keys(CROSS_VERSION_CHECKS);
     EvolutionValidator = class extends BaseValidator {
       feature = "schemaEvolution";
       schemaDiffer = new SchemaDiffer();
+      /**
+       * Each cross-version check's finder, under the code {@link CROSS_VERSION_CHECKS} reports it by. A
+       * code the table gains is a missing property here until it has a finder, and a finder under a code
+       * the table does not name is an excess one.
+       */
+      crossVersionFinders = {
+        FIELD_TYPE_CHANGE_FORBIDDEN: (comparison) => this.fieldTypeChanges(comparison),
+        REFERENCE_TARGET_REMOVED: (comparison) => this.removedReferenceTargets(comparison),
+        MISSING_DEPRECATION_MARKER: (comparison) => this.undeprecatedReplacements(comparison)
+      };
       async validate(index) {
         const result = this.createResult();
         this.validateEvolutionReadiness(index, result);
@@ -8660,13 +8391,22 @@ var init_dist2 = __esm({
         const result = this.createResult();
         const newIndex = buildSchemaIndex(newSchema);
         this.validateEvolutionReadiness(newIndex, result);
-        this.validateFieldTypeImmutability(oldSchema, newSchema, result);
-        this.validateDeprecationWorkflow(oldSchema, newSchema, result);
-        this.validateReferenceTargetRemovals(oldSchema, newIndex, result);
+        const comparison = {
+          previous: oldSchema,
+          next: newIndex,
+          diff: this.schemaDiffer.computeDiff(oldSchema, newSchema)
+        };
+        for (const code of CROSS_VERSION_CODES) {
+          const { severity, fixable } = CROSS_VERSION_CHECKS[code];
+          const reported = severity === "error" ? result.errors : result.warnings;
+          for (const { message, path: path25, suggestion } of this.crossVersionFinders[code](comparison)) {
+            reported.push(this.createError(code, message, path25, severity, suggestion, fixable));
+          }
+        }
         return result;
       }
       /**
-       * Flags reference fields that still target a content/asset type removed in
+       * Reference fields that still target a content/asset type removed in
        * this change. `DataIntegrityValidator` already errors on a dangling target
        * (REFERENCE_TARGET_NOT_FOUND) when it validates the new schema in isolation;
        * this diff-aware pass upgrades the same situation to an attributed breaking
@@ -8676,99 +8416,81 @@ var init_dist2 = __esm({
        * Reference fields inside asset types are covered too — {@link BaseValidator.traverseFields}
        * walks asset type fields by default.
        */
-      validateReferenceTargetRemovals(oldSchema, newIndex, result) {
-        const diff2 = this.schemaDiffer.computeDiff(oldSchema, newIndex.schema);
+      removedReferenceTargets({ next, diff: diff2 }) {
         const removedTargets = /* @__PURE__ */ new Map();
         for (const id of diff2.removed.contentTypes) removedTargets.set(id, "content");
         for (const id of diff2.removed.singletonContentTypes) removedTargets.set(id, "content");
         for (const id of diff2.removed.assetTypes) removedTargets.set(id, "asset");
-        if (removedTargets.size === 0) return;
-        this.traverseFields(newIndex, (field, path25) => {
+        const findings = [];
+        if (removedTargets.size === 0) return findings;
+        this.traverseFields(next, (field, path25) => {
           if (field.type !== "reference") return;
           const targets = normalizeReferenceTargets(field.config?.to);
           for (const [index, targetId] of targets.entries()) {
             const family = removedTargets.get(targetId);
             if (!family) continue;
-            result.errors.push(
-              this.createError(
-                "REFERENCE_TARGET_REMOVED",
-                `Reference field '${field.id}' targets ${family} type '${targetId}', which was removed in this change`,
-                `${path25}.config.to[${index}]`,
-                "error",
-                `Restore the ${family} type '${targetId}', or remove/repoint the reference field '${field.id}' before deploying`,
-                false
-              )
-            );
+            findings.push({
+              message: `Reference field '${field.id}' targets ${family} type '${targetId}', which was removed in this change`,
+              path: `${path25}.config.to[${index}]`,
+              suggestion: `Restore the ${family} type '${targetId}', or remove/repoint the reference field '${field.id}' before deploying`
+            });
           }
         });
+        return findings;
       }
       /**
-       * Enforces the field type immutability rule
+       * The field type immutability rule: a field keeps the type it was deployed with.
        */
-      validateFieldTypeImmutability(oldSchema, newSchema, result) {
-        const oldFieldTypes = this.buildFieldTypeHistory(oldSchema);
-        const newFieldTypes = this.buildFieldTypeHistory(newSchema);
+      fieldTypeChanges({ previous, next }) {
+        const oldFieldTypes = this.buildFieldTypeHistory(previous);
+        const newFieldTypes = this.buildFieldTypeHistory(next.schema);
+        const findings = [];
         for (const [fieldKey, oldField] of oldFieldTypes.entries()) {
           const newField = newFieldTypes.get(fieldKey);
           if (newField && oldField.fieldType !== newField.fieldType) {
             const oldType = this.normalizeFieldType(oldField.fieldType);
             const newType = this.normalizeFieldType(newField.fieldType);
-            result.errors.push(
-              this.createError(
-                "FIELD_TYPE_CHANGE_FORBIDDEN",
-                `Field type cannot be changed after deployment: "${oldField.fieldId}" (${oldType} \u2192 ${newType})`,
-                newField.path,
-                "error",
-                `Use deprecation workflow:
+            findings.push({
+              message: `Field type cannot be changed after deployment: "${oldField.fieldId}" (${oldType} \u2192 ${newType})`,
+              path: newField.path,
+              suggestion: `Use deprecation workflow:
 \u250C\u2500 Correct approach
 \u2502  fields:
 \u2502    \u251C\u2500 ${oldField.fieldId}:
 \u2502    \u2502    type: "${oldField.fieldType}"
 \u2502    \u2502    deprecated: true  # Mark old field as deprecated
 \u2502    \u2514\u2500 ${oldField.fieldId}_v2:
-\u2502         type: "${newField.fieldType}"  # Create new field with correct type`,
-                false
-              )
-            );
+\u2502         type: "${newField.fieldType}"  # Create new field with correct type`
+            });
           }
         }
+        return findings;
       }
       /**
-       * Validates proper deprecation workflow when introducing new fields
+       * A field added beside one it appears to replace, which is not marked deprecated.
        */
-      validateDeprecationWorkflow(oldSchema, newSchema, result) {
-        const diff2 = this.schemaDiffer.computeDiff(oldSchema, newSchema);
+      undeprecatedReplacements({ previous, next, diff: diff2 }) {
+        const findings = [];
         for (const contentTypeChange of diff2.modified.contentTypes) {
           for (const addedFieldId of contentTypeChange.changes.addedFields) {
             const potentialOriginalField = this.findPotentialOriginalField(
               addedFieldId,
-              oldSchema,
+              previous,
               contentTypeChange.name
             );
-            if (potentialOriginalField) {
-              const isOriginalDeprecated = this.isFieldDeprecated(
-                potentialOriginalField,
-                newSchema,
-                contentTypeChange.name
-              );
-              if (!isOriginalDeprecated) {
-                result.warnings.push(
-                  this.createError(
-                    "MISSING_DEPRECATION_MARKER",
-                    `Field '${addedFieldId}' appears to be a replacement for '${potentialOriginalField}'. Consider marking the original field as deprecated.`,
-                    `contentTypes.${contentTypeChange.name}.fields.${potentialOriginalField}`,
-                    "warning",
-                    `Mark the original field as deprecated:
+            if (potentialOriginalField && !this.isFieldDeprecated(potentialOriginalField, next.schema, contentTypeChange.name)) {
+              findings.push({
+                message: `Field '${addedFieldId}' appears to be a replacement for '${potentialOriginalField}'. Consider marking the original field as deprecated.`,
+                path: `contentTypes.${contentTypeChange.name}.fields.${potentialOriginalField}`,
+                suggestion: `Mark the original field as deprecated:
 - id: "${potentialOriginalField}"
   type: "..."
-  deprecated: true`,
-                    true
-                  )
-                );
-              }
+  deprecated: true`
+              });
             }
           }
         }
+        return findings;
       }
       /**
        * Builds a map of field types from a schema for comparison
@@ -9013,9 +8735,7 @@ var init_dist2 = __esm({
         const safeChanges = [];
         const evolutionResult = await this.validateSchemaEvolution(oldSchema, newSchema);
         for (const error2 of evolutionResult.errors) {
-          if (error2.code === "FIELD_TYPE_CHANGE_FORBIDDEN" || error2.code === "REFERENCE_TARGET_REMOVED") {
-            breakingChanges.push(error2.message);
-          }
+          if (isCrossVersionCheckCode(error2.code)) breakingChanges.push(error2.message);
         }
         const diff2 = this.schemaDiffer.computeDiff(oldSchema, newSchema);
         const compatibility = classifyCompatibility(diff2);
@@ -9226,19 +8946,6 @@ var init_dist2 = __esm({
         return fieldIds;
       }
       validateFieldRules(rules, fieldId, fieldPath, result, allFieldIds, _context) {
-        if (!Array.isArray(rules)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_RULES_FORMAT",
-              "Field rules must be an array",
-              `${fieldPath}.rules`,
-              "error",
-              "Change rules to an array format: rules: [...]",
-              true
-            )
-          );
-          return;
-        }
         const ruleTypes = /* @__PURE__ */ new Set();
         for (const [ruleIndex, rule] of rules.entries()) {
           const rulePath = `${fieldPath}.rules[${ruleIndex}]`;
@@ -9261,86 +8968,16 @@ var init_dist2 = __esm({
         this.checkCircularDependencies(rules, fieldId, fieldPath, result, allFieldIds);
         this.validateRuleLogicConsistency(rules, fieldId, fieldPath, result);
       }
+      /**
+       * A rule's shape — its type, its action, its message, a mode, a non-empty list of conditions and
+       * each condition's operator — is the parse's (`FieldRuleSchema`), which refuses every one this
+       * checked; none of those eleven checks could fire (REL-1497, `parse-refuses-first.test.ts`). What
+       * is left is what the parse cannot know: which fields a condition names, and whether its operator
+       * has the value it compares with.
+       */
       validateSingleRule(rule, rulePath, result, allFieldIds, currentFieldId) {
-        const validRuleTypes = ["visibility", "requirement", "validation", "readOnly"];
-        if (!validRuleTypes.includes(rule.type)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_RULE_TYPE",
-              `Invalid rule type '${rule.type}'. Must be one of: ${validRuleTypes.join(", ")}`,
-              `${rulePath}.type`,
-              "error",
-              `Use one of the valid rule types: ${validRuleTypes.join(", ")}`,
-              true
-            )
-          );
-        }
-        const hasConditions = rule.conditions && rule.conditions.conditions && rule.conditions.conditions.length > 0;
-        if (!hasConditions) {
-          result.errors.push(
-            this.createError(
-              "MISSING_RULE_CONDITION",
-              "Rule must specify conditions with at least one condition entry",
-              rulePath,
-              "error",
-              "Add a conditions object to define when the rule applies",
-              true
-            )
-          );
-        }
-        if (hasConditions) {
-          this.validateConditions(
-            rule.conditions,
-            `${rulePath}.conditions`,
-            result,
-            allFieldIds,
-            currentFieldId
-          );
-        }
-        this.validateRuleSpecificProperties(rule, rulePath, result);
-      }
-      validateConditions(conditions, conditionsPath, result, allFieldIds, currentFieldId) {
-        if (!conditions) return;
-        const validModes = ["all", "any", "none"];
-        if (!validModes.includes(conditions.mode)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_CONDITIONS_MODE",
-              `Invalid conditions mode '${conditions.mode}'. Must be one of: ${validModes.join(", ")}`,
-              `${conditionsPath}.mode`,
-              "error",
-              `Use one of: ${validModes.join(", ")}`,
-              true
-            )
-          );
-        }
-        if (!conditions.conditions || !Array.isArray(conditions.conditions)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_CONDITIONS_ARRAY",
-              "Conditions must include a 'conditions' array",
-              `${conditionsPath}.conditions`,
-              "error",
-              "Add a conditions array with at least one condition",
-              true
-            )
-          );
-          return;
-        }
-        if (conditions.conditions.length === 0) {
-          result.errors.push(
-            this.createError(
-              "EMPTY_CONDITIONS_ARRAY",
-              "Conditions array cannot be empty",
-              `${conditionsPath}.conditions`,
-              "error",
-              "Add at least one condition to the array",
-              true
-            )
-          );
-          return;
-        }
-        for (const [index, condition] of conditions.conditions.entries()) {
+        const conditionsPath = `${rulePath}.conditions`;
+        for (const [index, condition] of rule.conditions.conditions.entries()) {
           this.validateSingleCondition(
             condition,
             `${conditionsPath}.conditions[${index}]`,
@@ -9387,28 +9024,6 @@ var init_dist2 = __esm({
             )
           );
         }
-        const validOperators = [
-          "equals",
-          "not_equals",
-          "contains",
-          "not_contains",
-          "greater_than",
-          "less_than",
-          "is_empty",
-          "is_not_empty"
-        ];
-        if (!validOperators.includes(condition.operator)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_CONDITION_OPERATOR",
-              `Invalid operator '${condition.operator}'. Must be one of: ${validOperators.join(", ")}`,
-              `${conditionPath}.operator`,
-              "error",
-              `Use one of: ${validOperators.join(", ")}`,
-              true
-            )
-          );
-        }
         const operatorsRequiringValue = [
           "equals",
           "not_equals",
@@ -9444,70 +9059,6 @@ var init_dist2 = __esm({
           );
         }
       }
-      validateRuleSpecificProperties(rule, rulePath, result) {
-        switch (rule.type) {
-          case "visibility": {
-            if ("action" in rule && rule.action && !["show", "hide"].includes(rule.action)) {
-              result.errors.push(
-                this.createError(
-                  "INVALID_VISIBILITY_ACTION",
-                  `Invalid visibility action '${rule.action}'. Must be 'show' or 'hide'`,
-                  `${rulePath}.action`,
-                  "error",
-                  "Use 'show' or 'hide'",
-                  true
-                )
-              );
-            }
-            break;
-          }
-          case "requirement": {
-            if ("action" in rule && rule.action && !["require", "optional"].includes(rule.action)) {
-              result.errors.push(
-                this.createError(
-                  "INVALID_REQUIREMENT_ACTION",
-                  `Invalid requirement action '${rule.action}'. Must be 'require' or 'optional'`,
-                  `${rulePath}.action`,
-                  "error",
-                  "Use 'require' or 'optional'",
-                  true
-                )
-              );
-            }
-            break;
-          }
-          case "validation": {
-            if ("message" in rule && rule.message && typeof rule.message !== "string") {
-              result.errors.push(
-                this.createError(
-                  "INVALID_VALIDATION_MESSAGE",
-                  "Validation message must be a string",
-                  `${rulePath}.message`,
-                  "error",
-                  "Provide a string message for validation errors",
-                  true
-                )
-              );
-            }
-            break;
-          }
-          case "readOnly": {
-            if ("action" in rule && rule.action && !["enable", "disable"].includes(rule.action)) {
-              result.errors.push(
-                this.createError(
-                  "INVALID_READONLY_ACTION",
-                  `Invalid readOnly action '${rule.action}'. Must be 'enable' or 'disable'`,
-                  `${rulePath}.action`,
-                  "error",
-                  "Use 'enable' or 'disable'",
-                  true
-                )
-              );
-            }
-            break;
-          }
-        }
-      }
       checkCircularDependencies(rules, _fieldId, _fieldPath, _result, _allFieldIds) {
         const referencedFields = /* @__PURE__ */ new Set();
         for (const rule of rules) {
@@ -9582,6 +9133,15 @@ var init_dist2 = __esm({
         });
         return fieldIds;
       }
+      /**
+       * A declared `localization`, in the one of its three forms the parse admits
+       * (`LocalizationConfigSchema`): a boolean, a list of locale codes, or `{ enabled, requiredLocales? }`
+       * with `enabled` a boolean and `requiredLocales` a list. This refused any other form
+       * (`INVALID_LOCALIZATION_FORMAT`), an `enabled` that is not a boolean
+       * (`INVALID_LOCALIZATION_ENABLED`) and a `requiredLocales` that is not a list
+       * (`INVALID_REQUIRED_LOCALES`) — the parse refuses all three first, so none could fire (REL-1497,
+       * `parse-refuses-first.test.ts`).
+       */
       validateFieldLocalization(field, fieldPath, result, _allFieldIds, _context) {
         const localization = field.localization;
         const localizationPath = `${fieldPath}.localization`;
@@ -9589,24 +9149,8 @@ var init_dist2 = __esm({
           this.validateBooleanLocalization(localization, localizationPath, result, field);
         } else if (Array.isArray(localization)) {
           this.validateArrayLocalization(localization, localizationPath, result, field);
-        } else if (typeof localization === "object" && localization !== null) {
-          this.validateObjectLocalization(
-            localization,
-            localizationPath,
-            result,
-            field
-          );
-        } else {
-          result.errors.push(
-            this.createError(
-              "INVALID_LOCALIZATION_FORMAT",
-              "Localization must be a boolean, string array, or configuration object",
-              localizationPath,
-              "error",
-              "Use true/false, array of locale codes, or { enabled: boolean, ... } object",
-              true
-            )
-          );
+        } else if (localization !== void 0) {
+          this.validateRequiredLocales(localization.requiredLocales, localizationPath, result);
         }
       }
       validateBooleanLocalization(enabled, localizationPath, result, field) {
@@ -9664,36 +9208,10 @@ var init_dist2 = __esm({
           );
         }
       }
-      validateObjectLocalization(config, localizationPath, result, _field) {
-        if (config.enabled !== void 0 && typeof config.enabled !== "boolean") {
-          result.errors.push(
-            this.createError(
-              "INVALID_LOCALIZATION_ENABLED",
-              "Localization 'enabled' property must be a boolean",
-              `${localizationPath}.enabled`,
-              "error",
-              "Use true or false",
-              true
-            )
-          );
-        }
-        if (config.requiredLocales) {
-          if (Array.isArray(config.requiredLocales)) {
-            for (const [index, locale] of config.requiredLocales.entries()) {
-              this.validateLocaleCode(locale, `${localizationPath}.requiredLocales[${index}]`, result);
-            }
-          } else {
-            result.errors.push(
-              this.createError(
-                "INVALID_REQUIRED_LOCALES",
-                "Required locales must be an array of locale codes",
-                `${localizationPath}.requiredLocales`,
-                "error",
-                "Use array format: ['en-US', 'fr-FR']",
-                true
-              )
-            );
-          }
+      validateRequiredLocales(requiredLocales, localizationPath, result) {
+        if (requiredLocales === void 0) return;
+        for (const [index, locale] of requiredLocales.entries()) {
+          this.validateLocaleCode(locale, `${localizationPath}.requiredLocales[${index}]`, result);
         }
       }
       validateFieldFallback(field, fieldPath, result, allFieldIds, _context) {
@@ -10080,93 +9598,13 @@ var init_dist2 = __esm({
         });
       }
       /**
-       * Validate locale configuration for consistency and best practices
+       * The locale list's shape — exactly one default, unique codes, fallbacks to declared locales,
+       * none to itself and no cycle — is the parse's (`LocalesArraySchema`), which refuses each first,
+       * so the six checks this made of it could not fire (REL-1497, `parse-refuses-first.test.ts`).
+       * What is left is advice the parse does not give.
        */
       validateLocaleConfiguration(locales, result) {
-        const defaultLocales = locales.filter((l) => l.default === true);
-        if (defaultLocales.length === 0) {
-          result.errors.push(
-            this.createError(
-              "NO_DEFAULT_LOCALE",
-              "No default locale defined. Exactly one locale must be marked as default.",
-              "locales",
-              "error",
-              "Add 'default: true' to one of your locale definitions",
-              true
-            )
-          );
-        } else if (defaultLocales.length > 1) {
-          result.errors.push(
-            this.createError(
-              "MULTIPLE_DEFAULT_LOCALES",
-              `Multiple default locales defined: ${defaultLocales.map((l) => l.code).join(", ")}`,
-              "locales",
-              "error",
-              "Only one locale can be the default",
-              true
-            )
-          );
-        }
-        const seenCodes = /* @__PURE__ */ new Set();
-        for (const [index, locale] of locales.entries()) {
-          if (seenCodes.has(locale.code)) {
-            result.errors.push(
-              this.createError(
-                "DUPLICATE_LOCALE_CODE",
-                `Duplicate locale code '${locale.code}'`,
-                `locales[${index}]`,
-                "error",
-                "Each locale must have a unique code",
-                true
-              )
-            );
-          }
-          seenCodes.add(locale.code);
-        }
-        const localeCodes = new Set(locales.map((l) => l.code));
-        for (const [index, locale] of locales.entries()) {
-          if (!locale.fallback) continue;
-          for (const [fallbackIndex, fallbackCode] of locale.fallback.entries()) {
-            if (!localeCodes.has(fallbackCode)) {
-              result.errors.push(
-                this.createError(
-                  "INVALID_LOCALE_FALLBACK",
-                  `Locale '${locale.code}' has fallback to non-existent locale '${fallbackCode}'`,
-                  `locales[${index}].fallback[${fallbackIndex}]`,
-                  "error",
-                  `Reference an existing locale: ${[...localeCodes].join(", ")}`,
-                  true
-                )
-              );
-            }
-            if (fallbackCode === locale.code) {
-              result.errors.push(
-                this.createError(
-                  "SELF_REFERENCING_LOCALE_FALLBACK",
-                  `Locale '${locale.code}' references itself in fallback chain`,
-                  `locales[${index}].fallback[${fallbackIndex}]`,
-                  "error",
-                  "Remove self-reference from fallback chain",
-                  true
-                )
-              );
-            }
-          }
-          const circularPath = this.detectCircularFallback(locale.code, locales);
-          if (circularPath) {
-            result.errors.push(
-              this.createError(
-                "CIRCULAR_LOCALE_FALLBACK",
-                `Circular fallback chain detected: ${circularPath.join(" \u2192 ")}`,
-                `locales[${index}].fallback`,
-                "error",
-                "Remove circular references in fallback chain",
-                true
-              )
-            );
-          }
-        }
-        const defaultLocale = defaultLocales[0];
+        const defaultLocale = locales.find((l) => l.default === true);
         if (defaultLocale?.fallback && defaultLocale.fallback.length > 0) {
           result.warnings.push(
             this.createError(
@@ -10224,34 +9662,6 @@ var init_dist2 = __esm({
           }
         });
       }
-      /**
-       * Detects circular fallback chains starting from a given locale
-       */
-      detectCircularFallback(startCode, locales) {
-        const visited = /* @__PURE__ */ new Set();
-        const path25 = [];
-        const localeMap = new Map(locales.map((l) => [l.code, l]));
-        const visit = (code) => {
-          if (visited.has(code)) {
-            const cycleStart = path25.indexOf(code);
-            return [...path25.slice(cycleStart), code];
-          }
-          const locale = localeMap.get(code);
-          if (!locale?.fallback || locale.fallback.length === 0) {
-            return null;
-          }
-          visited.add(code);
-          path25.push(code);
-          for (const fallbackCode of locale.fallback) {
-            const cycle = visit(fallbackCode);
-            if (cycle) return cycle;
-          }
-          path25.pop();
-          visited.delete(code);
-          return null;
-        };
-        return visit(startCode);
-      }
     };
     SettingsGroupsValidator = class extends BaseValidator {
       feature = "settingsGroups";
@@ -10328,53 +9738,27 @@ var init_dist2 = __esm({
             )
           );
         }
-        if (!settingsGroup.displayName || typeof settingsGroup.displayName !== "string") {
-          result.errors.push(
+        if (settingsGroup.displayName.length < 3) {
+          result.warnings.push(
             this.createError(
-              "MISSING_SETTINGS_GROUP_DISPLAY_NAME",
-              `Settings group '${groupId}' must have a displayName`,
+              "SHORT_SETTINGS_GROUP_DISPLAY_NAME",
+              `Settings group '${groupId}' has a very short displayName`,
               `${groupPath}.displayName`,
-              "error",
-              "Add a descriptive displayName property",
-              true
+              "warning",
+              "Use a more descriptive displayName (at least 3 characters)"
             )
           );
-        } else {
-          if (settingsGroup.displayName.length < 3) {
-            result.warnings.push(
-              this.createError(
-                "SHORT_SETTINGS_GROUP_DISPLAY_NAME",
-                `Settings group '${groupId}' has a very short displayName`,
-                `${groupPath}.displayName`,
-                "warning",
-                "Use a more descriptive displayName (at least 3 characters)"
-              )
-            );
-          }
         }
         if (settingsGroup.description) {
-          if (typeof settingsGroup.description === "string") {
-            stats.groupsWithDescriptions++;
-            if (settingsGroup.description.length < 10) {
-              result.warnings.push(
-                this.createError(
-                  "SHORT_SETTINGS_GROUP_DESCRIPTION",
-                  `Settings group '${groupId}' has a very short description`,
-                  `${groupPath}.description`,
-                  "warning",
-                  "Provide a more detailed description for better understanding"
-                )
-              );
-            }
-          } else {
-            result.errors.push(
+          stats.groupsWithDescriptions++;
+          if (settingsGroup.description.length < 10) {
+            result.warnings.push(
               this.createError(
-                "INVALID_SETTINGS_GROUP_DESCRIPTION",
-                `Settings group '${groupId}' description must be a string`,
+                "SHORT_SETTINGS_GROUP_DESCRIPTION",
+                `Settings group '${groupId}' has a very short description`,
                 `${groupPath}.description`,
-                "error",
-                "Use a string description",
-                true
+                "warning",
+                "Provide a more detailed description for better understanding"
               )
             );
           }
@@ -10389,47 +9773,13 @@ var init_dist2 = __esm({
             )
           );
         }
-        if (!settingsGroup.fields || !Array.isArray(settingsGroup.fields)) {
-          result.errors.push(
-            this.createError(
-              "MISSING_SETTINGS_FIELDS_ARRAY",
-              `Settings group '${groupId}' must have a fields array`,
-              `${groupPath}.fields`,
-              "error",
-              "Add a fields array with field configurations",
-              true
-            )
-          );
-        } else if (settingsGroup.fields.length === 0) {
-          result.warnings.push(
-            this.createError(
-              "EMPTY_SETTINGS_GROUP_FIELDS",
-              `Settings group '${groupId}' has no fields`,
-              `${groupPath}.fields`,
-              "warning",
-              "Add fields or remove this empty group"
-            )
-          );
-        }
       }
       validateSettingsGroupFields(groupId, settingsGroup, result, allFieldIds, stats) {
         const groupPath = `settingsGroups.${groupId}`;
-        if (!Array.isArray(settingsGroup.fields)) {
-          return;
-        }
         stats.totalFields += settingsGroup.fields.length;
-        const groupFieldIds = /* @__PURE__ */ new Set();
         for (const [index, field] of settingsGroup.fields.entries()) {
           const fieldPath = `${groupPath}.fields[${index}]`;
-          this.validateSettingsField(
-            field,
-            fieldPath,
-            result,
-            groupFieldIds,
-            allFieldIds,
-            groupId,
-            stats
-          );
+          this.validateSettingsField(field, fieldPath, result, allFieldIds, groupId, stats);
         }
         if (settingsGroup.fields.length > 15) {
           result.warnings.push(
@@ -10443,57 +9793,21 @@ var init_dist2 = __esm({
           );
         }
         if (settingsGroup.fields.length >= 8 && settingsGroup.fields.length <= 15) {
-          result.info.push(
-            this.createError(
-              "CONSIDER_SUBGROUPING",
-              `Settings group '${groupId}' with ${settingsGroup.fields.length} fields might benefit from logical subgrouping`,
-              `${groupPath}`,
-              "info",
-              "Consider organizing related fields together or using field prefixes for clarity"
-            )
-          );
-        }
-      }
-      validateSettingsField(field, fieldPath, result, groupFieldIds, allFieldIds, groupId, stats) {
-        if (!field.id || typeof field.id !== "string") {
-          result.errors.push(
-            this.createError(
-              "MISSING_FIELD_ID",
-              "Field must have an id property",
-              `${fieldPath}.id`,
-              "error",
-              "Add a unique string id for this field",
-              true
-            )
-          );
-          return;
-        }
-        if (groupFieldIds.has(field.id)) {
-          result.errors.push(
-            this.createError(
-              "DUPLICATE_FIELD_ID",
-              `Duplicate field ID '${field.id}' in settings group '${groupId}'`,
-              `${fieldPath}.id`,
-              "error",
-              "Use unique field IDs within each settings group",
-              true
-            )
-          );
-        } else {
-          groupFieldIds.add(field.id);
-        }
-        if (!ValidationUtils.isValidName(field.id)) {
-          result.warnings.push(
+          result.info.push(
             this.createError(
-              "INVALID_FIELD_ID_FORMAT",
-              `Field ID '${field.id}' should follow naming conventions`,
-              `${fieldPath}.id`,
-              "warning",
-              "Use camelCase or snake_case for field IDs"
+              "CONSIDER_SUBGROUPING",
+              `Settings group '${groupId}' with ${settingsGroup.fields.length} fields might benefit from logical subgrouping`,
+              `${groupPath}`,
+              "info",
+              "Consider organizing related fields together or using field prefixes for clarity"
             )
           );
         }
-        if (!field.type || typeof field.type !== "string") {
+      }
+      validateSettingsField(field, fieldPath, result, allFieldIds, groupId, stats) {
+        if (field.type) {
+          this.validateFieldTypeForSettings(field, fieldPath, result);
+        } else {
           result.errors.push(
             this.createError(
               "MISSING_FIELD_TYPE",
@@ -10504,8 +9818,6 @@ var init_dist2 = __esm({
               true
             )
           );
-        } else {
-          this.validateFieldTypeForSettings(field, fieldPath, result);
         }
         if (field.localization !== void 0) {
           this.validateSettingsFieldLocalization(field, fieldPath, result);
@@ -10768,7 +10080,7 @@ var init_dist2 = __esm({
           singletonsWithSlugFields: 0,
           singletonsWithUniqueFields: 0
         };
-        if (!index.schema.singletonContentTypes || index.singletonContentTypes.ids.length === 0) {
+        if (index.singletonContentTypes.ids.length === 0) {
           result.info.push(
             this.createError(
               "NO_SINGLETON_CONTENT_TYPES",
@@ -10807,18 +10119,6 @@ var init_dist2 = __esm({
       }
       validateSingletonStructure(singletonId, singletonType, result, stats) {
         const singletonPath = `singletonContentTypes.${singletonId}`;
-        if (!ValidationUtils.isValidName(singletonId)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_SINGLETON_ID",
-              `Singleton content type ID '${singletonId}' is invalid`,
-              singletonPath,
-              "error",
-              "Use camelCase or snake_case starting with a letter",
-              true
-            )
-          );
-        }
         const reservedKeywords = ValidationUtils.getReservedKeywords();
         if (reservedKeywords.includes(singletonId.toLowerCase())) {
           result.errors.push(
@@ -10832,18 +10132,7 @@ var init_dist2 = __esm({
             )
           );
         }
-        if (!singletonType.displayName || typeof singletonType.displayName !== "string") {
-          result.errors.push(
-            this.createError(
-              "MISSING_SINGLETON_DISPLAY_NAME",
-              `Singleton content type '${singletonId}' must have a displayName`,
-              `${singletonPath}.displayName`,
-              "error",
-              "Add a descriptive displayName property",
-              true
-            )
-          );
-        } else {
+        if (singletonType.displayName) {
           if (singletonType.displayName.length < 3) {
             result.warnings.push(
               this.createError(
@@ -10855,30 +10144,28 @@ var init_dist2 = __esm({
               )
             );
           }
+        } else {
+          result.errors.push(
+            this.createError(
+              "MISSING_SINGLETON_DISPLAY_NAME",
+              `Singleton content type '${singletonId}' must have a displayName`,
+              `${singletonPath}.displayName`,
+              "error",
+              "Add a descriptive displayName property",
+              true
+            )
+          );
         }
         if (singletonType.description) {
-          if (typeof singletonType.description === "string") {
-            stats.singletonsWithDescriptions++;
-            if (singletonType.description.length < 10) {
-              result.warnings.push(
-                this.createError(
-                  "SHORT_SINGLETON_DESCRIPTION",
-                  `Singleton content type '${singletonId}' has a very short description`,
-                  `${singletonPath}.description`,
-                  "warning",
-                  "Provide a more detailed description for better understanding"
-                )
-              );
-            }
-          } else {
-            result.errors.push(
+          stats.singletonsWithDescriptions++;
+          if (singletonType.description.length < 10) {
+            result.warnings.push(
               this.createError(
-                "INVALID_SINGLETON_DESCRIPTION",
-                `Singleton content type '${singletonId}' description must be a string`,
+                "SHORT_SINGLETON_DESCRIPTION",
+                `Singleton content type '${singletonId}' has a very short description`,
                 `${singletonPath}.description`,
-                "error",
-                "Use a string description",
-                true
+                "warning",
+                "Provide a more detailed description for better understanding"
               )
             );
           }
@@ -10906,21 +10193,7 @@ var init_dist2 = __esm({
           );
           stats.singletonsWithHierarchical++;
         }
-        const hasDirectFields = singletonType.fields && Array.isArray(singletonType.fields) && singletonType.fields.length > 0;
-        const hasFieldsets = singletonType.fieldsets && Array.isArray(singletonType.fieldsets) && singletonType.fieldsets.length > 0;
-        if (!hasDirectFields && !hasFieldsets) {
-          result.errors.push(
-            this.createError(
-              "SINGLETON_NO_FIELDS",
-              `Singleton content type '${singletonId}' has no fields or fieldsets`,
-              `${singletonPath}.fields`,
-              "error",
-              "Add fields or fieldsets to define the singleton's structure",
-              true
-            )
-          );
-        }
-        if (hasFieldsets) {
+        if (singletonType.fieldsets && singletonType.fieldsets.length > 0) {
           stats.singletonsWithFieldsets++;
         }
       }
@@ -10928,26 +10201,9 @@ var init_dist2 = __esm({
         const singletonPath = `singletonContentTypes.${singletonId}`;
         const allFields = this.getAllFieldsFromSingleton(singletonType);
         stats.totalFields += allFields.length;
-        const fieldIds = /* @__PURE__ */ new Set();
         let hasLocalizationEnabled = false;
         for (const [index, field] of allFields.entries()) {
           const fieldPath = this.getFieldPath(singletonPath, field, index, singletonType);
-          if (field.id) {
-            if (fieldIds.has(field.id)) {
-              result.errors.push(
-                this.createError(
-                  "DUPLICATE_SINGLETON_FIELD_ID",
-                  `Duplicate field ID '${field.id}' in singleton '${singletonId}'`,
-                  fieldPath,
-                  "error",
-                  "Use unique field IDs within each singleton",
-                  true
-                )
-              );
-            } else {
-              fieldIds.add(field.id);
-            }
-          }
           this.validateSingletonFieldType(field, fieldPath, result, stats, singletonId);
           if (isFieldLocalized(field)) {
             hasLocalizationEnabled = true;
@@ -10993,20 +10249,6 @@ var init_dist2 = __esm({
           );
           stats.singletonsWithSlugFields++;
         }
-        if (field.type === "reference") {
-          const config = field.config || {};
-          if (config.maxItems && config.maxItems > 10) {
-            result.info.push(
-              this.createError(
-                "LARGE_REFERENCE_LIST_IN_SINGLETON",
-                `Singleton field '${field.id}' allows ${config.maxItems} references`,
-                fieldPath,
-                "info",
-                "Consider if a large reference list is appropriate for singleton content, or if this should be a regular content type"
-              )
-            );
-          }
-        }
         const problematicFieldNames = ["title", "name", "identifier", "key", "index"];
         if (field.id && problematicFieldNames.some((name) => field.id.toLowerCase().includes(name))) {
           result.info.push(
@@ -11317,18 +10559,6 @@ var init_dist2 = __esm({
       }
       validateStructure(assetTypeId, assetType, result) {
         const path25 = `assetTypes.${assetTypeId}`;
-        if (!ValidationUtils.isValidName(assetTypeId)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_ASSET_TYPE_ID",
-              `Asset type ID '${assetTypeId}' is invalid`,
-              path25,
-              "error",
-              "Use camelCase or snake_case starting with a letter",
-              true
-            )
-          );
-        }
         if (ValidationUtils.getReservedKeywords().includes(assetTypeId.toLowerCase())) {
           result.errors.push(
             this.createError(
@@ -11341,7 +10571,7 @@ var init_dist2 = __esm({
             )
           );
         }
-        if (!assetType.displayName || typeof assetType.displayName !== "string") {
+        if (!assetType.displayName) {
           result.errors.push(
             this.createError(
               "MISSING_ASSET_TYPE_DISPLAY_NAME",
@@ -11353,48 +10583,12 @@ var init_dist2 = __esm({
             )
           );
         }
-        if (assetType.displayField) {
-          const exists = this.getAllFields(assetType).some((f) => f.id === assetType.displayField);
-          if (!exists) {
-            result.errors.push(
-              this.createError(
-                "INVALID_ASSET_TYPE_DISPLAY_FIELD",
-                `Asset type '${assetTypeId}' displayField '${assetType.displayField}' does not exist`,
-                `${path25}.displayField`,
-                "error",
-                "Reference an existing field id",
-                true
-              )
-            );
-          }
-        }
       }
       validateFields(assetTypeId, assetType, result, componentIds) {
         const path25 = `assetTypes.${assetTypeId}`;
         const fields = this.getAllFields(assetType);
-        const fieldIds = /* @__PURE__ */ new Set();
         for (const field of fields) {
-          const fieldPath = `${path25}.fields.${field.id || "[unknown]"}`;
-          if (!field.id) {
-            result.errors.push(
-              this.createError("MISSING_FIELD_ID", "Field must have an id", `${fieldPath}.id`, "error")
-            );
-            continue;
-          }
-          if (fieldIds.has(field.id)) {
-            result.errors.push(
-              this.createError(
-                "DUPLICATE_ASSET_TYPE_FIELD_ID",
-                `Duplicate field ID '${field.id}' in asset type '${assetTypeId}'`,
-                `${fieldPath}.id`,
-                "error",
-                "Use unique field IDs within each asset type",
-                true
-              )
-            );
-          } else {
-            fieldIds.add(field.id);
-          }
+          const fieldPath = `${path25}.fields.${field.id}`;
           if (field.type && FORBIDDEN_TYPES.has(field.type)) {
             result.errors.push(
               this.createError(
@@ -11454,33 +10648,6 @@ var init_dist2 = __esm({
       }
       validateKind(assetTypeId, assetType, result, schemaLocales, stats) {
         const path25 = `assetTypes.${assetTypeId}`;
-        const presentKinds = ASSET_KINDS.filter((k) => assetType[k] !== void 0);
-        if (presentKinds.length === 0) {
-          result.errors.push(
-            this.createError(
-              "MISSING_ASSET_KIND",
-              `Asset type '${assetTypeId}' must declare exactly one kind key (image, video, or file)`,
-              path25,
-              "error",
-              "Add one of image, video, or file",
-              true
-            )
-          );
-          return;
-        }
-        if (presentKinds.length > 1) {
-          result.errors.push(
-            this.createError(
-              "MULTIPLE_ASSET_KINDS",
-              `Asset type '${assetTypeId}' declares multiple kind keys (${presentKinds.join(", ")}). Use exactly one.`,
-              path25,
-              "error",
-              "Keep only one of image, video, or file",
-              true
-            )
-          );
-          return;
-        }
         const resolved = resolveAssetType(assetType);
         if (!resolved) return;
         const kind = resolved.kind;
@@ -11636,20 +10803,7 @@ var init_dist2 = __esm({
       validateTransformLimits(path25, transform, result) {
         const width = transform.width;
         const height = transform.height;
-        let format2 = transform.format;
-        if (format2 === "heic") {
-          result.errors.push(
-            this.createError(
-              "INVALID_OUTPUT_FORMAT_HEIC",
-              `Output format 'heic' is not supported; HEIC is a decodable input only. Use avif/webp/jpeg/png.`,
-              `${path25}.format`,
-              "error",
-              "Choose a web-safe output format",
-              true
-            )
-          );
-          format2 = void 0;
-        }
+        const format2 = transform.format;
         const maxDim = format2 === "avif" ? CF_IMAGES_LIMITS.maxDimensionAvifPx : CF_IMAGES_LIMITS.maxDimensionPx;
         if (width && width > maxDim) {
           result.errors.push(
@@ -11689,24 +10843,8 @@ var init_dist2 = __esm({
         }
       }
       validateVideoKind(assetTypeId, kindPath, kindConfig, schemaLocales, result) {
-        const poster = kindConfig.poster;
         const captions = kindConfig.captions;
         const watermark = kindConfig.watermark;
-        if (poster && typeof poster.defaultTimestampPct === "number") {
-          const pct = poster.defaultTimestampPct;
-          if (pct < 0 || pct > 1) {
-            result.errors.push(
-              this.createError(
-                "INVALID_POSTER_TIMESTAMP",
-                `video.poster.defaultTimestampPct must be between 0.0 and 1.0 (got ${pct})`,
-                `${kindPath}.poster.defaultTimestampPct`,
-                "error",
-                "Use a value between 0.0 and 1.0",
-                true
-              )
-            );
-          }
-        }
         if (captions?.requiredLocales && Array.isArray(captions.requiredLocales)) {
           for (const locale of captions.requiredLocales) {
             if (!schemaLocales.has(locale)) {
@@ -14476,30 +13614,6 @@ var init_dist2 = __esm({
             );
           }
         }
-        if (config.maxItems !== void 0 && (!Number.isInteger(config.maxItems) || config.maxItems <= 0)) {
-          result.errors.push(
-            this.createError(
-              "INVALID_MAX_ITEMS",
-              `Field '${field.id}' has invalid maxItems: ${config.maxItems}`,
-              `${path25}.config.maxItems`,
-              "error",
-              "maxItems must be a positive integer",
-              true
-            )
-          );
-        }
-        if (config.minItems !== void 0 && config.maxItems !== void 0 && config.minItems > config.maxItems) {
-          result.errors.push(
-            this.createError(
-              "INVALID_ITEMS_RANGE",
-              `Field '${field.id}' has minItems greater than maxItems`,
-              `${path25}.config`,
-              "error",
-              "Ensure minItems \u2264 maxItems",
-              true
-            )
-          );
-        }
       }
       validateRichTextFieldIntegrity(field, path25, result, index) {
         const config = field.config || {};
@@ -14535,22 +13649,6 @@ var init_dist2 = __esm({
             );
           }
         }
-        if (config.allowedBlocks && Array.isArray(config.allowedBlocks)) {
-          const validBlocks = ["paragraph", "heading", "list", "quote", "code", "divider", "table"];
-          for (const [index2, block] of config.allowedBlocks.entries()) {
-            if (!validBlocks.includes(block)) {
-              result.warnings.push(
-                this.createError(
-                  "UNKNOWN_RICH_TEXT_BLOCK",
-                  `Rich text field '${field.id}' allows unknown block type '${block}'`,
-                  `${path25}.config.allowedBlocks[${index2}]`,
-                  "warning",
-                  `Use standard block types: ${validBlocks.join(", ")}`
-                )
-              );
-            }
-          }
-        }
       }
       validateEnumFieldIntegrity(field, path25, result) {
         const config = field.config || {};
@@ -14646,35 +13744,18 @@ var init_dist2 = __esm({
         this.validateRequiredFieldDistribution(index, result);
       }
       validateRuleDependencies(rule, rulePath, context, result) {
-        const conditionsList = rule.conditions?.list ?? rule.conditions?.conditions;
-        if (conditionsList) {
-          for (const [condIndex, condition] of conditionsList.entries()) {
-            if (condition.field && !this.fieldExistsInContext(condition.field, context)) {
-              result.errors.push(
-                this.createError(
-                  "CONDITION_REFERENCES_NONEXISTENT_FIELD",
-                  `Rule condition references non-existent field '${condition.field}'`,
-                  `${rulePath}.conditions.list[${condIndex}].field`,
-                  "error",
-                  "Reference only existing fields in conditions",
-                  true
-                )
-              );
-            }
-            if (condition.field && condition.operator) {
-              const referencedField = this.findFieldInContext(condition.field, context);
-              if (referencedField && !this.isCompatibleComparator(condition.operator, referencedField.type)) {
-                result.warnings.push(
-                  this.createError(
-                    "INCOMPATIBLE_RULE_OPERATOR",
-                    `Operator '${condition.operator}' may not be compatible with field type '${referencedField.type}'`,
-                    `${rulePath}.conditions.list[${condIndex}].operator`,
-                    "warning",
-                    "Verify that the operator is appropriate for the field type"
-                  )
-                );
-              }
-            }
+        for (const [condIndex, condition] of rule.conditions.conditions.entries()) {
+          if (condition.field && !this.fieldExistsInContext(condition.field, context)) {
+            result.errors.push(
+              this.createError(
+                "CONDITION_REFERENCES_NONEXISTENT_FIELD",
+                `Rule condition references non-existent field '${condition.field}'`,
+                `${rulePath}.conditions.conditions[${condIndex}].field`,
+                "error",
+                "Reference only existing fields in conditions",
+                true
+              )
+            );
           }
         }
       }
@@ -14866,11 +13947,11 @@ var init_dist2 = __esm({
       validateComponentIntegrity(index, result) {
         for (const [componentId, component] of index.components.entries) {
           const componentPath = `components.${componentId}`;
-          if (!component.fields || component.fields.length < 2) {
+          if (component.fields.length < 2) {
             result.warnings.push(
               this.createError(
                 "COMPONENT_TOO_SIMPLE",
-                `Component '${componentId}' has only ${component.fields?.length || 0} field(s)`,
+                `Component '${componentId}' has only ${component.fields.length} field(s)`,
                 componentPath,
                 "warning",
                 "Components should group multiple related fields to justify reusability"
@@ -15110,14 +14191,6 @@ var init_dist2 = __esm({
         }
         return null;
       }
-      isCompatibleComparator(comparator, fieldType) {
-        const numericComparators = ["greaterThan", "lessThan"];
-        const numericTypes = ["integer", "decimal"];
-        if (numericComparators.includes(comparator) && !numericTypes.includes(fieldType)) {
-          return false;
-        }
-        return true;
-      }
       getAllFields(contentType) {
         const fields = [];
         if (contentType.fields) {
@@ -15240,18 +14313,6 @@ var init_dist2 = __esm({
       validateRoleStructure(role, rolePath, result, stats) {
         if (role.baseRole) {
           stats.rolesWithBaseRole++;
-          if (!isBuiltInRole(role.baseRole)) {
-            result.errors.push(
-              this.createError(
-                "INVALID_BASE_ROLE",
-                `Role '${role.id}' has invalid baseRole '${role.baseRole}'`,
-                `${rolePath}.baseRole`,
-                "error",
-                `Valid base roles are: ${BUILT_IN_ROLES.join(", ")}`,
-                true
-              )
-            );
-          }
         }
         if (role.includes && role.includes.length > 0) {
           stats.rolesWithIncludes++;
@@ -15259,17 +14320,6 @@ var init_dist2 = __esm({
         if (role.permissions && role.permissions.length > 0) {
           stats.rolesWithExplicitPermissions++;
         }
-        if (role.displayName.length > 128) {
-          result.warnings.push(
-            this.createError(
-              "LONG_ROLE_DISPLAY_NAME",
-              `Role '${role.id}' has a very long displayName (${role.displayName.length} chars)`,
-              `${rolePath}.displayName`,
-              "warning",
-              "Consider using a shorter display name for better UI presentation"
-            )
-          );
-        }
         if (!role.description) {
           result.info.push(
             this.createError(
@@ -15346,21 +14396,6 @@ var init_dist2 = __esm({
         }
         for (const [permIndex, permission] of role.permissions.entries()) {
           const permPath = `${rolePath}.permissions[${permIndex}]`;
-          for (const [actionIndex, action] of permission.actions.entries()) {
-            if (!ROLE_ACTIONS.includes(action)) {
-              const suggestion = ValidationUtils.findBestMatch(action, [...ROLE_ACTIONS]);
-              result.errors.push(
-                this.createError(
-                  "INVALID_ROLE_ACTION",
-                  `Role '${role.id}' has invalid action '${action}'`,
-                  `${permPath}.actions[${actionIndex}]`,
-                  "error",
-                  suggestion ? `Did you mean '${suggestion}'? Valid actions: ${ROLE_ACTIONS.join(", ")}` : `Valid actions are: ${ROLE_ACTIONS.join(", ")}`,
-                  true
-                )
-              );
-            }
-          }
           for (const [tagIndex, tag] of permission.tags.entries()) {
             stats.totalAccessTagsUsed.add(tag);
             if (!definedAccessTags.has(tag)) {
@@ -15565,7 +14600,7 @@ var init_dist2 = __esm({
       }
     };
     EVOLUTION_VALIDATOR_KEY = "evolution";
-    CROSS_VERSION_CHECKS_SKIPPED = Object.entries(CROSS_VERSION_CHECKS).map(([code, check]) => `${check} (${code})`).join(", ");
+    CROSS_VERSION_CHECKS_SKIPPED = Object.entries(CROSS_VERSION_CHECKS).map(([code, check]) => `${check.names} (${code})`).join(", ");
     ValidationPipeline = class {
       config;
       validators = /* @__PURE__ */ new Map();
@@ -16796,7 +15831,7 @@ async function preview(options) {
     return failed(extractApiError(error2, "Pre-deploy validation failed"));
   }
   const validationErrors = status.validationErrors ?? [];
-  const validationWarnings = status.validationWarnings ?? [];
+  const validationWarnings = status.validationWarnings;
   const gitCommitSha = getCurrentGitCommitSha() || void 0;
   const previewData = {
     branchName,
@@ -16889,7 +15924,8 @@ async function run(options) {
     version: deployResult.version,
     durationMs: Date.now() - start,
     preview: previewData,
-    verified
+    verified,
+    validationWarnings: deployResult.validationWarnings
   };
 }
 async function verifyDeploy(branchId, projectRoot) {
@@ -18836,6 +17872,7 @@ async function runLocalVsRemote(options) {
     hasChanges: status.hasChanges ?? false,
     changes: { ...DEFAULT_CHANGES2, ...status.changes },
     validationErrors: status.validationErrors ?? [],
+    validationWarnings: status.validationWarnings,
     localSchema: loaded.schema
   };
 }
@@ -22524,7 +21561,7 @@ var init_banner = __esm({
     init_dev_cockpit_context();
     init_dev_cockpit_format();
     init_startup_info();
-    CLI_VERSION2 = "0.4.0" ;
+    CLI_VERSION2 = "0.5.0" ;
     BRAND_GLYPH = "\u25B6";
     BRAND_NAME = "RelyIO";
     LABEL_WIDTH = 9;
@@ -30679,6 +29716,13 @@ function displayDeploySuccess(version, branchName) {
 
 // src/utils/json-output.ts
 init_change_buckets();
+function listIssues(issues) {
+  return issues.map((issue) => ({
+    path: issue.path,
+    message: issue.message,
+    ...issue.code && { code: issue.code }
+  }));
+}
 function listBucket(bucket) {
   return {
     added: bucket.added,
@@ -30722,25 +29766,23 @@ function createStatusJsonOutput(params) {
       complexity: statistics?.complexity
     },
     ...failure && { error: failure },
-    ...validationErrors.length > 0 && {
-      errors: validationErrors.map((e) => ({
-        path: e.path,
-        message: e.message,
-        ...e.code && { code: e.code }
-      }))
-    },
-    ...validationWarnings.length > 0 && {
-      warnings: validationWarnings.map((w) => ({
-        path: w.path,
-        message: w.message,
-        ...w.code && { code: w.code }
-      }))
-    },
+    ...validationErrors.length > 0 && { errors: listIssues(validationErrors) },
+    ...validationWarnings.length > 0 && { warnings: listIssues(validationWarnings) },
     ...divergence && { divergence }
   };
 }
 function createDeployJsonOutput(params) {
-  const { success: success2, branchName, branchId, version, changes, gitCommitSha, notes, error: error2 } = params;
+  const {
+    success: success2,
+    branchName,
+    branchId,
+    version,
+    changes,
+    gitCommitSha,
+    notes,
+    validationWarnings,
+    error: error2
+  } = params;
   return {
     success: success2,
     ...version && { version, deployedAt: (/* @__PURE__ */ new Date()).toISOString() },
@@ -30754,6 +29796,7 @@ function createDeployJsonOutput(params) {
     },
     ...gitCommitSha && { git: { commitSha: gitCommitSha } },
     ...notes && { notes },
+    warnings: listIssues(validationWarnings),
     ...error2 && { error: error2 }
   };
 }
@@ -30787,7 +29830,8 @@ function createDiffJsonOutput(params) {
     schemaSourcePath,
     hasChanges,
     changes,
-    localSchema
+    localSchema,
+    validationWarnings
   } = params;
   const fieldCount = (key, name) => {
     const section = localSchema?.[key];
@@ -30813,7 +29857,8 @@ function createDiffJsonOutput(params) {
       deleted: bucket.deleted,
       ...bucket.enabled && { enabled: bucket.enabled }
     })),
-    summary: countChanges(changes)
+    summary: countChanges(changes),
+    warnings: listIssues(validationWarnings)
   };
 }
 function countOf(count, noun) {
@@ -31265,10 +30310,16 @@ function nothingToDeploy(preview2) {
       branchName: preview2.branchName,
       branchId: preview2.branchId,
       changes: preview2.changes,
-      gitCommitSha: preview2.gitCommitSha
+      gitCommitSha: preview2.gitCommitSha,
+      validationWarnings: preview2.validationWarnings
     })
   );
 }
+var issueKey = (issue) => JSON.stringify([issue.code, issue.path, issue.message]);
+function warningsNotShown(deployed, shown) {
+  const seen = new Set(shown.map((warning2) => issueKey(warning2)));
+  return deployed.filter((warning2) => !seen.has(issueKey(warning2)));
+}
 async function handleDeploy(options) {
   const { json = false } = options;
   process.on("SIGINT", () => interrupted(json));
@@ -31379,24 +30430,26 @@ async function handleDeploy(options) {
     displayInfo("Your schema is already up to date with the remote branch");
     return;
   }
-  displaySection("Deployment Preview", "sparkles");
-  console.log(
-    THEME.primary("\u2502  ") + THEME.muted(
-      `Target: ${previewData.branchName} (${previewData.branchId.slice(0, 8)}...)`
-    )
-  );
-  console.log(
-    THEME.primary("\u2502  ") + THEME.muted(`Schema: ${formatSchemaSource(previewData)}`)
-  );
-  if (previewData.gitCommitSha) {
+  if (!json) {
+    displaySection("Deployment Preview", "sparkles");
     console.log(
-      THEME.primary("\u2502  ") + THEME.muted(`Git SHA: ${previewData.gitCommitSha.slice(0, 8)}...`)
+      THEME.primary("\u2502  ") + THEME.muted(
+        `Target: ${previewData.branchName} (${previewData.branchId.slice(0, 8)}...)`
+      )
     );
-  }
-  displaySectionEnd();
-  displaySchemaChanges(previewData.changes);
-  if (previewData.validationWarnings.length > 0) {
-    console.log(formatValidationErrors(previewData.validationWarnings));
+    console.log(
+      THEME.primary("\u2502  ") + THEME.muted(`Schema: ${formatSchemaSource(previewData)}`)
+    );
+    if (previewData.gitCommitSha) {
+      console.log(
+        THEME.primary("\u2502  ") + THEME.muted(`Git SHA: ${previewData.gitCommitSha.slice(0, 8)}...`)
+      );
+    }
+    displaySectionEnd();
+    displaySchemaChanges(previewData.changes);
+    if (previewData.validationWarnings.length > 0) {
+      console.log(formatValidationErrors(previewData.validationWarnings));
+    }
   }
   let notes;
   if (!json && !options.yes) {
@@ -31493,12 +30546,17 @@ async function handleDeploy(options) {
         version: result.version,
         changes: result.preview.changes,
         gitCommitSha: result.preview.gitCommitSha,
-        notes
+        notes,
+        validationWarnings: result.validationWarnings
       })
     );
   }
   deploySpinner?.succeed("Schema deployment completed successfully");
   displayDeploySuccess(result.version, result.preview.branchName);
+  const unseenWarnings = warningsNotShown(result.validationWarnings, previewData.validationWarnings);
+  if (unseenWarnings.length > 0) {
+    console.log(formatValidationErrors(unseenWarnings));
+  }
   console.log();
   switch (result.verified) {
     case "passed": {
@@ -32133,7 +31191,7 @@ function sandboxCommands(program2) {
 }
 
 // src/commands/version.ts
-var CLI_VERSION = "0.4.0" ;
+var CLI_VERSION = "0.5.0" ;
 async function handleVersion(_options) {
   console.log(heading("RelyIO CLI Version Information"));
   const versionInfo = [
@@ -32504,7 +31562,7 @@ async function performStatusCheck(branchName, options) {
               hasChanges: response.hasChanges ?? false,
               ...response.changes ?? defaultChanges,
               validationErrors: response.validationErrors ?? [],
-              validationWarnings: response.validationWarnings ?? [],
+              validationWarnings: response.validationWarnings,
               recommendations: response.recommendations ?? [],
               statistics: response.statistics,
               complexityAnalysis: response.complexityAnalysis
@@ -33679,19 +32737,23 @@ async function handleDiff(options) {
           schemaSourcePath: result.schemaSourcePath,
           hasChanges: result.hasChanges,
           changes: result.changes,
-          localSchema: result.localSchema
+          localSchema: result.localSchema,
+          validationWarnings: result.validationWarnings
         })
       );
       return;
     }
     displayDiffHeader(result.branchName, result.branchId);
-    if (!result.hasChanges) {
+    if (result.hasChanges) {
+      displayDiffSummary(result.changes);
+      displayDetailedDiff(result.changes, result.localSchema);
+    } else {
       console.log(THEME3.muted("No changes between local schema and remote branch"));
       console.log();
-      return;
     }
-    displayDiffSummary(result.changes);
-    displayDetailedDiff(result.changes, result.localSchema);
+    if (result.validationWarnings.length > 0) {
+      console.log(formatValidationErrors(result.validationWarnings));
+    }
     return;
   }
   if (json) {
@@ -36403,7 +35465,7 @@ Examples:
 }
 
 // src/index.ts
-var CLI_VERSION3 = "0.4.0" ;
+var CLI_VERSION3 = "0.5.0" ;
 var program = new Command();
 program.name("relyio").description("RelyIO CLI - Content Management, Simplified").version(CLI_VERSION3);
 registerGlobalOptions(program);