@wix/web5-core 1.56.0

package/dist/cjs/patternValidator/validator.test.js

@@ -0,0 +1,1277 @@
+"use strict";
+
+var _index = require("./index");
+/**
+ * Helper function to convert block element strings to mock AST nodes for testing
+ * Accepts BlockElement or list pattern strings like 'list{[t], [t]}'
+ */
+function createMockAstNodes(blockElements) {
+  return blockElements.map(element => {
+    // Handle list patterns like 'list{[t], [t, link]}'
+    if (typeof element === 'string' && element.startsWith('list{')) {
+      // Parse list pattern: list{[t], [t, link]} -> [[t], [t, link]]
+      const listPattern = element.slice(5, -1); // Remove 'list{' and '}'
+      const items = [];
+
+      // Parse items: [t], [t, link] -> ['t'], ['t', 'link']
+      const itemMatches = listPattern.match(/\[([^\]]+)\]/g) || [];
+      for (const itemMatch of itemMatches) {
+        const itemContent = itemMatch.slice(1, -1); // Remove '[' and ']'
+        const itemElements = itemContent.split(',').map(e => e.trim());
+
+        // Convert item elements to paragraph children
+        // To get multiple 't' elements, we need to break up text nodes
+        // We'll create separate paragraphs for consecutive 't' elements, or use separators
+        const paragraphs = [];
+        let currentParagraphChildren = [];
+        let lastWasText = false;
+        for (const itemElement of itemElements) {
+          if (itemElement === 't') {
+            // If previous was text, start a new paragraph to prevent merging
+            // Or add a separator to force text splitting
+            if (lastWasText && currentParagraphChildren.length > 0) {
+              // Finish current paragraph and start new one
+              paragraphs.push({
+                type: 'paragraph',
+                children: [...currentParagraphChildren]
+              });
+              currentParagraphChildren = [{
+                type: 'text',
+                value: 'Text'
+              }];
+            } else {
+              currentParagraphChildren.push({
+                type: 'text',
+                value: 'Text'
+              });
+            }
+            lastWasText = true;
+          } else if (itemElement === 'link') {
+            currentParagraphChildren.push({
+              type: 'link',
+              url: 'http://example.com',
+              children: [{
+                type: 'text',
+                value: 'Link'
+              }]
+            });
+            lastWasText = false;
+          } else if (itemElement === 'image') {
+            currentParagraphChildren.push({
+              type: 'image',
+              url: 'http://example.com/image.jpg',
+              alt: 'Image'
+            });
+            lastWasText = false;
+          } else if (itemElement === 'web5_icon') {
+            currentParagraphChildren.push({
+              type: 'image',
+              url: 'web5://icon/dollar',
+              alt: ''
+            });
+            lastWasText = false;
+          }
+        }
+
+        // Add final paragraph if it has children
+        if (currentParagraphChildren.length > 0) {
+          paragraphs.push({
+            type: 'paragraph',
+            children: currentParagraphChildren
+          });
+        }
+        items.push({
+          type: 'listItem',
+          children: paragraphs.length > 0 ? paragraphs : []
+        });
+      }
+      return {
+        type: 'list',
+        ordered: false,
+        start: null,
+        spread: false,
+        children: items
+      };
+    }
+
+    // Handle entity links for testing (e.g., 'entity_link:blog_post:abc123')
+    const elementStr = String(element);
+    if (elementStr.startsWith('entity_link:')) {
+      const parts = elementStr.slice('entity_link:'.length).split(':');
+      const entityType = parts[0] || 'default_type';
+      const entityId = parts[1] || 'default_id';
+      return {
+        type: 'paragraph',
+        children: [{
+          type: 'link',
+          url: `web5://entity/${entityType}/${entityId}`,
+          children: [{
+            type: 'text',
+            value: 'Entity Link'
+          }]
+        }]
+      };
+    }
+
+    // Handle web5 icon images for testing (e.g., 'web5_icon:dollar')
+    if (elementStr.startsWith('web5_icon:')) {
+      const iconName = elementStr.slice('web5_icon:'.length);
+      return {
+        type: 'paragraph',
+        children: [{
+          type: 'image',
+          url: `web5://icon/${iconName}`,
+          alt: ''
+        }]
+      };
+    }
+
+    // Handle web5 images with custom type for testing (e.g., 'web5_image:illustration:chart')
+    if (elementStr.startsWith('web5_image:')) {
+      const parts = elementStr.slice('web5_image:'.length).split(':');
+      const imageType = parts[0] || 'default';
+      const imageName = parts[1] || 'default';
+      return {
+        type: 'paragraph',
+        children: [{
+          type: 'image',
+          url: `web5://${imageType}/${imageName}`,
+          alt: ''
+        }]
+      };
+    }
+
+    // Handle http links for testing (e.g., 'http_link')
+    if (elementStr === 'http_link') {
+      return {
+        type: 'paragraph',
+        children: [{
+          type: 'link',
+          url: 'http://example.com/page',
+          children: [{
+            type: 'text',
+            value: 'HTTP Link'
+          }]
+        }]
+      };
+    }
+
+    // Handle https links for testing (e.g., 'https_link')
+    if (elementStr === 'https_link') {
+      return {
+        type: 'paragraph',
+        children: [{
+          type: 'link',
+          url: 'https://example.com/page',
+          children: [{
+            type: 'text',
+            value: 'HTTPS Link'
+          }]
+        }]
+      };
+    }
+    switch (element) {
+      case 'h1':
+        return {
+          type: 'heading',
+          depth: 1,
+          children: [{
+            type: 'text',
+            value: 'Heading 1'
+          }]
+        };
+      case 'h2':
+        return {
+          type: 'heading',
+          depth: 2,
+          children: [{
+            type: 'text',
+            value: 'Heading 2'
+          }]
+        };
+      case 'h3':
+        return {
+          type: 'heading',
+          depth: 3,
+          children: [{
+            type: 'text',
+            value: 'Heading 3'
+          }]
+        };
+      case 'h4':
+        return {
+          type: 'heading',
+          depth: 4,
+          children: [{
+            type: 'text',
+            value: 'Heading 4'
+          }]
+        };
+      case 'h5':
+        return {
+          type: 'heading',
+          depth: 5,
+          children: [{
+            type: 'text',
+            value: 'Heading 5'
+          }]
+        };
+      case 'h6':
+        return {
+          type: 'heading',
+          depth: 6,
+          children: [{
+            type: 'text',
+            value: 'Heading 6'
+          }]
+        };
+      case 't':
+        return {
+          type: 'paragraph',
+          children: [{
+            type: 'text',
+            value: 'Text content'
+          }]
+        };
+      case 'link':
+        return {
+          type: 'paragraph',
+          children: [{
+            type: 'link',
+            url: 'http://example.com',
+            children: [{
+              type: 'text',
+              value: 'Link'
+            }]
+          }]
+        };
+      case 'image':
+        return {
+          type: 'paragraph',
+          children: [{
+            type: 'image',
+            url: 'http://example.com/image.jpg',
+            alt: 'Image'
+          }]
+        };
+      case 'html_comment':
+        return {
+          type: 'html',
+          value: '<!-- comment -->'
+        };
+      case 'table':
+        return {
+          type: 'table',
+          align: [],
+          children: []
+        };
+      case 'callout':
+        return {
+          type: 'blockquote',
+          children: []
+        };
+      case 'thematicBreak':
+        return {
+          type: 'thematicBreak'
+        };
+      default:
+        // For other types, create a simple paragraph
+        return {
+          type: 'paragraph',
+          children: [{
+            type: 'text',
+            value: String(element)
+          }]
+        };
+    }
+  });
+}
+describe('Pattern Validator', () => {
+  describe('Pattern Syntax Validation', () => {
+    it('validates correct patterns', () => {
+      expect((0, _index.validatePatternSyntax)('h2 > t').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('t+').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('(t | image)*').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('h2 > t[1-3] > link?').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('(h2 > t)+').valid).toBe(true);
+    });
+    it('detects invalid elements', () => {
+      const result = (0, _index.validatePatternSyntax)('h2 > invalid');
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('Invalid element');
+    });
+    it('detects empty patterns', () => {
+      const result = (0, _index.validatePatternSyntax)('');
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe('Pattern rule is empty');
+    });
+    it('detects syntax errors', () => {
+      expect((0, _index.validatePatternSyntax)('h2 >').valid).toBe(false);
+      expect((0, _index.validatePatternSyntax)('(h2 > t').valid).toBe(false);
+      expect((0, _index.validatePatternSyntax)('h2 [').valid).toBe(false);
+    });
+    it('detects unexpected characters', () => {
+      const result = (0, _index.validatePatternSyntax)('h2 @ t');
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('Unexpected character');
+    });
+  });
+  describe('Basic sequences', () => {
+    it('matches simple sequence', () => {
+      const nodes1 = createMockAstNodes(['h2', 't']);
+      const nodes2 = createMockAstNodes(['h2', 'image']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(1); // Matched both h2 and t
+      // nodes2 matches h2 (partial match), so valid is true but endIndex is 0
+      expect(result2.valid).toBe(false);
+      expect(result2.endIndex).toBe(0); // Only matched h2
+    });
+    it('matches longer sequence', () => {
+      const nodes1 = createMockAstNodes(['h2', 't', 'link']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t > link');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t > link');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(2); // Matched all three
+      // nodes2 matches h2 > t (partial match), so valid is true but endIndex is 1
+      expect(result2.valid).toBe(false);
+      expect(result2.endIndex).toBe(1); // Only matched h2 and t
+    });
+  });
+  describe('Quantifiers', () => {
+    it('matches star quantifier (0 or more)', () => {
+      const nodes1 = createMockAstNodes(['h2']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't', 't']);
+      expect((0, _index.validatePattern)(nodes1, 'h2 > t*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > t*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h2 > t*').valid).toBe(true);
+    });
+    it('matches plus quantifier (1 or more)', () => {
+      const nodes1 = createMockAstNodes(['h2']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t+');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t+');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > t+');
+      // nodes1 matches h2 (partial match), so valid is true but endIndex is 0
+      expect(result1.valid).toBe(false);
+      expect(result1.endIndex).toBe(0); // Only matched h2
+      expect(result2.valid).toBe(true);
+      expect(result2.endIndex).toBe(1); // Matched h2 and t
+      expect(result3.valid).toBe(true);
+      expect(result3.endIndex).toBe(2); // Matched h2, t, t
+    });
+    it('matches optional quantifier', () => {
+      const nodes1 = createMockAstNodes(['h2']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t?');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t?');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > t?');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(0); // Matched h2 (t is optional)
+      expect(result2.valid).toBe(true);
+      expect(result2.endIndex).toBe(1); // Matched h2 and t
+      // nodes3 matches h2 > t (partial match), so valid is true but endIndex is 1
+      expect(result3.valid).toBe(true);
+      expect(result3.endIndex).toBe(1); // Only matched h2 and first t
+    });
+    it('matches exact count', () => {
+      const nodes1 = createMockAstNodes(['h2', 't', 't']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t[2]');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t[2]');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > t[2]');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(2); // Matched h2, t, t
+      // nodes2 matches h2 > t (partial match), so valid is true but endIndex is 1
+      expect(result2.valid).toBe(false);
+      expect(result2.endIndex).toBe(1); // Only matched h2 and t
+      // nodes3 matches h2 > t[2] (partial match), so valid is true but endIndex is 2
+      expect(result3.valid).toBe(true);
+      expect(result3.endIndex).toBe(2); // Matched h2, t, t (third t not matched)
+    });
+    it('matches range quantifier', () => {
+      const nodes1 = createMockAstNodes(['h2', 't']);
+      const nodes2 = createMockAstNodes(['h2', 't', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't', 't']);
+      const nodes4 = createMockAstNodes(['h2']);
+      const nodes5 = createMockAstNodes(['h2', 't', 't', 't', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t[1-3]');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t[1-3]');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > t[1-3]');
+      const result4 = (0, _index.validatePattern)(nodes4, 'h2 > t[1-3]');
+      const result5 = (0, _index.validatePattern)(nodes5, 'h2 > t[1-3]');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(1); // Matched h2, t
+      expect(result2.valid).toBe(true);
+      expect(result2.endIndex).toBe(2); // Matched h2, t, t
+      expect(result3.valid).toBe(true);
+      expect(result3.endIndex).toBe(3); // Matched h2, t, t, t
+      // nodes4 matches h2 (partial match), so valid is true but endIndex is 0
+      expect(result4.valid).toBe(false);
+      expect(result4.endIndex).toBe(0); // Only matched h2
+      // nodes5 matches h2 > t[1-3] (partial match), so valid is true but endIndex is 3
+      expect(result5.valid).toBe(true);
+      expect(result5.endIndex).toBe(3); // Matched h2, t, t, t (fourth t not matched)
+    });
+    it('matches up-to quantifier', () => {
+      const nodes1 = createMockAstNodes(['h2']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 't']);
+      const nodes4 = createMockAstNodes(['h2', 't', 't', 't']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > t[-2]');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > t[-2]');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > t[-2]');
+      const result4 = (0, _index.validatePattern)(nodes4, 'h2 > t[-2]');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(0); // Matched h2
+      expect(result2.valid).toBe(true);
+      expect(result2.endIndex).toBe(1); // Matched h2, t
+      expect(result3.valid).toBe(true);
+      expect(result3.endIndex).toBe(2); // Matched h2, t, t
+      // nodes4 matches h2 > t[-2] (partial match), so valid is true but endIndex is 2
+      expect(result4.valid).toBe(true);
+      expect(result4.endIndex).toBe(2); // Matched h2, t, t (third t not matched)
+    });
+  });
+  describe('Alternation', () => {
+    it('matches simple alternation', () => {
+      const nodes1 = createMockAstNodes(['h2', 't']);
+      const nodes2 = createMockAstNodes(['h2', 'image']);
+      const nodes3 = createMockAstNodes(['h2', 'link']);
+      const result1 = (0, _index.validatePattern)(nodes1, 'h2 > (t | image)');
+      const result2 = (0, _index.validatePattern)(nodes2, 'h2 > (t | image)');
+      const result3 = (0, _index.validatePattern)(nodes3, 'h2 > (t | image)');
+      expect(result1.valid).toBe(true);
+      expect(result1.endIndex).toBe(1); // Matched h2, t
+      expect(result2.valid).toBe(true);
+      expect(result2.endIndex).toBe(1); // Matched h2, image
+      // nodes3 matches h2 (partial match), so valid is true but endIndex is 0
+      expect(result3.valid).toBe(false);
+      expect(result3.endIndex).toBe(0); // Only matched h2
+    });
+    it('matches alternation with quantifier', () => {
+      const nodes1 = createMockAstNodes(['h2']);
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 'image', 't']);
+      expect((0, _index.validatePattern)(nodes1, 'h2 > (t | image)*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > (t | image)*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h2 > (t | image)*').valid).toBe(true);
+    });
+  });
+  describe('Groups', () => {
+    it('matches group with quantifier', () => {
+      const nodes1 = [];
+      const nodes2 = createMockAstNodes(['h2', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't', 'h2', 't']);
+      const nodes4 = createMockAstNodes(['h2']);
+      const result1 = (0, _index.validatePattern)(nodes1, '(h2 > t)*');
+      const result2 = (0, _index.validatePattern)(nodes2, '(h2 > t)*');
+      const result3 = (0, _index.validatePattern)(nodes3, '(h2 > t)*');
+      const result4 = (0, _index.validatePattern)(nodes4, '(h2 > t)*');
+      const result5 = (0, _index.validatePattern)(nodes1, '(h2 > t)+');
+      const result6 = (0, _index.validatePattern)(nodes2, '(h2 > t)+');
+      expect(result1.valid).toBe(true); // 0 repetitions
+      expect(result1.endIndex).toBe(-1); // No match
+      expect(result2.valid).toBe(true); // 1 repetition
+      expect(result2.endIndex).toBe(1); // Matched h2, t
+      expect(result3.valid).toBe(true); // 2 repetitions
+      expect(result3.endIndex).toBe(3); // Matched h2, t, h2, t
+      // nodes4 matches h2 (partial match), so valid is true but endIndex is 0
+      expect(result4.valid).toBe(false); // partial match
+      expect(result4.endIndex).toBe(0); // Matched h2
+      // nodes1 with + requires at least 1, empty array doesn't match, so valid is false
+      expect(result5.valid).toBe(false); // no match (empty array with + quantifier)
+      expect(result5.endIndex).toBe(-1); // No match
+      expect(result6.valid).toBe(true); // exactly 1
+      expect(result6.endIndex).toBe(1); // Matched h2, t
+    });
+  });
+  describe('ThematicBreak', () => {
+    it('matches single thematicBreak', () => {
+      const nodes = createMockAstNodes(['thematicBreak']);
+      const result = (0, _index.validatePattern)(nodes, 'thematicBreak');
+      expect(result.valid).toBe(true);
+      expect(result.endIndex).toBe(0);
+    });
+    it('matches thematicBreak with quantifiers', () => {
+      const nodes1 = createMockAstNodes(['h1', 'thematicBreak']);
+      const nodes2 = createMockAstNodes(['h1', 'thematicBreak', 'thematicBreak']);
+      const nodes3 = createMockAstNodes(['h1']);
+
+      // Optional thematicBreak
+      expect((0, _index.validatePattern)(nodes1, 'h1 > thematicBreak?').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h1 > thematicBreak?').valid).toBe(true);
+
+      // One or more thematicBreak
+      expect((0, _index.validatePattern)(nodes1, 'h1 > thematicBreak+').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h1 > thematicBreak+').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h1 > thematicBreak+').valid).toBe(false);
+
+      // Zero or more thematicBreak
+      expect((0, _index.validatePattern)(nodes1, 'h1 > thematicBreak*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h1 > thematicBreak*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h1 > thematicBreak*').valid).toBe(true);
+    });
+    it('matches thematicBreak in sequences', () => {
+      const nodes1 = createMockAstNodes(['h1', 'thematicBreak', 't']);
+      const nodes2 = createMockAstNodes(['h2', 'thematicBreak', 't', 'link']);
+      expect((0, _index.validatePattern)(nodes1, 'h1 > thematicBreak > t').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > thematicBreak > t > link').valid).toBe(true);
+    });
+    it('matches thematicBreak in alternation', () => {
+      const nodes1 = createMockAstNodes(['h2', 'thematicBreak', 't']);
+      const nodes2 = createMockAstNodes(['h2', 'callout', 't']);
+      const nodes3 = createMockAstNodes(['h2', 't']);
+      expect((0, _index.validatePattern)(nodes1, 'h2 > (thematicBreak | callout) > t').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > (thematicBreak | callout) > t').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'h2 > (thematicBreak | callout) > t').valid).toBe(false);
+    });
+    it('validates thematicBreak pattern syntax', () => {
+      expect((0, _index.validatePatternSyntax)('thematicBreak').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('h1 > thematicBreak').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('thematicBreak+').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('thematicBreak?').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('thematicBreak*').valid).toBe(true);
+    });
+  });
+  describe('Complex patterns', () => {
+    it('matches nested patterns', () => {
+      const nodes1 = createMockAstNodes(['h2', 'link', 'image']);
+      const nodes2 = createMockAstNodes(['h2', 'link', 'image', 'link', 'image']);
+      expect((0, _index.validatePattern)(nodes1, 'h2 > (link > image)*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > (link > image)*').valid).toBe(true);
+    });
+    it('matches multiple quantifiers', () => {
+      const nodes1 = createMockAstNodes(['h2', 't', 't', 'link']);
+      const nodes2 = createMockAstNodes(['h2', 't', 't', 'link', 'link']);
+      expect((0, _index.validatePattern)(nodes1, 'h2 > t+ > link*').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'h2 > t+ > link*').valid).toBe(true);
+    });
+  });
+  describe('Lists', () => {
+    it('matches simple list', () => {
+      const nodes = createMockAstNodes(['list{[t], [t]}']);
+      expect((0, _index.validatePattern)(nodes, 'list').valid).toBe(true);
+    });
+    it('validates list item count', () => {
+      // list{item[-2]:...} means up to 2 items
+      const nodes1 = createMockAstNodes(['list{[t]}']);
+      const nodes2 = createMockAstNodes(['list{[t], [t]}']);
+      const nodes3 = createMockAstNodes(['list{[t], [t], [t]}']);
+      expect((0, _index.validatePattern)(nodes1, 'list{item[-2]:t}').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes2, 'list{item[-2]:t}').valid).toBe(true);
+      expect((0, _index.validatePattern)(nodes3, 'list{item[-2]:t}').valid).toBe(false);
+    });
+    it('validates list item structure', () => {
+      // Each item should have: t > image > t+ > link*
+      const pattern = 'list{item[-2]:t > image > t+ > link*}';
+
+      // Valid: 1 item with t, image, t
+      const nodes1 = createMockAstNodes(['list{[t, image, t]}']);
+      expect((0, _index.validatePattern)(nodes1, pattern).valid).toBe(true);
+
+      // Valid: 1 item with t, image, t, t (multiple t's with t+)
+      const nodes2 = createMockAstNodes(['list{[t, image, t, t]}']);
+      expect((0, _index.validatePattern)(nodes2, pattern).valid).toBe(true);
+
+      // Valid: 1 item with t, image, t, link
+      const nodes3 = createMockAstNodes(['list{[t, image, t, link]}']);
+      expect((0, _index.validatePattern)(nodes3, pattern).valid).toBe(true);
+
+      // Valid: 2 items
+      const nodes4 = createMockAstNodes(['list{[t, image, t], [t, image, t, t, link]}']);
+      expect((0, _index.validatePattern)(nodes4, pattern).valid).toBe(true);
+
+      // Invalid: missing image
+      const nodes5 = createMockAstNodes(['list{[t, t]}']);
+      expect((0, _index.validatePattern)(nodes5, pattern).valid).toBe(false);
+
+      // Invalid: wrong order
+      const nodes6 = createMockAstNodes(['list{[image, t, t]}']);
+      expect((0, _index.validatePattern)(nodes6, pattern).valid).toBe(false);
+    });
+    it('validates complex pattern with list', () => {
+      const pattern = 'h2 > (link > image > t > list{item[-2]:t > image > t+ > link*})*';
+
+      // h2 alone (0 repetitions of group)
+      const nodes1 = createMockAstNodes(['h2']);
+      expect((0, _index.validatePattern)(nodes1, pattern).valid).toBe(true);
+
+      // h2 > link > image > t > list with valid items
+      const nodes2 = createMockAstNodes(['h2', 'link', 'image', 't', 'list{[t, image, t, link]}']);
+      expect((0, _index.validatePattern)(nodes2, pattern).valid).toBe(true);
+    });
+    it('validates real-world complex pattern from user', () => {
+      const blocks = ['h2',
+      // 1
+      'link',
+      // 2
+      't',
+      // 3
+      'link',
+      // 4
+      't',
+      // 5
+      'link',
+      // 6
+      't',
+      // 7
+      'link',
+      // 8
+      'html_comment',
+      // 9
+      'link',
+      // 10
+      'image',
+      // 11
+      't',
+      // 12
+      'list{[t, t]}',
+      // 13 - list with 1 item containing ['t', 't']
+      'html_comment',
+      // 14
+      'link',
+      // 15
+      'image',
+      // 16
+      't',
+      // 17
+      'list{[t, t]}' // 18 - list with 1 item containing ['t', 't']
+      ];
+      const nodes = createMockAstNodes(blocks);
+
+      // Pattern breakdown:
+      // h2 -> matches position 1
+      // (link > t)* -> matches positions 2-7 (3 repetitions: 2-3, 4-5, 6-7)
+      // link -> matches position 8
+      // (html_comment > link > image > t > list{item[1]:t > t})* -> matches 9-18 (2 repetitions)
+      //   First repetition: 9-13
+      //   Second repetition: 14-18
+      //
+      // list{[t, t]} means: 1 item with elements ['t', 't']
+
+      // Now with proper implementation, we can use quantifiers on groups with lists!
+      const properPattern = 'h2 > (link > t)* > link > (html_comment > link > image > t > list)*';
+      expect((0, _index.validatePattern)(nodes, properPattern).valid).toBe(true);
+
+      // Also test with item structure validation
+      const patternWithItemValidation = 'h2 > (link > t)* > link > (html_comment > link > image > t > list{item[1]:t > t})*';
+      expect((0, _index.validatePattern)(nodes, patternWithItemValidation).valid).toBe(true);
+    });
+
+    // TDD Tests for proper list validation implementation
+    describe('Advanced list validation (TDD)', () => {
+      it('Test 1: validates list in simple repetitive pattern', () => {
+        const blocks = ['t', 'list{[t]}', 't', 'list{[t]}', 't', 'list{[t]}'];
+        const nodes = createMockAstNodes(blocks);
+
+        // Pattern: t > list repeated 3 times
+        const pattern = '(t > list)*';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Test 2: validates list in complex group repetition', () => {
+        const blocks = ['h2', 'html_comment', 'link', 'list{[t]}', 'html_comment', 'link', 'list{[t]}'];
+        const nodes = createMockAstNodes(blocks);
+
+        // Pattern: h2 followed by repeated groups
+        const pattern = 'h2 > (html_comment > link > list)*';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Test 3: validates list with simple item structure', () => {
+        const nodes1 = createMockAstNodes(['list{[t, t]}']);
+        const nodes2 = createMockAstNodes(['list{[t]}']);
+
+        // Pattern: list with 1 item containing 2 't' elements in sequence
+        const pattern = 'list{item[1]:t > t}';
+        const result1 = (0, _index.validatePattern)(nodes1, pattern);
+        const result2 = (0, _index.validatePattern)(nodes2, pattern);
+        expect(result1.valid).toBe(true);
+        expect(result1.endIndex).toBe(0); // Matched the list
+
+        // nodes2 has list{[t]} but pattern expects list{item[1]:t > t} (1 item with 2 t's)
+        // The list structure doesn't match (only 1 t instead of 2), so it should fail
+        expect(result2.valid).toBe(false); // Structure doesn't match
+        expect(result2.endIndex).toBe(-1); // No match
+      });
+      it('Test 4: validates list with complex item structure using quantifiers', () => {
+        const nodes1 = createMockAstNodes(['list{[t, t, t, link, link]}']);
+        const nodes2 = createMockAstNodes(['list{[t, t, link]}']);
+        const nodes3 = createMockAstNodes(['list{[link, link]}']);
+
+        // Pattern: list with 1 item containing 1+ t's followed by exactly 2 links
+        // link[2] should expand to link > link
+        const pattern = 'list{item[1]:t+ > link[2]}';
+        expect((0, _index.validatePattern)(nodes1, pattern).valid).toBe(true);
+
+        // Should fail with wrong number of links
+        expect((0, _index.validatePattern)(nodes2, pattern).valid).toBe(false);
+
+        // Should fail with no t at start
+        expect((0, _index.validatePattern)(nodes3, pattern).valid).toBe(false);
+      });
+      it('Test 5: validates list with variable item counts and quantifiers', () => {
+        // Test data has 2 lists:
+        // 1st list: 1 item with 2 't' elements
+        // 2nd list: 3 items, each with 2 't' elements
+        const blocks = ['h2', 'link', 't', 'link', 't', 'link', 't', 'link', 'html_comment', 'link', 'image', 't', 'list{[t, t]}',
+        // 1 item: ['t', 't']
+        'html_comment', 'link', 'image', 't', 'list{[t, t], [t, t], [t, t]}' // 3 items: ['t', 't'], ['t', 't'], ['t', 't']
+        ];
+        const nodes = createMockAstNodes(blocks);
+
+        // Pattern: list with 1+ items, each item has 1+ 't' elements
+        // Use + quantifier for "1 or more"
+        const pattern = 'h2 > (link > t)* > link > (html_comment > link > image > t > list{item+:t+})*';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+
+        // Should also work with explicit range [1-] for "1 or more"
+        const patternWithRange = 'h2 > (link > t)* > link > (html_comment > link > image > t > list{item[1-]:t+})*';
+        expect((0, _index.validatePattern)(nodes, patternWithRange).valid).toBe(true);
+      });
+    });
+    describe('Super Complex Patterns (8 Advanced Cases)', () => {
+      it('Complex 1: Multiple lists with wildcards', () => {
+        // Real-world: Product specifications with flexible structure
+        const blocks = ['h2', 'list{[t, t, link]}', 'list{[t, link, link, link]}', 'list{[t]}'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h2 > list{item+:t+ > link*}+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 2: Deeply nested groups with quantifiers', () => {
+        // Real-world: Blog post with multiple paragraphs, each with optional formatting
+        const blocks = ['h2', 't', 'link', 't', 't', 'image', 't', 't', 'link', 't'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h2 > (t > (link | image) > t)+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 3: Lists with complex quantified item structures', () => {
+        // Real-world: Feature comparison table with variable columns
+        const blocks = ['h3', 'list{[t, t, t, link, link, image]}', 'list{[t, link, image], [t, t, link, link]}', 'list{[t, image]}'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h3 > list{item+:t+ > link* > image?}+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 4: Alternation with lists', () => {
+        // Real-world: Flexible content sections
+        const blocks = ['h2', 't', 'list{[t, t]}', 'list{[t, link, link]}'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h2 > t > list{item+:t+ > link*}+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 5: Optional groups with mandatory list validation', () => {
+        // Real-world: Product page with optional gallery but required specs
+        const blocks = ['h1', 't', 'image', 'image', 'image', 'h2', 'list{[t, t, link]}', 'list{[t, link], [t, t, link]}'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h1 > t > image* > h2 > list{item+:t+ > link}+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 6: Optional elements throughout', () => {
+        // Real-world: Blog post with optional media
+        const blocks = ['h1', 't', 'image', 'list{[t, link]}', 'callout', 'link'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h1 > t > image? > list{item+:t+ > link*} > callout? > link?';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 7: Complex alternation with exact quantifiers', () => {
+        // Real-world: Structured data with specific format requirements
+        const blocks = ['h3', 'link', 'link', 'link', 't', 't', 'image', 'list{[t, link]}', 'list{[t, link, link]}', 'callout'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h3 > link[3] > t[2] > image > list{item+:t > link*}+ > callout';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 8: Nested alternation in list items', () => {
+        // Real-world: Flexible content blocks in CMS
+        const blocks = ['h2', 'list{[t, link], [image, t], [link, image, t]}', 'list{[t], [link, link], [image]}'];
+        const nodes = createMockAstNodes(blocks);
+        const pattern = 'h2 > list{item[1-5]:(t | image | link)+}+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('Complex 9: Nested list with quantifiers', () => {
+        const blocks = ['h1', 't', 'h2', 't', 't', 't', 'image', 'image', 'list{[t], [t]}', 'h2', 't', 't', 't', 'image', 'image', 'list{[t], [t]}'];
+        const nodes = createMockAstNodes(blocks);
+
+        // Test with error details to debug
+        const pattern = 'h1 > t? > (h2 > t+ > image[2] > list{item+:t})[1-3]';
+        const result = (0, _index.validatePattern)(nodes, pattern);
+        if (!result.valid) {
+          console.log('Complex 9 Error:', result.error);
+        }
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+    });
+    describe('Error Messages', () => {
+      it('provides detailed error for wrong item count', () => {
+        const nodes = createMockAstNodes(['h2', 'list{[t], [t], [t]}']);
+        const pattern = 'h2 > list{item[2]:t}';
+        const result = (0, _index.validatePattern)(nodes, pattern);
+        // With new behavior, partial matches are valid, but we still get error messages
+        expect(result.valid).toBe(false);
+        expect(result.endIndex).toBe(0); // Matched h2
+        // Error message should indicate wrong item count
+        if (result.error) {
+          expect(result.error).toContain('Expected exactly 2 items');
+          expect(result.error).toContain('got 3 items');
+        }
+      });
+      it('provides detailed error for item structure mismatch', () => {
+        const nodes = createMockAstNodes(['h2', 'list{[t, link, link]}']);
+        const pattern = 'h2 > list{item[1]:t > link}'; // Expects exactly 2 elements but got 3
+
+        const result = (0, _index.validatePattern)(nodes, pattern);
+        // With new behavior, partial matches are valid, but we still get an error message
+        // The pattern matches h2 (partial match), so valid is true, but error indicates structure mismatch
+        expect(result.valid).toBe(false); // Partial match is valid
+        // Error message should indicate structure mismatch
+        if (result.error) {
+          expect(result.error).toContain('Item #1');
+          expect(result.error).toContain('does not match');
+        }
+      });
+      it('provides detailed error for unexpected element', () => {
+        const nodes = createMockAstNodes(['h2', 'image', 't']);
+        const pattern = 'h2 > t > link';
+        const result = (0, _index.validatePattern)(nodes, pattern);
+        // With new behavior, partial matches are valid, but we still get an error message
+        // The pattern matches h2 (partial match), so valid is true, but error indicates unexpected element
+        expect(result.valid).toBe(false); // Partial match is valid
+        expect(result.endIndex).toBe(0); // Matched up to index 0 (h2)
+        // Error message should indicate unexpected element
+        if (result.error) {
+          expect(result.error).toContain('Unexpected element');
+          expect(result.error).toContain('image');
+          expect(result.error).toContain('position 2');
+        }
+      });
+      it('provides detailed error for incomplete pattern', () => {
+        const nodes = createMockAstNodes(['h2', 't']);
+        const pattern = 'h2 > t > link > image';
+        const result = (0, _index.validatePattern)(nodes, pattern);
+        // With new behavior, partial matches are valid, but we still get an error message
+        // The pattern matches h2 > t (partial match), so valid is true, but error indicates incomplete
+        expect(result.valid).toBe(false); // Partial match is valid
+        expect(result.endIndex).toBe(1); // Matched up to index 1 (h2, t)
+        // Error message should indicate incomplete pattern
+        if (result.error) {
+          expect(result.error).toContain('incomplete');
+          expect(result.error).toContain('Expected more elements');
+        }
+      });
+    });
+  });
+  describe('Entity Link Patterns', () => {
+    describe('Pattern Syntax Validation', () => {
+      it('validates link attribute selector syntax', () => {
+        // Basic attribute selectors
+        expect((0, _index.validatePatternSyntax)('link[entityType]').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"]').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[protocol="entity"]').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityId="abc123"]').valid).toBe(true);
+      });
+      it('validates link attribute operators', () => {
+        // Contains operator
+        expect((0, _index.validatePatternSyntax)('link[entityType*="post"]').valid).toBe(true);
+        // Starts with operator
+        expect((0, _index.validatePatternSyntax)('link[entityType^="blog"]').valid).toBe(true);
+        // Ends with operator
+        expect((0, _index.validatePatternSyntax)('link[entityId$="123"]').valid).toBe(true);
+      });
+      it('validates multiple link attributes', () => {
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"][entityId]').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[protocol="entity"][entityType="product"]').valid).toBe(true);
+      });
+      it('validates link attributes with quantifiers', () => {
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"]?').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"]*').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"]+').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"][2]').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[entityType="blog_post"][1-3]').valid).toBe(true);
+      });
+      it('validates link attributes in sequences', () => {
+        expect((0, _index.validatePatternSyntax)('h2 > link[entityType="blog_post"] > t').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('link[protocol="entity"] > image > t').valid).toBe(true);
+      });
+      it('validates link attributes in groups and alternation', () => {
+        expect((0, _index.validatePatternSyntax)('(link[entityType="blog_post"] | link[entityType="product"])').valid).toBe(true);
+        expect((0, _index.validatePatternSyntax)('(t > link[entityType])+').valid).toBe(true);
+      });
+    });
+    describe('Entity Link Matching', () => {
+      it('matches entity link with exact entityType', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType="blog_post"] > t');
+        expect(result.valid).toBe(true);
+        expect(result.endIndex).toBe(1);
+      });
+      it('does not match entity link with different entityType', () => {
+        const nodes = createMockAstNodes(['entity_link:product:xyz789', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType="blog_post"] > t');
+        expect(result.valid).toBe(false);
+      });
+      it('matches entity link with entityType exists check', () => {
+        const nodes = createMockAstNodes(['entity_link:any_type:any_id', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('does not match http link when entityType is required', () => {
+        const nodes = createMockAstNodes(['http_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType] > t');
+        expect(result.valid).toBe(false);
+      });
+      it('matches entity link with exact entityId', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityId="abc123"] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('matches entity link with protocol="web5"', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="web5"] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('does not match entity link when http protocol is required', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="http"] > t');
+        expect(result.valid).toBe(false);
+      });
+      it('matches http link with protocol="http"', () => {
+        const nodes = createMockAstNodes(['http_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="http"] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('matches https link with protocol="https"', () => {
+        const nodes = createMockAstNodes(['https_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="https"] > t');
+        expect(result.valid).toBe(true);
+      });
+    });
+    describe('Entity Link Attribute Operators', () => {
+      it('matches entityType containing substring (*=)', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType*="blog"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType*="post"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType*="log_po"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType*="product"] > t').valid).toBe(false);
+      });
+      it('matches entityType starting with prefix (^=)', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType^="blog"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType^="blog_"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType^="post"] > t').valid).toBe(false);
+      });
+      it('matches entityType ending with suffix ($=)', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType$="post"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType$="_post"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityType$="blog"] > t').valid).toBe(false);
+      });
+      it('matches entityId ending with suffix ($=)', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:post123', 't']);
+        expect((0, _index.validatePattern)(nodes, 'link[entityId$="123"] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link[entityId$="789"] > t').valid).toBe(false);
+      });
+    });
+    describe('Multiple Link Attributes', () => {
+      it('matches with both entityType and entityId', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType="blog_post"][entityId="abc123"] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('does not match if one attribute fails', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType="blog_post"][entityId="xyz789"] > t');
+        expect(result.valid).toBe(false);
+      });
+      it('matches with protocol and entityType', () => {
+        const nodes = createMockAstNodes(['entity_link:product:xyz789', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="web5"][entityType="product"] > t');
+        expect(result.valid).toBe(true);
+      });
+    });
+    describe('Optional Entity Links', () => {
+      it('matches pattern without link when optional', () => {
+        const nodes = createMockAstNodes(['h2', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'h2 > link[entityType="blog_post"]? > t');
+        expect(result.valid).toBe(true);
+        expect(result.endIndex).toBe(1);
+      });
+      it('matches pattern with matching link when optional', () => {
+        const nodes = createMockAstNodes(['h2', 'entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'h2 > link[entityType="blog_post"]? > t');
+        expect(result.valid).toBe(true);
+        expect(result.endIndex).toBe(2);
+      });
+      it('skips non-matching optional entity link', () => {
+        // When optional entity link doesn't match, pattern should try to match without it
+        const nodes = createMockAstNodes(['h2', 'http_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'h2 > link[entityType="blog_post"]? > link > t');
+        expect(result.valid).toBe(true);
+      });
+    });
+    describe('Entity Links with Quantifiers', () => {
+      it('matches zero or more entity links (*)', () => {
+        const nodes1 = createMockAstNodes(['h2', 't']);
+        const nodes2 = createMockAstNodes(['h2', 'entity_link:blog_post:1', 't']);
+        const nodes3 = createMockAstNodes(['h2', 'entity_link:blog_post:1', 'entity_link:blog_post:2', 't']);
+        expect((0, _index.validatePattern)(nodes1, 'h2 > link[entityType="blog_post"]* > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes2, 'h2 > link[entityType="blog_post"]* > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes3, 'h2 > link[entityType="blog_post"]* > t').valid).toBe(true);
+      });
+      it('matches one or more entity links (+)', () => {
+        const nodes1 = createMockAstNodes(['h2', 't']);
+        const nodes2 = createMockAstNodes(['h2', 'entity_link:blog_post:1', 't']);
+        const nodes3 = createMockAstNodes(['h2', 'entity_link:blog_post:1', 'entity_link:blog_post:2', 't']);
+        expect((0, _index.validatePattern)(nodes1, 'h2 > link[entityType="blog_post"]+ > t').valid).toBe(false);
+        expect((0, _index.validatePattern)(nodes2, 'h2 > link[entityType="blog_post"]+ > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes3, 'h2 > link[entityType="blog_post"]+ > t').valid).toBe(true);
+      });
+      it('matches exact count of entity links ([N])', () => {
+        const nodes = createMockAstNodes(['h2', 'entity_link:blog_post:1', 'entity_link:blog_post:2', 't']);
+        expect((0, _index.validatePattern)(nodes, 'h2 > link[entityType="blog_post"][2] > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'h2 > link[entityType="blog_post"][3] > t').valid).toBe(false);
+      });
+    });
+    describe('Backward Compatibility', () => {
+      it('plain link matches entity links', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link > t');
+        expect(result.valid).toBe(true);
+      });
+      it('plain link matches http links', () => {
+        const nodes = createMockAstNodes(['http_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link > t');
+        expect(result.valid).toBe(true);
+      });
+      it('plain link with quantifiers works as before', () => {
+        const nodes = createMockAstNodes(['link', 'link', 't']);
+        expect((0, _index.validatePattern)(nodes, 'link+ > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link* > t').valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes, 'link? > link > t').valid).toBe(true);
+      });
+    });
+    describe('Complex Entity Link Patterns', () => {
+      it('matches mixed entity and regular links in sequence', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:abc123', 't', 'http_link', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'link[protocol="web5"] > t > link[protocol="http"] > t');
+        expect(result.valid).toBe(true);
+      });
+      it('matches entity links in alternation', () => {
+        const nodes1 = createMockAstNodes(['h2', 'entity_link:blog_post:1', 't']);
+        const nodes2 = createMockAstNodes(['h2', 'entity_link:product:1', 't']);
+        const pattern = 'h2 > (link[entityType="blog_post"] | link[entityType="product"]) > t';
+        expect((0, _index.validatePattern)(nodes1, pattern).valid).toBe(true);
+        expect((0, _index.validatePattern)(nodes2, pattern).valid).toBe(true);
+      });
+      it('matches entity links in groups with quantifiers', () => {
+        const nodes = createMockAstNodes(['h2', 'entity_link:blog_post:1', 't', 'entity_link:blog_post:2', 't']);
+        const result = (0, _index.validatePattern)(nodes, 'h2 > (link[entityType="blog_post"] > t)+');
+        expect(result.valid).toBe(true);
+        expect(result.endIndex).toBe(4);
+      });
+      it('matches real-world blog post pattern with entity links', () => {
+        const nodes = createMockAstNodes(['h2', 't', 'entity_link:blog_post:123', 'image', 't', 'entity_link:blog_post:456', 'image', 't']);
+        const pattern = 'h2 > t > (link[entityType="blog_post"] > image > t)+';
+        expect((0, _index.validatePattern)(nodes, pattern).valid).toBe(true);
+      });
+      it('matches pattern with entity type prefix matching', () => {
+        const nodes = createMockAstNodes(['entity_link:blog_post:1', 'entity_link:blog_article:2', 't']);
+        // Match any link where entityType starts with "blog"
+        const result = (0, _index.validatePattern)(nodes, 'link[entityType^="blog"]+ > t');
+        expect(result.valid).toBe(true);
+      });
+    });
+    describe('Image Attribute Selectors', () => {
+      describe('Pattern Syntax Validation', () => {
+        it('validates image attribute selector syntax', () => {
+          expect((0, _index.validatePatternSyntax)('image[type]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[type="icon"]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[src]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[alt="money"]').valid).toBe(true);
+        });
+        it('validates image attribute operators', () => {
+          expect((0, _index.validatePatternSyntax)('image[src*="web5"]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[src^="web5://"]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[alt$="icon"]').valid).toBe(true);
+        });
+        it('validates multiple image attributes', () => {
+          expect((0, _index.validatePatternSyntax)('image[type="icon"][alt]').valid).toBe(true);
+        });
+        it('validates image attributes with quantifiers', () => {
+          expect((0, _index.validatePatternSyntax)('image[type="icon"]?').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[type="icon"]*').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[type="icon"]+').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[type="icon"][2]').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('image[type="icon"][1-3]').valid).toBe(true);
+        });
+        it('validates image attributes in sequences', () => {
+          expect((0, _index.validatePatternSyntax)('h2 > image[type="icon"] > t').valid).toBe(true);
+        });
+        it('validates image attributes in groups and alternation', () => {
+          expect((0, _index.validatePatternSyntax)('(image[type="icon"] | image[type="illustration"])').valid).toBe(true);
+          expect((0, _index.validatePatternSyntax)('(t > image[type="icon"])+').valid).toBe(true);
+        });
+        it('validates image attributes in list item patterns', () => {
+          expect((0, _index.validatePatternSyntax)('h2 > list{item[2-]:(image[type="icon"] | h3 | t | link)* > t+}').valid).toBe(true);
+        });
+      });
+      describe('Image Attribute Matching', () => {
+        it('matches web5 illustration with type="illustration"', () => {
+          const nodes = createMockAstNodes(['web5_image:illustration:chart', 't']);
+          const result = (0, _index.validatePattern)(nodes, 'image[type="illustration"] > t');
+          expect(result.valid).toBe(true);
+        });
+        it('does not match regular image when type is required', () => {
+          const nodes = createMockAstNodes(['image', 't']);
+          const result = (0, _index.validatePattern)(nodes, 'image[type] > t');
+          expect(result.valid).toBe(false);
+        });
+        it('does not match regular image with src starts-with web5://', () => {
+          const nodes = createMockAstNodes(['image', 't']);
+          const result = (0, _index.validatePattern)(nodes, 'image[src^="web5://"] > t');
+          expect(result.valid).toBe(false);
+        });
+        it('plain image pattern does not match icon element', () => {
+          const iconNodes = createMockAstNodes(['web5_icon:dollar', 't']);
+          expect((0, _index.validatePattern)(iconNodes, 'image > t').valid).toBe(false);
+          const regularNodes = createMockAstNodes(['image', 't']);
+          expect((0, _index.validatePattern)(regularNodes, 'image > t').valid).toBe(true);
+        });
+      });
+      describe('Icon BlockElement Matching', () => {
+        it('matches web5 icon with icon pattern', () => {
+          const nodes = createMockAstNodes(['web5_icon:dollar', 't']);
+          const result = (0, _index.validatePattern)(nodes, 'icon > t');
+          expect(result.valid).toBe(true);
+        });
+        it('does not match regular image with icon pattern', () => {
+          const nodes = createMockAstNodes(['image', 't']);
+          const result = (0, _index.validatePattern)(nodes, 'icon > t');
+          expect(result.valid).toBe(false);
+        });
+      });
+      describe('Icon in List Items', () => {
+        it('matches list items with icons using icon pattern', () => {
+          const nodes = createMockAstNodes(['h2', 'list{[web5_icon, t], [web5_icon, t]}']);
+          const result = (0, _index.validatePattern)(nodes, 'h2 > list{item[2-]:icon > t}');
+          expect(result.valid).toBe(true);
+        });
+        it('rejects list items with regular images when icon is required', () => {
+          const nodes = createMockAstNodes(['h2', 'list{[image, t], [image, t]}']);
+          const result = (0, _index.validatePattern)(nodes, 'h2 > list{item[2-]:icon > t}');
+          expect(result.valid).toBe(false);
+        });
+        it('matches FeatureSection9Plus pattern with icons in list items', () => {
+          const nodes = createMockAstNodes(['h2', 'list{[web5_icon, t, t], [web5_icon, t, t]}']);
+          const result = (0, _index.validatePattern)(nodes, 'h2 > list{item[2-]:(icon | h3 | t | link)* > t+}');
+          expect(result.valid).toBe(true);
+        });
+        it('matches FeatureSection9Plus pattern without icons (backward compat)', () => {
+          const nodes = createMockAstNodes(['h2', 'list{[t, t], [t, t]}']);
+          const result = (0, _index.validatePattern)(nodes, 'h2 > list{item[2-]:(icon | h3 | t | link)* > t+}');
+          expect(result.valid).toBe(true);
+        });
+        it('matches alternation of icon and text in list items', () => {
+          const nodes = createMockAstNodes(['h2', 'list{[web5_icon, t, link], [t, link]}']);
+          const result = (0, _index.validatePattern)(nodes, 'h2 > list{item[1-]:(icon | t)* > (t? > link)+}');
+          expect(result.valid).toBe(true);
+        });
+      });
+    });
+  });
+});
+describe('Stop clause (~)', () => {
+  const comment = content => ({
+    type: 'html',
+    value: `<!-- ${content} -->`
+  });
+  describe('Syntax validation', () => {
+    it('accepts a bare stop element', () => {
+      expect((0, _index.validatePatternSyntax)('html_comment > t* ~ html_comment').valid).toBe(true);
+    });
+    it('accepts a stop element with attributes', () => {
+      expect((0, _index.validatePatternSyntax)('html_comment > (t | list)* ~ html_comment[type="end"]').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ link[entityType="solution"]').valid).toBe(true);
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ image[type="icon"]').valid).toBe(true);
+    });
+    it('rejects a trailing ~ with no element', () => {
+      const result = (0, _index.validatePatternSyntax)('h2 > t* ~');
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("Expected a single element after '~'");
+    });
+    it('rejects quantifiers on the stop element', () => {
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ html_comment+').valid).toBe(false);
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ html_comment*').valid).toBe(false);
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ html_comment[2]').valid).toBe(false);
+    });
+    it('rejects groups after ~', () => {
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ (h2 | t)').valid).toBe(false);
+    });
+    it('rejects a second ~', () => {
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ html_comment ~ t').valid).toBe(false);
+    });
+    it('rejects tokens after the stop clause', () => {
+      expect((0, _index.validatePatternSyntax)('h2 > t* ~ html_comment > t').valid).toBe(false);
+    });
+  });
+  describe('Matching', () => {
+    it('stops before an attribute-matched end comment even when the loop accepts comments', () => {
+      const nodes = [comment('semantic: intro'), ...createMockAstNodes(['t', 't']), comment('type: end')];
+      const result = (0, _index.validatePattern)(nodes, 'html_comment > (t | html_comment)* ~ html_comment[type="end"]');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(2); // end comment (index 3) excluded
+    });
+    it('consumes the end comment without a stop clause (baseline greedy behavior)', () => {
+      const nodes = [comment('semantic: intro'), ...createMockAstNodes(['t', 't']), comment('type: end')];
+      const result = (0, _index.validatePattern)(nodes, 'html_comment > (t | html_comment)*');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(3);
+    });
+    it('stops before an identical end comment (candidate retry)', () => {
+      const nodes = createMockAstNodes(['html_comment', 't', 't', 'html_comment']);
+      const result = (0, _index.validatePattern)(nodes, 'html_comment > t* ~ html_comment');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(2);
+    });
+    it('matches at end-of-input when the stop marker is absent (streaming)', () => {
+      const nodes = [comment('semantic: intro'), ...createMockAstNodes(['t', 't'])];
+      const result = (0, _index.validatePattern)(nodes, 'html_comment > t* ~ html_comment[type="end"]');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(2);
+    });
+    it('fails when the marker is present but no valid prefix exists', () => {
+      const nodes = createMockAstNodes(['t', 't', 'html_comment']);
+      const result = (0, _index.validatePattern)(nodes, 'h2 > t* ~ html_comment');
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('stop marker');
+    });
+    it('does not match through a marker even if the full input would match', () => {
+      const nodes = createMockAstNodes(['html_comment', 't', 'html_comment', 't']);
+      // Without the stop clause the full input matches
+      expect((0, _index.validatePattern)(nodes, 'html_comment > t > html_comment > t').valid).toBe(true);
+      const result = (0, _index.validatePattern)(nodes, 'html_comment > t > html_comment > t ~ html_comment');
+      expect(result.valid).toBe(false);
+    });
+    it('fails when the only marker is at the start (empty prefix)', () => {
+      const nodes = createMockAstNodes(['html_comment', 't']);
+      const result = (0, _index.validatePattern)(nodes, 't ~ html_comment');
+      expect(result.valid).toBe(false);
+    });
+    it('keeps extra-elements-before-marker semantics', () => {
+      const nodes = createMockAstNodes(['h2', 't', 't', 'html_comment']);
+      const result = (0, _index.validatePattern)(nodes, 'h2 > t ~ html_comment');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(1); // second t is extra, marker untouched
+    });
+    it('supports stopping at non-comment elements', () => {
+      const nodes = createMockAstNodes(['h2', 't', 't', 'h2', 't']);
+      const result = (0, _index.validatePattern)(nodes, 'h2 > t+ ~ h2');
+      expect(result.valid).toBe(true);
+      expect(result.astEndIndex).toBe(2);
+    });
+  });
+});
+//# sourceMappingURL=validator.test.js.map