Atomic with non-atomic sub-rule vs. compound-atomic with regular rule

[simait]

I've come across a behavior that I'm not sure is a bug or not (hence why I'm not posting it as a bug). It seems that behavior is at least not consistent with my understanding of pest, but as I'm new to pest it's likely that it's PEBKAC. Anyway, I'm currently using the following idiom in order to avoid too many recursions in my code, e.g.:

affected_by         = !{ number }
affected_by_pattern = @{ "B" ~ WHITESPACE+ ~ affected_by ~ NEWLINE }

Where the idea is to use atomic rules and then punch holes in them with non-atomic rules so I can match those. Now, this works just fine for the most part (I have like 8-9 rules where I do this), but then suddenly it fails for a specific rule, i.e.:

effect         = !{ number ~ WHITESPACE+ ~ number }
effect_pattern = @{ "A" ~ NEWLINE ~ effect ~ NEWLINE }

The interesting part is that if I remove the ! then it matches just fine (I just don't get the token, etc.):

effect         = { number ~ WHITESPACE+ ~ number }
effect_pattern = @{ "A" ~ NEWLINE ~ effect ~ NEWLINE }

It also works if I use a compound-atomic rule (my current workaround), i.e.:

effect         =  { number ~ WHITESPACE+ ~ number }
effect_pattern = ${ "A" ~ NEWLINE ~ effect ~ NEWLINE }

This doesn't really make sense to me as it feels like the behavior is not consistent across the board, but is it a bug or am I simply misunderstanding how pest works? The error message I get is the following:

Error: Failed to parse file:   --> 21:1
   |
21 | 13 10
   | ^---
   |
   = expected effect

Caused by:
      --> 21:1
       |
    21 | 13 10
       | ^---
       |
       = expected effect

See the complete grammar below, i.e. definition of number and WHITESPACE in order to be properly baffled like me, or to explain to me what I'm doing wrong!

For information, I'm using pest 2.8.4, the following is my complete grammar (see comment for the specific rules that work/doesn't work):

WHITESPACE = _{ (" " | "\t") }

number = @{
    ("+" | "-")? ~ ASCII_DIGIT+
  | (ASCII_ALPHA_LOWER | 'A'..'G')+
}

vnum         = !{ number }
vnum_pattern = @{ "#" ~ vnum ~ WHITESPACE* ~ NEWLINE }

text_terminator = @{ "~" ~ NEWLINE }
text            = @{ (!text_terminator ~ ANY)* }

keywords         = !{ text }
keywords_pattern = @{ keywords ~ text_terminator }

name         = !{ text }
name_pattern = @{ name ~ text_terminator }

description         = !{ text }
description_pattern = @{ description ~ text_terminator }

action_description         = !{ text }
action_description_pattern = @{ action_description ~ text_terminator }

object_type   = !{ number }
level         = !{ number }
anti_classes  = !{ number }
extra_flags   = !{ number }
wear_flags    = !{ number }
stats_pattern = @{ object_type ~ WHITESPACE+ ~ level ~ WHITESPACE+ ~ anti_classes ~ WHITESPACE+ ~ extra_flags ~ WHITESPACE+ ~ wear_flags ~ WHITESPACE* ~ NEWLINE }

property           = !{ number }
properties_pattern = @{ property ~ WHITESPACE+ ~ property ~ WHITESPACE+ ~ property ~ WHITESPACE+ ~ property ~ WHITESPACE+ ~ property ~ WHITESPACE+ ~ property ~ WHITESPACE* ~ NEWLINE }

weight       = !{ number }
value        = !{ number }
cost_per_day = !{ number }
misc_pattern = @{ weight ~ WHITESPACE+ ~ value ~ WHITESPACE+ ~ cost_per_day ~ WHITESPACE* ~ NEWLINE }

extra_keywords                     = !{ text }
extra_description                  = !{ text }
extra_keywords_description_pattern = @{ "E" ~ NEWLINE ~ extra_keywords ~ text_terminator ~ extra_description ~ text_terminator }

// Works, i.e. it can parse the file and produces a token for "effect"
effect         =  { number ~ WHITESPACE+ ~ number }
effect_pattern = ${ "A" ~ NEWLINE ~ effect ~ NEWLINE }

// Also works, i.e. it can parse the file, but doesn't produce any token for "effect" ofc.
// effect         = { number ~ WHITESPACE+ ~ number }
// effect_pattern = @{ "A" ~ NEWLINE ~ effect ~ NEWLINE }

// Doesn't work, i.e. can't parse the file, complains about expecting "effect".
// effect         = !{ number ~ WHITESPACE+ ~ number }
// effect_pattern = @{ "A" ~ NEWLINE ~ effect ~ NEWLINE }

affected_by         = !{ number }
affected_by_pattern = @{ "B" ~ WHITESPACE+ ~ affected_by ~ NEWLINE }

procedure         = !{ (!")" ~ ANY)+ }
procedure_pattern = @{ "Proc(" ~ procedure ~ ")" ~ NEWLINE }

optional_patterns = { extra_keywords_description_pattern | effect_pattern | affected_by_pattern | procedure_pattern }

object = @{
    vnum_pattern ~ keywords_pattern ~ name_pattern ~ description_pattern ~ action_description_pattern ~ stats_pattern ~ properties_pattern ~ misc_pattern ~ optional_patterns*
}

eoi      = _{ !ANY }
database =  { SOI ~ object+ ~ "#99999" ~ NEWLINE ~ "$~" ~ NEWLINE ~ eoi }

[simait]

UPDATE: Apparently the compound-atomic ($) rule doesn't seem to work as I expected it to, i.e. no token is produced for effect, only for effect_pattern and adding ! to effect causes the same failure to parse as for the atomic (@) rule. So at least that is consistent (although I could swear that I managed to get it working, but I'm quite a few iterations deep on this so...). However, the question remains if this is the expected behavior and if so why?

[tomtau]

I think it's expected if I understand the issue correctly: in atomic rules, inner rules are silent, while in compound atomic rules, they produce inner tokens as normal?