test: fix legacy fixture suites against modern DSL validation

The legacy test files (Definition/Evidence/Expression/Fact/Integration/
Measure) predate the DSL's validation rules: reserved built-in types
(User/Account/Device/AuthSession) and the boolean/predicate-call
requirements on evidence statements. Fixed the fixtures, not the engine:

- reserved renames: User->Employee, Account->Tenant (Device/AuthSession
  were only legally referenced)
- expression fixtures: comparators now use predicate calls on both sides
  (fact score(value: number) + score(1 + 2 * 3) > score(0)); measure
  bodies carry the original arbitrary expressions (validated, not
  rule-generated)
- grammar-shape fixes: comma-separated fusion/aggregate lists, PROVIDES
  X (no array returns), predicate-call evidence statements

All 54 tests across the 8 files pass.

tests/IntegrationTests.js

@@ -19,8 +19,9 @@ describe('Integration Tests', () => {
   test('Complete authorization system', () => {
     const completeSystem = `
       // Type definitions with complex behaviors
-      definition User {
-        role: string
+      definition Employee {
+        role: Role
+        group: Group
         isActive: boolean
         lastActive: timestamp BEHAVES {
           decaying down hourly
@@ -41,21 +42,34 @@ describe('Integration Tests', () => {
         reputation: number BEHAVES {
           decaying up daily
         } CACHE lazy
+        activityScore: number
+        verificationLevel: number
+      }
+
+      definition Role {
+        permissions: Permission[]
+        clearance: string
       }
 
       definition Group {
         name: string
         permissions: Permission[]
         level: string
+        clearance: string
         isPublic: boolean CACHE eager
         created: timestamp BEHAVES {
           decaying stable monthly
         } CACHE lazy
       }
 
+      definition Permission {
+        name: string
+        level: string
+      }
+
       definition Document {
         level: string
-        owner: User
+        owner: Employee
         tags: string[]
         content: string BEHAVES {
           blurring fixed
@@ -71,7 +85,7 @@ describe('Integration Tests', () => {
 
       definition Resource {
         level: string
-        owner: User
+        owner: Employee
         permissions: Permission[]
         isPublic: boolean CACHE eager
         accessCount: number BEHAVES {
@@ -80,20 +94,28 @@ describe('Integration Tests', () => {
       }
 
       // Facts with various properties and caching
-      fact hasRole(user: User, role: string) CACHE eager
-      fact isMember(user: User, group: Group) transitive CACHE lazy limit 10
-      fact isFriend(user: User, friend: User) symmetrical CACHE eager limit 100
-      fact owns(user: User, doc: Document) CACHE eager
-      fact isSuspended(user: User) CACHE lazy
-      fact hasPermission(user: User, resource: Resource, action: string) CACHE eager
-      fact isAdmin(user: User) CACHE eager
-      fact isOwner(user: User, resource: Resource) CACHE eager
-      fact hasAccess(user: User, resource: Resource, level: string) CACHE lazy
-      fact isColleague(user: User, colleague: User) symmetrical CACHE lazy limit 50
-      fact isParentOf(parent: User, child: User) transitive CACHE eager limit 3
+      fact hasRole(user: Employee, role: string) CACHE eager
+      fact isMember(user: any, group: any) transitive CACHE lazy limit 10
+      fact isFriend(user: any, friend: any) symmetrical CACHE eager limit 100
+      fact owns(user: Employee, doc: Document) CACHE eager
+      fact isSuspended(user: Employee) CACHE lazy
+      fact hasPermission(user: Employee, resource: Resource, action: string) CACHE eager
+      fact isAdmin(user: Employee) CACHE eager
+      fact isOwner(user: Employee, resource: Resource) CACHE eager
+      fact hasAccess(user: Employee, resource: Resource, level: string) CACHE lazy
+      fact isColleague(user: any, colleague: any) symmetrical CACHE lazy limit 50
+      fact isParentOf(parent: Employee, child: Employee) transitive CACHE eager limit 3
+      fact hasClearance(user: Employee, level: string) CACHE eager
+      fact parentOf(user: any, parent: any) CACHE eager
+      fact similar(a: any, b: any) CACHE lazy
+      fact isActive(user: Employee) CACHE eager
+      fact isTrusted(user: Employee) CACHE eager
+      fact isBlacklisted(user: Employee) CACHE lazy
+      fact hasRecentActivity(user: Employee) CACHE lazy
+      fact recentlyActive(user: Employee) CACHE lazy
 
       // Evidence rules with complex logic
-      evidence canRead(user: User, doc: Document) {
+      evidence canRead(user: Employee, doc: Document) {
         owns(user, doc)
 
         isMember(user, *group) {
@@ -106,12 +128,12 @@ describe('Integration Tests', () => {
 
         similar(doc, *similar) |similarity| {
           canRead(user, similar)
-        } with similarity > 0.7 limit 5
+        } limit 5 with similarity > 0.7
 
         WHEN hasRole(user, 'admin') UNLESS isSuspended(user)
       }
 
-      evidence canWrite(user: User, doc: Document) {
+      evidence canWrite(user: Employee, doc: Document) {
         owns(user, doc)
 
         isMember(user, *group) {
@@ -120,82 +142,83 @@ describe('Integration Tests', () => {
 
         WHEN hasRole(user, 'admin') UNLESS isSuspended(user)
 
-        REQUIRES user.isActive
+        REQUIRES isActive(user)
       }
 
-      evidence canDelete(user: User, doc: Document) {
+      evidence canDelete(user: Employee, doc: Document) {
         owns(user, doc)
 
-        ALWAYS user.isActive
+        ALWAYS isActive(user)
 
         WHEN hasRole(user, 'admin') UNLESS isSuspended(user)
 
-        REQUIRES user.isActive
+        REQUIRES isActive(user)
       }
 
-      evidence canAccessCritical(user: User, resource: Resource) {
+      evidence canAccessCritical(user: Employee, resource: Resource) {
         fusion min {
-          hasClearance(user, resource.level)
-          user.isActive
-          NOT user.isBlacklisted
+          hasClearance(user, resource.level),
+          isActive(user),
+          NOT isBlacklisted(user)
         }
 
         fusion max {
           hasRole(user, 'admin')
-          fusion majority {
-            hasClearance(user, 'secret')
-            user.isTrusted
-            user.lastActive within 1hr
-          }
+        }
+
+        fusion majority {
+          hasClearance(user, 'secret'),
+          isTrusted(user),
+          recentlyActive(user)
         }
       }
 
-      evidence canAccessSensitive(user: User, doc: Document) {
-        ALWAYS user.isActive
+      evidence canAccessSensitive(user: Employee, doc: Document) {
+        ALWAYS isActive(user)
 
         WHEN hasRole(user, 'admin') UNLESS isSuspended(user)
 
         REQUIRES hasClearance(user, doc.level)
 
         fusion majority {
-          user.isTrusted
-          user.hasRecentActivity
+          isTrusted(user),
+          hasRecentActivity(user)
         }
       }
 
       // Measures for computed values
-      measure userRole(user: User) {
+      measure userRole(user: Employee) {
         user.role
       } PROVIDES string
 
-      measure userPermissions(user: User) {
+      measure userPermissions(user: Employee) {
         fusion max {
-          user.role.permissions
+          user.role.permissions,
           user.group.permissions
         }
-      } PROVIDES Permission[]
+      } PROVIDES Permission
 
-      measure effectiveClearance(user: User) {
+      measure effectiveClearance(user: Employee) {
         fusion majority {
-          user.clearance
-          user.role.clearance
+          user.clearance,
+          user.role.clearance,
           user.group.clearance
         }
       } PROVIDES string
 
-      measure userTrustScore(user: User) {
+      measure userTrustScore(user: Employee) {
         fusion average {
-          user.reputation
-          user.activityScore
+          user.reputation,
+          user.activityScore,
           user.verificationLevel
         }
       } PROVIDES number
 
-      measure userBalance(user: User) {
+      measure userBalance(user: Employee) {
         user.balance
       } PROVIDES number
 
-      measure userScore(user: User) {
+      measure userScore(user: Employee) {
         user.score
       } PROVIDES number
     `;
@@ -211,64 +234,71 @@ describe('Integration Tests', () => {
   test('Multi-domain system', () => {
     const multiDomain = `
       // Authentication domain
-      definition User {
+      definition Employee {
         role: string
         isActive: boolean
         lastActive: timestamp BEHAVES { decaying down hourly } CACHE lazy
         session: string BEHAVES { ttl 24h } CACHE eager
       }
 
-      fact hasRole(user: User, role: string) CACHE eager
-      fact isActive(user: User) CACHE eager
+      fact hasRole(user: Employee, role: string) CACHE eager
+      fact isActive(user: Employee) CACHE eager
+      fact recentlyActive(user: any) CACHE lazy
+      fact isPublic(doc: any) CACHE eager
 
-      evidence canAuthenticate(user: User) {
-        user.isActive
-        user.session within 24h
+      evidence canAuthenticate(user: Employee) {
+        isActive(user)
+        recentlyActive(user)
       }
 
       // Authorization domain
       definition Resource {
         level: string
-        owner: User
+        owner: Employee
         permissions: Permission[]
       }
 
-      fact owns(user: User, resource: Resource) CACHE eager
-      fact hasPermission(user: User, resource: Resource, action: string) CACHE eager
+      definition Permission {
+        name: string
+        level: string
+      }
 
-      evidence canAccess(user: User, resource: Resource) {
+      fact owns(user: Employee, resource: Resource) CACHE eager
+      fact hasPermission(user: Employee, resource: Resource, action: string) CACHE eager
+
+      evidence canAccess(user: Employee, resource: Resource) {
         owns(user, resource)
         hasPermission(user, resource, 'read')
       }
 
       // Finance domain
-      definition Account {
+      definition Tenant {
         balance: number BEHAVES { decaying down hourly } CACHE eager
-        owner: User
+        owner: Employee
         isActive: boolean CACHE eager
       }
 
-      fact hasAccount(user: User, account: Account) CACHE eager
-      fact hasBalance(user: User, amount: number) CACHE eager
+      fact hasAccount(user: Employee, account: Tenant) CACHE eager
+      fact hasBalance(user: Employee, amount: number) CACHE eager
 
-      evidence canWithdraw(user: User, amount: number) {
+      evidence canWithdraw(user: Employee, amount: number) {
         hasBalance(user, amount)
-        user.isActive
+        isActive(user)
       }
 
       // Social domain
       definition Group {
         name: string
-        members: User[]
+        members: Employee[]
         isPublic: boolean CACHE eager
       }
 
-      fact isMember(user: User, group: Group) transitive CACHE lazy limit 10
-      fact isFriend(user: User, friend: User) symmetrical CACHE eager limit 100
+      fact isMember(user: any, group: any) transitive CACHE lazy limit 10
+      fact isFriend(user: any, friend: any) symmetrical CACHE eager limit 100
 
-      evidence canAccessGroup(user: User, group: Group) {
+      evidence canAccessGroup(user: Employee, group: Group) {
         isMember(user, group)
-        group.isPublic
+        isPublic(group)
       }
     `;
 
@@ -281,7 +311,7 @@ describe('Integration Tests', () => {
 
   test('Hierarchical access', () => {
     const hierarchicalSystem = `
-      definition User {
+      definition Employee {
         role: string
         level: string
         isActive: boolean
@@ -294,22 +324,28 @@ describe('Integration Tests', () => {
         parent: Organization
       }
 
-      fact isMember(user: User, org: Organization) transitive CACHE lazy limit 5
-      fact isParentOf(parent: Organization, child: Organization) transitive CACHE eager limit 3
-      fact hasRole(user: User, role: string) CACHE eager
-      fact hasClearance(user: User, level: string) CACHE eager
+      definition Resource {
+        level: string
+      }
 
-      evidence canAccessOrg(user: User, org: Organization) {
+      fact isMember(user: any, org: any) transitive CACHE lazy limit 5
+      fact isParentOf(parent: Organization, child: Organization) transitive CACHE eager limit 3
+      fact hasRole(user: Employee, role: string) CACHE eager
+      fact hasClearance(user: Employee, level: string) CACHE eager
+      fact isSuspended(user: any) CACHE lazy
+      fact parentOf(user: any, parent: any) CACHE eager
+
+      evidence canAccessOrg(user: Employee, org: Organization) {
         isMember(user, org)
 
         isParentOf(org, *parentOrg) {
           canAccessOrg(user, parentOrg)
         } limit 3
 
-        WHEN hasRole(user, 'admin') UNLESS user.isSuspended
+        WHEN hasRole(user, 'admin') UNLESS isSuspended(user)
       }
 
-      evidence canAccessResource(user: User, resource: Resource) {
+      evidence canAccessResource(user: Employee, resource: Resource) {
         isMember(user, *org) {
           canAccessResource(org, resource)
         } limit 5
@@ -326,7 +362,7 @@ describe('Integration Tests', () => {
 
   test('Similarity-based access', () => {
     const similaritySystem = `
-      definition User {
+      definition Employee {
         profile: string
         interests: string[]
         isActive: boolean
@@ -336,39 +372,46 @@ describe('Integration Tests', () => {
         content: string
         tags: string[]
         isPublic: boolean
-        owner: User
+        owner: Employee
       }
 
-      fact isFriend(user: User, friend: User) symmetrical CACHE eager limit 100
-      fact hasInterest(user: User, interest: string) CACHE lazy
-      fact hasTag(doc: Document, tag: string) CACHE lazy
+      fact isFriend(user: any, friend: any) symmetrical CACHE eager limit 100
+      fact hasInterest(user: any, interest: string) CACHE lazy
+      fact hasTag(doc: any, tag: string) CACHE lazy
+      fact owns(user: any, doc: any) CACHE eager
+      fact similar(a: any, b: any) CACHE lazy
+      fact isPublic(doc: any) CACHE eager
+      fact hasInterests(user: any) CACHE lazy
+      fact hasTags(doc: any) CACHE lazy
+      fact hasProfile(user: any) CACHE lazy
+      fact hasContent(doc: any) CACHE lazy
 
-      evidence canRead(user: User, doc: Document) {
+      evidence canRead(user: Employee, doc: Document) {
         owns(user, doc)
 
         similar(doc, *similar) |similarity| {
           canRead(user, similar)
-          similar.isPublic
-        } with similarity > 0.7 limit 10
+          isPublic(similar)
+        } limit 10 with similarity > 0.7
 
         isFriend(user, *friend) {
           canRead(friend, doc)
         } limit 5
 
         fusion majority {
-          user.interests
-          doc.tags
+          hasInterests(user),
+          hasTags(doc)
         }
       }
 
-      evidence canRecommend(user: User, doc: Document) {
+      evidence canRecommend(user: Employee, doc: Document) {
         similar(user, *similarUser) |similarity| {
           canRead(similarUser, doc)
-        } with similarity > 0.8 limit 20
+        } limit 20 with similarity > 0.8
 
         fusion average {
-          user.profile
-          doc.content
+          hasProfile(user),
+          hasContent(doc)
         }
       }
     `;
@@ -379,7 +422,7 @@ describe('Integration Tests', () => {
 
   test('Temporal access', () => {
     const temporalSystem = `
-      definition User {
+      definition Employee {
         lastActive: timestamp BEHAVES { decaying down hourly } CACHE lazy
         session: string BEHAVES { ttl 24h } CACHE eager
         isActive: boolean
@@ -391,29 +434,34 @@ describe('Integration Tests', () => {
         isPublic: boolean
       }
 
-      fact hasAccess(user: User, event: Event) CACHE lazy
-      fact isParticipant(user: User, event: Event) CACHE eager
+      fact hasAccess(user: Employee, event: Event) CACHE lazy
+      fact isParticipant(user: Employee, event: Event) CACHE eager
+      fact recentlyActive(user: any) CACHE lazy
+      fact sessionFresh(user: any) CACHE lazy
+      fact isPublic(doc: any) CACHE eager
+      fact isSuspended(user: any) CACHE lazy
+      fact isActive(user: any) CACHE eager
 
-      evidence canAccessEvent(user: User, event: Event) {
-        user.lastActive within 1h
+      evidence canAccessEvent(user: Employee, event: Event) {
+        recentlyActive(user)
 
         isParticipant(user, event)
 
-        WHEN event.isPublic UNLESS user.isSuspended
+        WHEN isPublic(event) UNLESS isSuspended(user)
 
         fusion min {
-          user.session within 24h
-          user.isActive
+          sessionFresh(user),
+          isActive(user)
         }
       }
 
-      evidence canAccessHistorical(user: User, event: Event) {
-        user.lastActive within 24h
+      evidence canAccessHistorical(user: Employee, event: Event) {
+        recentlyActive(user)
 
         fusion majority {
-          user.isActive
-          user.session within 24h
-          event.isPublic
+          isActive(user),
+          sessionFresh(user),
+          isPublic(event)
         }
       }
     `;
@@ -424,7 +472,7 @@ describe('Integration Tests', () => {
 
   test('Complex behaviors', () => {
     const behaviorSystem = `
-      definition User {
+      definition Employee {
         balance: number BEHAVES { decaying down hourly } CACHE eager
         score: number BEHAVES { blurring adaptive confidence_95 } CACHE lazy
         session: string BEHAVES { ttl 24h } CACHE eager
@@ -440,30 +488,37 @@ describe('Integration Tests', () => {
         isPublic: boolean CACHE eager
       }
 
-      fact hasBalance(user: User, amount: number) CACHE eager
-      fact hasScore(user: User, score: number) CACHE lazy
-      fact hasReputation(user: User, reputation: number) CACHE lazy
+      fact hasBalance(user: Employee, amount: number) CACHE eager
+      fact hasScore(user: Employee, score: number) CACHE lazy
+      fact hasReputation(user: Employee, reputation: number) CACHE lazy
+      fact hasPositiveBalance(user: any) CACHE eager
+      fact hasHighScore(user: any) CACHE eager
+      fact hasGoodReputation(user: any) CACHE eager
+      fact isNotOverused(doc: any) CACHE eager
+      fact isActive(user: any) CACHE eager
+      fact recentlyActive(user: any) CACHE lazy
+      fact isPublic(doc: any) CACHE eager
 
-      evidence canAccessDocument(user: User, doc: Document) {
-        user.balance > 0
+      evidence canAccessDocument(user: Employee, doc: Document) {
+        hasPositiveBalance(user)
 
-        user.score > 0.5
+        hasHighScore(user)
 
-        user.reputation > 0.3
+        hasGoodReputation(user)
 
-        doc.accessCount < 1000
+        isNotOverused(doc)
 
         fusion majority {
-          user.isActive
-          user.lastActive within 1h
-          doc.isPublic
+          isActive(user),
+          recentlyActive(user),
+          isPublic(doc)
         }
       }
 
-      measure userEffectiveScore(user: User) {
+      measure userEffectiveScore(user: Employee) {
         fusion average {
-          user.score
-          user.reputation
+          user.score,
+          user.reputation,
           user.balance
         }
       } PROVIDES number
@@ -479,7 +534,7 @@ describe('Integration Tests', () => {
 
   test('Performance scenarios', () => {
     const performanceSystem = `
-      definition User {
+      definition Employee {
         role: string
         isActive: boolean
         permissions: Permission[] CACHE eager
@@ -487,18 +542,23 @@ describe('Integration Tests', () => {
 
       definition Resource {
         level: string
-        owner: User
+        owner: Employee
         permissions: Permission[] CACHE eager
       }
 
+      definition Permission {
+        name: string
+        level: string
+      }
+
       // High-frequency facts with limits
-      fact isMember(user: User, group: Group) transitive CACHE lazy limit 5
-      fact isFriend(user: User, friend: User) symmetrical CACHE eager limit 50
-      fact hasPermission(user: User, resource: Resource, action: string) CACHE eager
-      fact owns(user: User, resource: Resource) CACHE eager
+      fact isMember(user: any, group: any) transitive CACHE lazy limit 5
+      fact isFriend(user: any, friend: any) symmetrical CACHE eager limit 50
+      fact hasPermission(user: Employee, resource: Resource, action: string) CACHE eager
+      fact owns(user: Employee, resource: Resource) CACHE eager
 
       // Optimized evidence rules
-      evidence canAccess(user: User, resource: Resource) {
+      evidence canAccess(user: Employee, resource: Resource) {
         owns(user, resource)
 
         isMember(user, *group) {
@@ -508,7 +568,7 @@ describe('Integration Tests', () => {
         WHEN hasPermission(user, resource, 'read')
       }
 
-      evidence canModify(user: User, resource: Resource) {
+      evidence canModify(user: Employee, resource: Resource) {
         owns(user, resource)
 
         isMember(user, *group) {
@@ -519,9 +579,9 @@ describe('Integration Tests', () => {
       }
 
       // Efficient measures
-      measure userEffectivePermissions(user: User) {
+      measure userEffectivePermissions(user: Employee) {
         user.permissions
-      } PROVIDES Permission[]
+      } PROVIDES Permission
 
       measure resourceAccessLevel(resource: Resource) {
         resource.level