@squiz/dx-json-schema-lib 1.87.0 → 1.89.0

package/src/utils/jsonBreakDetector/jsonBreakDetector.spec.ts

@@ -0,0 +1,3041 @@
+jest.mock('./dereference/dereference', () => ({
+  dereferenceLocal: jest.fn(<T extends Record<string, unknown>>(schema: T): T => schema),
+}));
+
+import type { JSONSchema } from '@squiz/json-schema-library';
+import { dereferenceLocal } from './dereference/dereference';
+
+import jsonBreakDetector from './jsonBreakDetector';
+
+const breakAt = (location: string, message: string) => ({ location, message });
+
+describe('jsonBreakDetector', () => {
+  describe('required fields', () => {
+    it('returns no breaks when there are no required fields', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+    it('returns no breaks when required fields are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects a newly required field at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title', 'subtitle'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('subtitle', 'New required field')]);
+    });
+
+    it('detects required on a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title', 'subtitle'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('subtitle', 'New required field')]);
+    });
+
+    it('detects required fields on a newly added nested property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          metadata: {
+            type: 'object',
+            properties: {
+              version: { type: 'string' },
+            },
+            required: ['version'],
+          },
+        },
+        required: ['title'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('metadata.version', 'New required field')]);
+    });
+
+    it('returns no breaks when a newly added property is optional', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects multiple newly required fields at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+          author: { type: 'string' },
+        },
+        required: [],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+          author: { type: 'string' },
+        },
+        required: ['title', 'author'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('title', 'New required field'),
+        breakAt('author', 'New required field'),
+      ]);
+    });
+
+    it('detects a newly required field in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: {
+            type: 'object',
+            properties: {
+              url: { type: 'string' },
+              width: { type: 'number' },
+            },
+            required: ['url'],
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: {
+            type: 'object',
+            properties: {
+              url: { type: 'string' },
+              width: { type: 'number' },
+            },
+            required: ['url', 'width'],
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('image.width', 'New required field')]);
+    });
+
+    it('detects a newly required field in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                value: { type: 'string' },
+              },
+              required: ['name'],
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                value: { type: 'string' },
+              },
+              required: ['name', 'value'],
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[].value', 'New required field')]);
+    });
+
+    it('treats a missing before property schema as having no required fields', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {},
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              version: { type: 'string' },
+            },
+            required: ['version'],
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('metadata.version', 'New required field')]);
+    });
+
+    it('does not report a break when a field is removed from required', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title', 'subtitle'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+        required: ['title'],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when required is removed entirely', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: ['title'],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when required is an empty array', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: [],
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+        required: [],
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when dependentRequired is unchanged and a new optional property is added', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+          height: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects a newly dependent required field at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+          height: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+          height: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width', 'height'],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('height', 'New dependent required field')]);
+    });
+
+    it('detects a new dependentRequired rule at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('width', 'New dependent required field')]);
+    });
+
+    it('detects a newly dependent required field in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              thumbnail: { type: 'string' },
+              url: { type: 'string' },
+              width: { type: 'number' },
+            },
+            dependentRequired: {
+              thumbnail: ['url'],
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              thumbnail: { type: 'string' },
+              url: { type: 'string' },
+              width: { type: 'number' },
+            },
+            dependentRequired: {
+              thumbnail: ['url', 'width'],
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.width', 'New dependent required field'),
+      ]);
+    });
+
+    it('detects a newly dependent required field in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                value: { type: 'string' },
+              },
+              dependentRequired: {
+                name: ['value'],
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                value: { type: 'string' },
+                category: { type: 'string' },
+              },
+              dependentRequired: {
+                name: ['value', 'category'],
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('tags[].category', 'New dependent required field'),
+      ]);
+    });
+
+    it('does not report a break when a value is removed from dependentRequired', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+          height: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width', 'height'],
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+          height: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when a dependentRequired trigger rule is removed entirely', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when dependentRequired uses empty arrays', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: [],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when dependentRequired is added with only empty arrays', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: { type: 'object' },
+        },
+        dependentRequired: {
+          image: [],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report dependentRequired for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          metadata: {
+            type: 'object',
+            properties: {
+              thumbnail: { type: 'string' },
+              url: { type: 'string' },
+            },
+            dependentRequired: {
+              thumbnail: ['url'],
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report dependentRequired when the trigger field is newly added', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          image: { type: 'object' },
+          width: { type: 'number' },
+        },
+        dependentRequired: {
+          image: ['width'],
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('field types', () => {
+    it('returns no breaks when field types are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when a new field is added', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+          subtitle: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when a "type" is added where it was undefined', async () => {
+      const beforeSchema: JSONSchema = {
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('treats equivalent union types as unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          value: { type: ['string', 'null'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          value: { type: ['null', 'string'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when integer is relaxed to number', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'integer' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when integer is relaxed to number in a union type', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: ['integer', 'null'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: ['number', 'null'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when integer is relaxed to number in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          counts: {
+            type: 'array',
+            items: { type: 'integer' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          counts: {
+            type: 'array',
+            items: { type: 'number' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects a break when number is narrowed to integer', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'integer' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Field type changed')]);
+    });
+
+    it('detects a break when number is narrowed to integer in a union type', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: ['number', 'null'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: ['integer', 'null'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Field type changed')]);
+    });
+
+    it('detects a field type change at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sheep: { type: 'object', properties: { name: { type: 'string' } } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sheep: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' } } } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('sheep', 'Field type changed')]);
+    });
+
+    it('detects a field type change in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: {
+            type: 'object',
+            properties: {
+              width: { type: 'string' },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          image: {
+            type: 'object',
+            properties: {
+              width: { type: 'number' },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('image.width', 'Field type changed')]);
+    });
+
+    it('detects a field type change in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'number' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[]', 'Field type changed')]);
+    });
+
+    it('detects when type is removed on an existing field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: {},
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Field type changed')]);
+    });
+
+    it('detects a field type change in a deeply nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'object',
+            properties: {
+              sidebar: {
+                type: 'object',
+                properties: {
+                  width: { type: 'string' },
+                },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'object',
+            properties: {
+              sidebar: {
+                type: 'object',
+                properties: {
+                  width: { type: 'number' },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('content.sidebar.width', 'Field type changed'),
+      ]);
+    });
+  });
+
+  describe('enum options', () => {
+    it('returns no breaks when enum options are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when enum options are added', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when a single-value enum becomes const with the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['published'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', const: 'published' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects removed enum options when a multi-value enum is narrowed to const', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', const: 'published' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('status', 'Enum options removed'),
+        breakAt('status', 'Const value changed'),
+      ]);
+    });
+
+    it('detects removed enum options at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('status', 'Enum options removed')]);
+    });
+
+    it('detects removed enum options in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              status: { type: 'string', enum: ['draft', 'published'] },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              status: { type: 'string', enum: ['published'] },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.status', 'Enum options removed'),
+        breakAt('metadata.status', 'Const value changed'),
+      ]);
+    });
+
+    it('detects removed enum options in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', enum: ['news', 'sport', 'weather'] },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', enum: ['news', 'sport'] },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[]', 'Enum options removed')]);
+    });
+
+    it('returns no breaks when enum is removed entirely', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects enum added to an existing field without enum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('status', 'Enum added')]);
+    });
+
+    it('detects enum added in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              status: { type: 'string' },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              status: { type: 'string', enum: ['draft', 'published'] },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('metadata.status', 'Enum added')]);
+    });
+
+    it('detects enum added in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', enum: ['news', 'sport'] },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[]', 'Enum added')]);
+    });
+
+    it('does not report enum added for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report enum added when a const is relaxed to an enum that includes the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', const: 'published' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report enum removal for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          status: { type: 'string', enum: ['draft', 'published'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('const values', () => {
+    it('returns no breaks when const values are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when a single-value enum becomes const with the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', enum: ['article'] },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when const becomes a single-value enum with the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', enum: ['article'] },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when const is removed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects when const is added to an existing field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('type', 'Const value changed')]);
+    });
+
+    it('detects when const is changed on an existing field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'article' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          type: { type: 'string', const: 'page' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('type', 'Const value changed')]);
+    });
+
+    it('detects const changes in a nested object property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              version: { type: 'number', const: 1 },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              version: { type: 'number', const: 2 },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.version', 'Const value changed'),
+      ]);
+    });
+
+    it('detects const changes in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', const: 'news' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', const: 'sport' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[]', 'Const value changed')]);
+    });
+
+    it('does not report const changes for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          type: { type: 'string', const: 'article' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('array constraints', () => {
+    it('returns no breaks when array constraints are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 10,
+            uniqueItems: true,
+            contains: { type: 'string' },
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 10,
+            uniqueItems: true,
+            contains: { type: 'string' },
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when array constraints are relaxed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            minItems: 2,
+            maxItems: 5,
+            uniqueItems: true,
+            contains: { type: 'string' },
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 10,
+            uniqueItems: false,
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects minItems being increased at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', minItems: 1, items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', minItems: 3, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags', 'Array minItems increased')]);
+    });
+
+    it('detects minItems being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', minItems: 1, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags', 'Array minItems increased')]);
+    });
+
+    it('detects maxItems being lowered at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', maxItems: 10, items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', maxItems: 5, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags', 'Array maxItems lowered')]);
+    });
+
+    it('detects maxItems being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', maxItems: 5, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags', 'Array maxItems lowered')]);
+    });
+
+    it('detects uniqueItems being added at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', uniqueItems: true, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags', 'Array uniqueItems added')]);
+    });
+
+    it('detects contains being added at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', contains: { type: 'string' }, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags.{contains}', 'Field type changed')]);
+    });
+
+    it('detects contains type changes at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            contains: { type: 'string' },
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            contains: { type: 'number' },
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags.{contains}', 'Field type changed')]);
+    });
+
+    it('detects string constraint narrowing inside contains subschemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            contains: { type: 'string', minLength: 1 },
+            items: { type: 'string' },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            contains: { type: 'string', minLength: 5 },
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('tags.{contains}', 'String minLength increased'),
+      ]);
+    });
+
+    it('detects array constraint narrowing in nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              tags: { type: 'array', minItems: 1, items: { type: 'string' } },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              tags: { type: 'array', minItems: 2, items: { type: 'string' } },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.tags', 'Array minItems increased'),
+      ]);
+    });
+
+    it('detects array constraint narrowing in deeply nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'object',
+            properties: {
+              sidebar: {
+                type: 'object',
+                properties: {
+                  links: { type: 'array', maxItems: 10, items: { type: 'string' } },
+                },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'object',
+            properties: {
+              sidebar: {
+                type: 'object',
+                properties: {
+                  links: { type: 'array', maxItems: 3, items: { type: 'string' } },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('content.sidebar.links', 'Array maxItems lowered'),
+      ]);
+    });
+
+    it('detects uniqueItems being added in nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              roles: { type: 'array', items: { type: 'string' } },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              roles: { type: 'array', uniqueItems: true, items: { type: 'string' } },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.roles', 'Array uniqueItems added'),
+      ]);
+    });
+
+    it('detects contains constraint changes in nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              tags: {
+                type: 'array',
+                contains: { type: 'string' },
+                items: { type: 'string' },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              tags: {
+                type: 'array',
+                contains: { type: 'number' },
+                items: { type: 'string' },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.tags.{contains}', 'Field type changed'),
+      ]);
+    });
+
+    it('detects array constraint narrowing in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'array',
+              maxItems: 10,
+              items: { type: 'string' },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'array',
+              maxItems: 3,
+              items: { type: 'string' },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('groups[]', 'Array maxItems lowered')]);
+    });
+
+    it('detects minItems being increased on arrays inside array item objects', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                tags: { type: 'array', minItems: 1, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                tags: { type: 'array', minItems: 3, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('groups[].tags', 'Array minItems increased'),
+      ]);
+    });
+
+    it('detects maxItems being lowered on arrays inside array item objects', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                tags: { type: 'array', maxItems: 10, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                tags: { type: 'array', maxItems: 3, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('groups[].tags', 'Array maxItems lowered'),
+      ]);
+    });
+
+    it('detects uniqueItems being added on arrays inside array item objects', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                members: { type: 'array', items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                members: { type: 'array', uniqueItems: true, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('groups[].members', 'Array uniqueItems added'),
+      ]);
+    });
+
+    it('detects contains constraint changes on arrays inside array item objects', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                labels: {
+                  type: 'array',
+                  contains: { type: 'string' },
+                  items: { type: 'string' },
+                },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          groups: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                labels: {
+                  type: 'array',
+                  contains: { type: 'number' },
+                  items: { type: 'string' },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('groups[].labels.{contains}', 'Field type changed'),
+      ]);
+    });
+
+    it('detects array constraint narrowing in deeply nested array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sections: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                blocks: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      items: { type: 'array', minItems: 1, items: { type: 'string' } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sections: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                blocks: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      items: { type: 'array', minItems: 2, items: { type: 'string' } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('sections[].blocks[].items', 'Array minItems increased'),
+      ]);
+    });
+
+    it('detects multiple array constraint breaks on arrays inside nested objects within array items', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sections: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                content: {
+                  type: 'object',
+                  properties: {
+                    tags: { type: 'array', minItems: 1, maxItems: 10, items: { type: 'string' } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          sections: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                content: {
+                  type: 'object',
+                  properties: {
+                    tags: {
+                      type: 'array',
+                      minItems: 3,
+                      maxItems: 5,
+                      uniqueItems: true,
+                      items: { type: 'string' },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('sections[].content.tags', 'Array minItems increased'),
+        breakAt('sections[].content.tags', 'Array maxItems lowered'),
+        breakAt('sections[].content.tags', 'Array uniqueItems added'),
+      ]);
+    });
+
+    it('detects multiple array constraint breaks on the same field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: { type: 'array', minItems: 1, maxItems: 10, items: { type: 'string' } },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            minItems: 3,
+            maxItems: 5,
+            uniqueItems: true,
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('tags', 'Array minItems increased'),
+        breakAt('tags', 'Array maxItems lowered'),
+        breakAt('tags', 'Array uniqueItems added'),
+      ]);
+    });
+
+    it('does not report array constraint changes for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          tags: { type: 'array', minItems: 1, uniqueItems: true, items: { type: 'string' } },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('numeric constraints', () => {
+    it('returns no breaks when numeric constraints are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 0, maximum: 100, exclusiveMinimum: 0, exclusiveMaximum: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 0, maximum: 100, exclusiveMinimum: 0, exclusiveMaximum: 100 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when numeric constraints are relaxed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, maximum: 10, exclusiveMinimum: 5, exclusiveMaximum: 10, multipleOf: 4 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 0, maximum: 100, multipleOf: 2 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when both bounds are set and minimum remains the effective lower bound', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, exclusiveMinimum: 3 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, exclusiveMinimum: 4 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when both bounds are set and maximum remains the effective upper bound', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10, exclusiveMaximum: 20 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10, exclusiveMaximum: 15 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects minimum being increased at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 0 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric minimum increased')]);
+    });
+
+    it('detects minimum being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 1 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric minimum increased')]);
+    });
+
+    it('detects exclusiveMinimum being increased at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 0 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+      ]);
+    });
+
+    it('detects exclusiveMinimum being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 0 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+      ]);
+    });
+
+    it('detects maximum being lowered at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 50 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric maximum lowered')]);
+    });
+
+    it('detects maximum being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 100 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric maximum lowered')]);
+    });
+
+    it('detects exclusiveMaximum being lowered at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 50 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('detects exclusiveMaximum being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 100 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('detects numeric constraint narrowing in nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              priority: { type: 'integer', minimum: 1 },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              priority: { type: 'integer', minimum: 3 },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.priority', 'Numeric minimum increased'),
+      ]);
+    });
+
+    it('detects numeric constraint narrowing in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          scores: {
+            type: 'array',
+            items: { type: 'number', maximum: 100 },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          scores: {
+            type: 'array',
+            items: { type: 'number', maximum: 50 },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('scores[]', 'Numeric maximum lowered')]);
+    });
+
+    it('detects multiple numeric constraint breaks on the same field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 0, maximum: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, maximum: 50, exclusiveMinimum: 5, exclusiveMaximum: 50 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('detects minimum being changed to exclusiveMinimum at the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+      ]);
+    });
+
+    it('does not report a break when minimum is replaced by exclusiveMinimum at an equivalent value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 4 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when exclusiveMinimum is relaxed to minimum at the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMinimum: 5 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects maximum being changed to exclusiveMaximum at the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 10 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('does not report a break when maximum is replaced by exclusiveMaximum at an equivalent value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 11 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when exclusiveMaximum is relaxed to maximum at the same value', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', exclusiveMaximum: 10 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when exclusiveMinimum is redundant alongside a stricter minimum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, exclusiveMinimum: 3 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects when exclusiveMinimum is added at the same value as an existing minimum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, exclusiveMinimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+      ]);
+    });
+
+    it('detects when exclusiveMaximum is added at the same value as an existing maximum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10, exclusiveMaximum: 10 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('detects when exclusiveMinimum tightens beyond an existing minimum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 3, exclusiveMinimum: 1 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 3, exclusiveMinimum: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMinimum increased'),
+      ]);
+    });
+
+    it('detects minimum being increased when both lower bound keywords are set', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 3, exclusiveMinimum: 1 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', minimum: 5, exclusiveMinimum: 1 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric minimum increased')]);
+    });
+
+    it('does not report a break when exclusiveMaximum is redundant alongside a stricter maximum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10, exclusiveMaximum: 20 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects when exclusiveMaximum tightens beyond an existing maximum', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 20, exclusiveMaximum: 30 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 20, exclusiveMaximum: 10 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('count', 'Numeric exclusiveMaximum lowered'),
+      ]);
+    });
+
+    it('detects maximum being lowered when both upper bound keywords are set', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 20, exclusiveMaximum: 30 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', maximum: 10, exclusiveMaximum: 30 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric maximum lowered')]);
+    });
+
+    it('detects multipleOf being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 2 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric multipleOf narrowed')]);
+    });
+
+    it('detects multipleOf being narrowed to a coarser divisor', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 2 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 4 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric multipleOf narrowed')]);
+    });
+
+    it('detects multipleOf being changed to an incompatible divisor', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 2 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 3 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('count', 'Numeric multipleOf narrowed')]);
+    });
+
+    it('does not report a break when multipleOf is relaxed to a finer divisor', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 4 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          count: { type: 'number', multipleOf: 2 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report numeric constraint changes for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          count: { type: 'number', minimum: 1, maximum: 10 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('string constraints', () => {
+    it('returns no breaks when string constraints are unchanged', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 1, maxLength: 100, format: 'email', pattern: '^[a-z]+$' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 1, maxLength: 100, format: 'email', pattern: '^[a-z]+$' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('returns no breaks when string constraints are relaxed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 5, maxLength: 10, format: 'email', pattern: '^[a-z]+$' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 1, maxLength: 100 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects minLength being increased at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 1 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 5 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('title', 'String minLength increased')]);
+    });
+
+    it('detects minLength being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', minLength: 1 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('title', 'String minLength increased')]);
+    });
+
+    it('detects maxLength being lowered at the root', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', maxLength: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', maxLength: 50 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('title', 'String maxLength lowered')]);
+    });
+
+    it('detects maxLength being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string', maxLength: 100 },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('title', 'String maxLength lowered')]);
+    });
+
+    it('detects format being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          email: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          email: { type: 'string', format: 'email' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('email', 'String format changed')]);
+    });
+
+    it('detects format being changed on an existing field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          value: { type: 'string', format: 'email' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          value: { type: 'string', format: 'uri' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('value', 'String format changed')]);
+    });
+
+    it('detects pattern being added where it was previously unset', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string', pattern: '^[a-z]+$' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('slug', 'String pattern changed')]);
+    });
+
+    it('detects pattern being changed on an existing field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string', pattern: '^[a-z]+$' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string', pattern: '^[a-z0-9-]+$' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('slug', 'String pattern changed')]);
+    });
+
+    it('does not report a break when format is removed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          email: { type: 'string', format: 'email' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          email: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('does not report a break when pattern is removed', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string', pattern: '^[a-z]+$' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+
+    it('detects string constraint narrowing in nested object properties', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              slug: { type: 'string', minLength: 1 },
+            },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          metadata: {
+            type: 'object',
+            properties: {
+              slug: { type: 'string', minLength: 3 },
+            },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('metadata.slug', 'String minLength increased'),
+      ]);
+    });
+
+    it('detects string constraint narrowing in array item schemas', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', maxLength: 100 },
+          },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          tags: {
+            type: 'array',
+            items: { type: 'string', maxLength: 50 },
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('tags[]', 'String maxLength lowered')]);
+    });
+
+    it('detects multiple string constraint breaks on the same field', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: { type: 'string', minLength: 1, maxLength: 100 },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          slug: {
+            type: 'string',
+            minLength: 3,
+            maxLength: 50,
+            format: 'hostname',
+            pattern: '^[a-z0-9-]+$',
+          },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('slug', 'String minLength increased'),
+        breakAt('slug', 'String maxLength lowered'),
+        breakAt('slug', 'String format changed'),
+        breakAt('slug', 'String pattern changed'),
+      ]);
+    });
+
+    it('does not report string constraint changes for a newly added property', async () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          slug: { type: 'string', minLength: 1, maxLength: 10, format: 'hostname', pattern: '^[a-z]+$' },
+        },
+      };
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([]);
+    });
+  });
+
+  describe('schema dereferencing', () => {
+    beforeEach(() => {
+      jest.mocked(dereferenceLocal).mockClear();
+    });
+
+    it('calls dereference for the before and after schemas', () => {
+      const beforeSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+        },
+      };
+      const afterSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          subtitle: { type: 'string' },
+        },
+      };
+
+      jsonBreakDetector(beforeSchema, afterSchema);
+
+      expect(dereferenceLocal).toHaveBeenCalledTimes(2);
+      expect(dereferenceLocal).toHaveBeenNthCalledWith(1, beforeSchema);
+      expect(dereferenceLocal).toHaveBeenNthCalledWith(2, afterSchema);
+    });
+
+    it('reports a break when before schema dereferencing fails', () => {
+      const beforeSchema: JSONSchema = { $ref: '#/definitions/Missing' };
+      const afterSchema: JSONSchema = { type: 'string' };
+      const errorMessage = 'Could not resolve JSON pointer reference: "#/definitions/Missing" at segment "definitions"';
+
+      jest.mocked(dereferenceLocal).mockImplementationOnce(() => {
+        throw new Error(errorMessage);
+      });
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('', errorMessage)]);
+      expect(dereferenceLocal).toHaveBeenCalledTimes(2);
+    });
+
+    it('reports a break when after schema dereferencing fails', () => {
+      const beforeSchema: JSONSchema = { type: 'string' };
+      const afterSchema: JSONSchema = { $ref: '#/definitions/Missing' };
+      const errorMessage = 'Could not resolve JSON pointer reference: "#/definitions/Missing" at segment "definitions"';
+
+      jest
+        .mocked(dereferenceLocal)
+        .mockImplementationOnce((schema) => schema)
+        .mockImplementationOnce(() => {
+          throw new Error(errorMessage);
+        });
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([breakAt('', errorMessage)]);
+      expect(dereferenceLocal).toHaveBeenCalledTimes(2);
+    });
+
+    it('reports breaks for both schemas when dereferencing fails for each', () => {
+      const beforeSchema: JSONSchema = { $ref: '#/definitions/MissingBefore' };
+      const afterSchema: JSONSchema = { $ref: '#/definitions/MissingAfter' };
+      const beforeErrorMessage =
+        'Could not resolve JSON pointer reference: "#/definitions/MissingBefore" at segment "definitions"';
+      const afterErrorMessage =
+        'Could not resolve JSON pointer reference: "#/definitions/MissingAfter" at segment "definitions"';
+
+      jest
+        .mocked(dereferenceLocal)
+        .mockImplementationOnce(() => {
+          throw new Error(beforeErrorMessage);
+        })
+        .mockImplementationOnce(() => {
+          throw new Error(afterErrorMessage);
+        });
+
+      expect(jsonBreakDetector(beforeSchema, afterSchema)).toEqual([
+        breakAt('', beforeErrorMessage),
+        breakAt('', afterErrorMessage),
+      ]);
+      expect(dereferenceLocal).toHaveBeenCalledTimes(2);
+    });
+  });
+});