Confirmed that this definition is enough to run the compiler (basically the same as commit 6a256ca, but maintaining the fill):

_under_↩{
  i←↕l←1×´s←≢𝕩
  v←𝕨𝔽○𝔾𝕩 ⋄ gi←𝔾s⥊i
  n←(IsArray gi)⊑{⟨𝕩⟩}‿⥊ ⋄ v↩N v ⋄ gi↩N gi
  g←⍋ gi
  P←(≠g)⊸≤◶⟨(⊑⟜g)⊑gi˜,l⟩
  e←P j←0
  𝕩 ⊣_fillBy_⊢˜ s⥊{e=𝕩}◶⟨⊑⟜(⥊𝕩),{𝕩⋄r←(j⊑g)⊑v⋄e↩P j↩1+j⋄r}⟩⌜i
}

Looks like right operands are always of the form ⊸⊏, ⊸/, ⊸⊑, or ⌽ so you could even detect and use the special case fairly easily if you don't want the compiler to use a special runtime.

dzaima/BQN is definitely fastest when it works. Although I don't think the runtime version is too hard to implement either. It's a real headache when your only mutable data structure is a closure and you're trying to maintain performance, but with mutable arrays all the reinsertion is pretty simple.

Same with the special version. The last four lines are just to reinsert values v at indices gi.

The runtime doesn't use Catch, so structural Under does a manual error trapping thing. I'm guessing this is failing on the fairly complicated result of ⋆⁼.

Oh, so it called built-in ⥊ with an invalid shape (left argument ⟨0⟩ and right argument a 1-element list).

Adjusting Recompose to detect if a modifier is StructErr˙ fixes 4 +⌾(⋆⁼) 5. Need to think a little more about whether other cases can have similar problems.

Okay, fixed both of those. For modifying fills, I fill index arrays with a character and then check that none of the indices coming out are characters. Doesn't seem to have a significant performance impact in JS.