@startsimpli/funnels 0.4.6 → 0.4.8

package/src/core/engine.test.ts

@@ -116,20 +116,20 @@ describe('FunnelEngine - Empty Funnel', () => {
       id: 'funnel-1',
       name: 'Empty Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_input).toBe(3);
-    expect(result.total_matched).toBe(3); // No exclusions
-    expect(result.total_excluded).toBe(0);
+    expect(result.totalInput).toBe(3);
+    expect(result.totalMatched).toBe(3); // No exclusions
+    expect(result.totalExcluded).toBe(0);
     expect(result.matched.length).toBe(3);
     expect(result.excluded.length).toBe(0);
-    expect(Object.keys(result.stage_stats).length).toBe(0);
+    expect(Object.keys(result.stageStats).length).toBe(0);
   });
 
   it('should handle empty entity array', () => {
@@ -139,27 +139,27 @@ describe('FunnelEngine - Empty Funnel', () => {
       id: 'funnel-1',
       name: 'Test Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Filter Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, []);
 
-    expect(result.total_input).toBe(0);
-    expect(result.total_matched).toBe(0);
-    expect(result.total_excluded).toBe(0);
+    expect(result.totalInput).toBe(0);
+    expect(result.totalMatched).toBe(0);
+    expect(result.totalExcluded).toBe(0);
   });
 });
 
@@ -176,31 +176,31 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Single Stage Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Pass All',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [], // No rules = always match
-          match_action: 'continue',
-          no_match_action: 'exclude',
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(3);
-    expect(result.stage_stats['stage-1'].input_count).toBe(3);
-    expect(result.stage_stats['stage-1'].matched_count).toBe(3);
-    expect(result.stage_stats['stage-1'].not_matched_count).toBe(0);
+    expect(result.totalMatched).toBe(3);
+    expect(result.stageStats['stage-1'].inputCount).toBe(3);
+    expect(result.stageStats['stage-1'].matchedCount).toBe(3);
+    expect(result.stageStats['stage-1'].notMatchedCount).toBe(0);
   });
 
-  it('should apply match_action: output (stop processing)', () => {
+  it('should apply matchAction: output (stop processing)', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -208,30 +208,30 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Output Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Output All',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output', // Stop processing
-          no_match_action: 'exclude',
+          matchAction: 'output', // Stop processing
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(3);
-    expect(result.matched.every(r => r.stage_results?.length === 1)).toBe(true);
-    expect(result.matched.every(r => r.stage_results![0].continued === false)).toBe(true);
+    expect(result.totalMatched).toBe(3);
+    expect(result.matched.every(r => r.stageResults?.length === 1)).toBe(true);
+    expect(result.matched.every(r => r.stageResults![0].continued === false)).toBe(true);
   });
 
-  it('should apply match_action: tag (add tags and exclude)', () => {
+  it('should apply matchAction: tag (add tags and exclude)', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -239,31 +239,31 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Tag Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Tag All',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'tag',
-          no_match_action: 'exclude',
-          match_tags: ['qualified'],
+          matchAction: 'tag',
+          noMatchAction: 'exclude',
+          matchTags: ['qualified'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    // Entities are tagged but excluded (match_action: tag stops processing)
-    expect(result.total_excluded).toBe(3);
-    expect(result.excluded.every(r => r.accumulated_tags.includes('qualified'))).toBe(true);
+    // Entities are tagged but excluded (matchAction: tag stops processing)
+    expect(result.totalExcluded).toBe(3);
+    expect(result.excluded.every(r => r.accumulatedTags.includes('qualified'))).toBe(true);
   });
 
-  it('should apply match_action: tag_continue (add tags and continue)', () => {
+  it('should apply matchAction: tag_continue (add tags and continue)', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -271,31 +271,31 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Tag Continue Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Tag and Continue',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'tag_continue',
-          no_match_action: 'exclude',
-          match_tags: ['processed'],
+          matchAction: 'tag_continue',
+          noMatchAction: 'exclude',
+          matchTags: ['processed'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(3);
-    expect(result.matched.every(r => r.accumulated_tags.includes('processed'))).toBe(true);
-    expect(result.matched.every(r => r.stage_results![0].continued === true)).toBe(true);
+    expect(result.totalMatched).toBe(3);
+    expect(result.matched.every(r => r.accumulatedTags.includes('processed'))).toBe(true);
+    expect(result.matched.every(r => r.stageResults![0].continued === true)).toBe(true);
   });
 
-  it('should apply no_match_action: exclude', () => {
+  it('should apply noMatchAction: exclude', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -303,30 +303,30 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Exclude Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Never Match',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          custom_evaluator: () => false, // Always false
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          customEvaluator: () => false, // Always false
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_excluded).toBe(3);
-    expect(result.excluded.every(r => r.excluded_at_stage === 'stage-1')).toBe(true);
+    expect(result.totalExcluded).toBe(3);
+    expect(result.excluded.every(r => r.excludedAtStage === 'stage-1')).toBe(true);
   });
 
-  it('should apply no_match_action: tag_exclude', () => {
+  it('should apply noMatchAction: tag_exclude', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -334,31 +334,31 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Tag Exclude Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Tag on No Match',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'tag_exclude',
-          no_match_tags: ['rejected'],
-          custom_evaluator: () => false,
+          matchAction: 'continue',
+          noMatchAction: 'tag_exclude',
+          noMatchTags: ['rejected'],
+          customEvaluator: () => false,
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_excluded).toBe(3);
-    expect(result.excluded.every(r => r.accumulated_tags.includes('rejected'))).toBe(true);
+    expect(result.totalExcluded).toBe(3);
+    expect(result.excluded.every(r => r.accumulatedTags.includes('rejected'))).toBe(true);
   });
 
-  it('should add match_context when rules match', () => {
+  it('should add matchContext when rules match', () => {
     const engine = new FunnelEngine<MockInvestor>();
     const entities = createMockInvestors();
 
@@ -366,21 +366,21 @@ describe('FunnelEngine - Single Stage', () => {
       id: 'funnel-1',
       name: 'Context Stage',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Add Context',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_context: { tier: 'premium', score: 100 },
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchContext: { tier: 'premium', score: 100 },
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
@@ -403,51 +403,51 @@ describe('FunnelEngine - Multi-Stage', () => {
       id: 'funnel-1',
       name: 'Multi-Stage Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Stage 1',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['stage-1'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['stage-1'],
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Stage 2',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['stage-2'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['stage-2'],
         },
         {
           id: 'stage-3',
           order: 2,
           name: 'Stage 3',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          match_tags: ['stage-3'],
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          matchTags: ['stage-3'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(3);
-    expect(result.matched.every(r => r.stage_results?.length === 3)).toBe(true);
+    expect(result.totalMatched).toBe(3);
+    expect(result.matched.every(r => r.stageResults?.length === 3)).toBe(true);
     expect(result.matched.every(r =>
-      r.accumulated_tags.includes('stage-1') &&
-      r.accumulated_tags.includes('stage-2') &&
-      r.accumulated_tags.includes('stage-3')
+      r.accumulatedTags.includes('stage-1') &&
+      r.accumulatedTags.includes('stage-2') &&
+      r.accumulatedTags.includes('stage-3')
     )).toBe(true);
   });
 
@@ -459,51 +459,51 @@ describe('FunnelEngine - Multi-Stage', () => {
       id: 'funnel-1',
       name: 'Filtering Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Pass All',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Filter Some',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          custom_evaluator: (entity) => entity.id === '1' || entity.id === '2',
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          customEvaluator: (entity) => entity.id === '1' || entity.id === '2',
         },
         {
           id: 'stage-3',
           order: 2,
           name: 'Final Filter',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          custom_evaluator: (entity) => entity.id === '1',
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          customEvaluator: (entity) => entity.id === '1',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(1);
+    expect(result.totalMatched).toBe(1);
     expect(result.matched[0].entity.id).toBe('1');
-    expect(result.total_excluded).toBe(2);
+    expect(result.totalExcluded).toBe(2);
 
     // Check exclusion stages
-    const excludedAtStage2 = result.excluded.find(r => r.excluded_at_stage === 'stage-2');
-    const excludedAtStage3 = result.excluded.find(r => r.excluded_at_stage === 'stage-3');
+    const excludedAtStage2 = result.excluded.find(r => r.excludedAtStage === 'stage-2');
+    const excludedAtStage3 = result.excluded.find(r => r.excludedAtStage === 'stage-3');
 
     expect(excludedAtStage2?.entity.id).toBe('3');
     expect(excludedAtStage3?.entity.id).toBe('2');
@@ -520,47 +520,47 @@ describe('FunnelEngine - Multi-Stage', () => {
       id: 'funnel-1',
       name: 'Unsorted Stages',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-3',
           order: 2,
           name: 'Third Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['third'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['third'],
         },
         {
           id: 'stage-1',
           order: 0,
           name: 'First Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['first'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['first'],
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Second Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['second'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['second'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
     // Tags should be added in order: first, second, third
-    expect(result.matched[0].accumulated_tags).toEqual(['first', 'second', 'third']);
+    expect(result.matched[0].accumulatedTags).toEqual(['first', 'second', 'third']);
   });
 });
 
@@ -581,29 +581,29 @@ describe('FunnelEngine - AND Logic', () => {
       id: 'funnel-1',
       name: 'AND Logic Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'AND Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [
-            { field_path: 'value', operator: 'gte', value: 20 },
-            { field_path: 'active', operator: 'is_true', value: null },
+            { fieldPath: 'value', operator: 'gte', value: 20 },
+            { fieldPath: 'active', operator: 'is_true', value: null },
           ],
-          match_action: 'output',
-          no_match_action: 'exclude',
+          matchAction: 'output',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
-    // Mock rule evaluator to use custom_evaluator
+    // Mock rule evaluator to use customEvaluator
     const stageWithEvaluator: FunnelStage<GenericEntity> = {
       ...funnel.stages[0],
-      custom_evaluator: (entity) => entity.value >= 20 && entity.active === true,
+      customEvaluator: (entity) => entity.value >= 20 && entity.active === true,
     };
 
     funnel.stages[0] = stageWithEvaluator;
@@ -611,7 +611,7 @@ describe('FunnelEngine - AND Logic', () => {
     const result = engine.execute(funnel, entities);
 
     // Only entity 3 matches both conditions
-    expect(result.total_matched).toBe(1);
+    expect(result.totalMatched).toBe(1);
     expect(result.matched[0].entity.id).toBe('3');
   });
 });
@@ -633,29 +633,29 @@ describe('FunnelEngine - OR Logic', () => {
       id: 'funnel-1',
       name: 'OR Logic Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'OR Stage',
-          filter_logic: 'OR',
+          filterLogic: 'OR',
           rules: [
-            { field_path: 'value', operator: 'gte', value: 20 },
-            { field_path: 'active', operator: 'is_true', value: null },
+            { fieldPath: 'value', operator: 'gte', value: 20 },
+            { fieldPath: 'active', operator: 'is_true', value: null },
           ],
-          match_action: 'output',
-          no_match_action: 'exclude',
+          matchAction: 'output',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     // Mock rule evaluator
     const stageWithEvaluator: FunnelStage<GenericEntity> = {
       ...funnel.stages[0],
-      custom_evaluator: (entity) => entity.value >= 20 || entity.active === true,
+      customEvaluator: (entity) => entity.value >= 20 || entity.active === true,
     };
 
     funnel.stages[0] = stageWithEvaluator;
@@ -663,7 +663,7 @@ describe('FunnelEngine - OR Logic', () => {
     const result = engine.execute(funnel, entities);
 
     // Entities 1 and 2 match (1 has active=true, 2 has value>=20)
-    expect(result.total_matched).toBe(2);
+    expect(result.totalMatched).toBe(2);
     expect(result.matched.map(r => r.entity.id).sort()).toEqual(['1', '2']);
   });
 });
@@ -681,36 +681,36 @@ describe('FunnelEngine - Tags', () => {
       id: 'funnel-1',
       name: 'Tag Accumulation',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Stage 1',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['tag-1', 'tag-2'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['tag-1', 'tag-2'],
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Stage 2',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['tag-3'],
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['tag-3'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.matched[0].accumulated_tags).toEqual(['tag-1', 'tag-2', 'tag-3']);
+    expect(result.matched[0].accumulatedTags).toEqual(['tag-1', 'tag-2', 'tag-3']);
   });
 
   it('should apply completion tags to matched entities', () => {
@@ -724,29 +724,29 @@ describe('FunnelEngine - Tags', () => {
       id: 'funnel-1',
       name: 'Completion Tags',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Filter',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          custom_evaluator: (entity) => entity.value >= 20,
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          customEvaluator: (entity) => entity.value >= 20,
         },
       ],
-      completion_tags: ['completed', 'qualified'],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      completionTags: ['completed', 'qualified'],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(1);
-    expect(result.matched[0].accumulated_tags).toContain('completed');
-    expect(result.matched[0].accumulated_tags).toContain('qualified');
+    expect(result.totalMatched).toBe(1);
+    expect(result.matched[0].accumulatedTags).toContain('completed');
+    expect(result.matched[0].accumulatedTags).toContain('qualified');
   });
 
   it('should count tagged entities correctly', () => {
@@ -761,27 +761,27 @@ describe('FunnelEngine - Tags', () => {
       id: 'funnel-1',
       name: 'Tag Counting',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Tag Some',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'continue',
-          match_tags: ['tagged'],
-          custom_evaluator: (entity) => entity.value >= 20,
+          matchAction: 'continue',
+          noMatchAction: 'continue',
+          matchTags: ['tagged'],
+          customEvaluator: (entity) => entity.value >= 20,
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_tagged).toBe(2); // Entities 2 and 3
+    expect(result.totalTagged).toBe(2); // Entities 2 and 3
   });
 });
 
@@ -802,40 +802,40 @@ describe('FunnelEngine - Exclusions', () => {
       id: 'funnel-1',
       name: 'Exclusion Tracking',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Stage 1',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          custom_evaluator: (entity) => entity.value >= 20,
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          customEvaluator: (entity) => entity.value >= 20,
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Stage 2',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          custom_evaluator: (entity) => entity.value >= 30,
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          customEvaluator: (entity) => entity.value >= 30,
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(1);
+    expect(result.totalMatched).toBe(1);
     expect(result.matched[0].entity.id).toBe('3');
 
-    const excludedAtStage1 = result.excluded.find(r => r.excluded_at_stage === 'stage-1');
-    const excludedAtStage2 = result.excluded.find(r => r.excluded_at_stage === 'stage-2');
+    const excludedAtStage1 = result.excluded.find(r => r.excludedAtStage === 'stage-1');
+    const excludedAtStage2 = result.excluded.find(r => r.excludedAtStage === 'stage-2');
 
     expect(excludedAtStage1?.entity.id).toBe('1');
     expect(excludedAtStage2?.entity.id).toBe('2');
@@ -849,37 +849,37 @@ describe('FunnelEngine - Exclusions', () => {
       id: 'funnel-1',
       name: 'Stop After Exclusion',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Exclude',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          custom_evaluator: () => false,
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          customEvaluator: () => false,
         },
         {
           id: 'stage-2',
           order: 1,
           name: 'Should Not Reach',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          match_tags: ['unreachable'],
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          matchTags: ['unreachable'],
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.excluded[0].stage_results?.length).toBe(1); // Only stage-1
-    expect(result.excluded[0].accumulated_tags).not.toContain('unreachable');
+    expect(result.excluded[0].stageResults?.length).toBe(1); // Only stage-1
+    expect(result.excluded[0].accumulatedTags).not.toContain('unreachable');
   });
 });
 
@@ -900,35 +900,35 @@ describe('FunnelEngine - Statistics', () => {
       id: 'funnel-1',
       name: 'Stats Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Filter Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'continue',
-          no_match_action: 'exclude',
-          match_tags: ['qualified'],
-          custom_evaluator: (entity) => entity.value >= 20,
+          matchAction: 'continue',
+          noMatchAction: 'exclude',
+          matchTags: ['qualified'],
+          customEvaluator: (entity) => entity.value >= 20,
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    const stats = result.stage_stats['stage-1'];
+    const stats = result.stageStats['stage-1'];
 
-    expect(stats.input_count).toBe(3);
-    expect(stats.matched_count).toBe(2);
-    expect(stats.not_matched_count).toBe(1);
-    expect(stats.excluded_count).toBe(1);
-    expect(stats.tagged_count).toBe(2);
-    expect(stats.continued_count).toBe(2);
-    expect(stats.duration_ms).toBeGreaterThanOrEqual(0);
+    expect(stats.inputCount).toBe(3);
+    expect(stats.matchedCount).toBe(2);
+    expect(stats.notMatchedCount).toBe(1);
+    expect(stats.excludedCount).toBe(1);
+    expect(stats.taggedCount).toBe(2);
+    expect(stats.continuedCount).toBe(2);
+    expect(stats.durationMs).toBeGreaterThanOrEqual(0);
   });
 
   it('should track execution duration', () => {
@@ -939,26 +939,26 @@ describe('FunnelEngine - Statistics', () => {
       id: 'funnel-1',
       name: 'Duration Test',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Test Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
+          matchAction: 'output',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.duration_ms).toBeGreaterThanOrEqual(0);
-    expect(typeof result.duration_ms).toBe('number');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    expect(typeof result.durationMs).toBe('number');
   });
 });
 
@@ -967,7 +967,7 @@ describe('FunnelEngine - Statistics', () => {
 // ============================================================================
 
 describe('FunnelEngine - Custom Evaluators', () => {
-  it('should use custom_evaluator when provided', () => {
+  it('should use customEvaluator when provided', () => {
     const engine = new FunnelEngine<MockRecipe>();
     const entities = createMockRecipes();
 
@@ -975,30 +975,30 @@ describe('FunnelEngine - Custom Evaluators', () => {
       id: 'funnel-1',
       name: 'Custom Eval Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Quick Recipes',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          custom_evaluator: (recipe) => recipe.prep_time_minutes <= 45,
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          customEvaluator: (recipe) => recipe.prep_time_minutes <= 45,
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(2); // Pasta and Curry
+    expect(result.totalMatched).toBe(2); // Pasta and Curry
     expect(result.matched.every(r => r.entity.prep_time_minutes <= 45)).toBe(true);
   });
 
-  it('should handle custom_evaluator errors gracefully', () => {
+  it('should handle customEvaluator errors gracefully', () => {
     const engine = new FunnelEngine<GenericEntity>();
     const entities: GenericEntity[] = [{ id: '1', value: 10 }];
 
@@ -1006,30 +1006,30 @@ describe('FunnelEngine - Custom Evaluators', () => {
       id: 'funnel-1',
       name: 'Error Handling',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Throw Error',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
-          custom_evaluator: () => {
+          matchAction: 'output',
+          noMatchAction: 'exclude',
+          customEvaluator: () => {
             throw new Error('Evaluator failed');
           },
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
     // Should treat error as no match
-    expect(result.total_matched).toBe(0);
-    expect(result.total_excluded).toBe(1);
+    expect(result.totalMatched).toBe(0);
+    expect(result.totalExcluded).toBe(1);
   });
 });
 
@@ -1062,25 +1062,25 @@ describe('FunnelEngine - Generic Entity Types', () => {
       id: 'funnel-1',
       name: 'Arbitrary Funnel',
       status: 'active',
-      input_type: 'any',
+      inputType: 'any',
       stages: [
         {
           id: 'stage-1',
           order: 0,
           name: 'Test Stage',
-          filter_logic: 'AND',
+          filterLogic: 'AND',
           rules: [],
-          match_action: 'output',
-          no_match_action: 'exclude',
+          matchAction: 'output',
+          noMatchAction: 'exclude',
         },
       ],
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
     };
 
     const result = engine.execute(funnel, entities);
 
-    expect(result.total_matched).toBe(1);
+    expect(result.totalMatched).toBe(1);
     expect(result.matched[0].entity.uuid).toBe('abc-123');
     expect(result.matched[0].entity.nested.deep.value).toBe(42);
   });