@agentvibes/guardrails 0.1.0

package/rules/store-async-method.yml

@@ -0,0 +1,98 @@
+# ── wave 1, store rule 2 of 7 ──────────────────────────────────────────
+#
+# The other half of `store-no-runinaction`, and the reason that rule has so much
+# to find: an `async` method's continuation after each `await` is NOT covered by
+# the action `makeAutoObservable` created. Every assignment past the first await
+# is an unbatched mutation outside an action.
+#
+# Deliberately does NOT fire when the method already contains `runInAction` —
+# that method is reported by `store-no-runinaction` at `error`, and the fix is
+# the same conversion. Two findings prescribing one change read as two problems,
+# and the error-tier one is the one worth showing.
+#
+# So this rule catches the quieter half: the async store method that mutates
+# without even the hand-patched `runInAction`, where nothing marks the hole.
+id: store-async-method
+language: typescript
+severity: warning
+ignores:
+  - '**/*.test.ts'
+  - '**/*.spec.ts'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+  contains-runinaction:
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^runInAction$'
+  # An observable MUTATION — which is the whole defect. Without this clause the
+  # rule fires on any async method, and in SiteCraft 10 of its 12 hits were
+  # private I/O helpers (`walkDir`, `collectAllFiles`, `uploadFile`) that await
+  # a filesystem and never touch a field. Those have no action coverage to lose,
+  # so at warning tier they were pure noise.
+  mutates-this:
+    has:
+      stopBy: end
+      any:
+        # this.field = … / this.field += …
+        - all:
+            - any:
+                - kind: assignment_expression
+                - kind: augmented_assignment_expression
+            - has:
+                field: left
+                kind: member_expression
+                has:
+                  field: object
+                  kind: this
+        # this.list.push(…), this.map.set(…), … — mutation through a method.
+        - all:
+            - kind: call_expression
+            - has:
+                field: function
+                kind: member_expression
+                all:
+                  - has:
+                      field: property
+                      regex: '^(push|pop|shift|unshift|splice|sort|reverse|set|delete|clear|add)$'
+                  - has:
+                      field: object
+                      kind: member_expression
+                      has:
+                        field: object
+                        kind: this
+message: |
+  An `async` method on a store class. The action that `makeAutoObservable`
+  wrapped around it ends at the first `await` — everything after resumes
+  OUTSIDE it, so each assignment there is an unbatched mutation and observers
+  see the half-updated store between them.
+  Use a `flow`, which resumes inside an action at every yield:
+    async load() { this.x = await f(); this.y = await g() }
+    → load = flow(function* (this: Store) { this.x = yield f(); this.y = yield g() })
+  Scope: this fires only when the method actually MUTATES an observable —
+  assigns `this.field` or calls `push`/`set`/`delete` on one. A private async
+  helper that only does I/O and returns has no action coverage to lose and stays
+  silent.
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: method_definition
+    - regex: '^((private|public|protected|static|override|abstract)\s+)*async\s'
+    - inside:
+        stopBy: end
+        matches: store-class
+    - matches: mutates-this
+    - not:
+        matches: contains-runinaction

package/rules/store-context-provider-tsx.yml

@@ -0,0 +1,68 @@
+# ADOPTION NOTE (canon promotion): brownfield-heavy — ~48-105 whole-tree hits
+# per useStore-era repo (tg-gallery/observatory/ppa). Run it DIFF-SCOPED
+# (verify-diff / hook) until a repo's useStore migration campaign lands;
+# whole-tree `verify` output will be loud there by design, not by accident.
+# ── simple-components, rule 1 of 4 — the .tsx half ─────────────────────
+#
+# ast-grep's `typescript` and `tsx` languages are disjoint, not nested: a rule at
+# `language: typescript` never sees a `.tsx` file. So this is the same rule
+# wearing a second id, plus one arm that only exists in JSX (`<StoreContext.Provider>`).
+# Suppress with the id the finding PRINTS — `-tsx` in a `.tsx` file.
+# Keep the two `rule:` blocks in sync.
+id: store-context-provider-tsx
+language: tsx
+severity: error
+ignores:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**'
+message: |
+  A store reached through React context. Decision D1: MobX already gives every
+  component a live channel to the data — a second one buys nothing and costs a
+  provider, a null-check and a hook on every file that reads state.
+  Do instead:
+    - one module-level `rootStore` in the canonical store module, imported
+      DIRECTLY and only by screen-level files;
+    - platform/DI dependencies through `initRootStore(deps)`, called once from
+      the entry file before the first render;
+    - page-scoped state through `usePageStore(() => new XxxPageStore(...), [k])`;
+    - everything below a screen receives `model={...}` as a prop.
+  Tests stop needing a provider at all: `new XxxStore(fakeDeps)` directly, and
+  `*.view.tsx` files mount with nothing around them.
+  See the simple-components skill (§store access) and report §8.
+rule:
+  any:
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^useStore$'
+    - all:
+        - any:
+            - kind: function_declaration
+            - kind: variable_declarator
+        - has:
+            field: name
+            regex: '^useStore$'
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^createContext$'
+        - inside:
+            stopBy: end
+            kind: variable_declarator
+            regex: '[Ss]tore'
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^useContext$'
+        - regex: '[Ss]tore'
+    # JSX-only arm: `<XxxStoreContext.Provider value={…}>`.
+    - all:
+        - kind: jsx_opening_element
+        - regex: '[Ss]tore[A-Za-z]*\.Provider'

package/rules/store-context-provider.yml

@@ -0,0 +1,78 @@
+# ADOPTION NOTE (canon promotion): brownfield-heavy — ~48-105 whole-tree hits
+# per useStore-era repo (tg-gallery/observatory/ppa). Run it DIFF-SCOPED
+# (verify-diff / hook) until a repo's useStore migration campaign lands;
+# whole-tree `verify` output will be loud there by design, not by accident.
+# ── simple-components, rule 1 of 4 ─────────────────────────────────────
+#
+# Decision D1: a MobX project has NO store context. One module-level `rootStore`,
+# imported at screen level only; everything below gets models through props.
+#
+# The canon rule `direct-store-import` covers the other half — where a store
+# import is legal. Nothing in the canon bans the context CHANNEL itself, which is
+# what this rule is for. Audit basis (report §8): all four store-bearing apps
+# route through a `useStore()` context hook (215/97/69/46 call sites) and not one
+# of them uses it for anything context is needed for: in one of them the provider
+# hands out a module-level singleton unconditionally, and its own tests bypass
+# the provider entirely.
+#
+# NOT a candidate for blanket adoption in a repo that has not migrated: on
+# today's park this fires hundreds of times. Run it diff-scoped (the skill's
+# check-simple.sh --changed, or `guardrails verify-diff`) until the migration
+# lands.
+id: store-context-provider
+language: typescript
+severity: error
+ignores:
+  - '**/*.test.ts'
+  - '**/*.spec.ts'
+  - '**/__tests__/**'
+message: |
+  A store reached through React context. Decision D1: MobX already gives every
+  component a live channel to the data — a second one buys nothing and costs a
+  provider, a null-check and a hook on every file that reads state.
+  Do instead:
+    - one module-level `rootStore` in the canonical store module, imported
+      DIRECTLY and only by screen-level files;
+    - platform/DI dependencies through `initRootStore(deps)`, called once from
+      the entry file before the first render;
+    - page-scoped state through `usePageStore(() => new XxxPageStore(...), [k])`;
+    - everything below a screen receives `model={...}` as a prop.
+  Tests stop needing a provider at all: `new XxxStore(fakeDeps)` directly, and
+  `*.view.tsx` files mount with nothing around them.
+  See the simple-components skill (§store access) and report §8.
+rule:
+  any:
+    # `useStore()` — the call...
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^useStore$'
+    # ...and its declaration, which is the thing that enables every call site.
+    - all:
+        - any:
+            - kind: function_declaration
+            - kind: variable_declarator
+        - has:
+            field: name
+            regex: '^useStore$'
+    # `createContext` whose declarator mentions a store.
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^createContext$'
+        - inside:
+            stopBy: end
+            kind: variable_declarator
+            regex: '[Ss]tore'
+    # `useContext(SomethingStoreContext)`.
+    - all:
+        - kind: call_expression
+        - has:
+            field: function
+            kind: identifier
+            regex: '^useContext$'
+        - regex: '[Ss]tore'

package/rules/store-delegation-getter-tsx.yml

@@ -0,0 +1,104 @@
+# ── the .tsx half of `store-delegation-getter` ──
+#
+# ast-grep's `typescript` and `tsx` languages are DISJOINT: a `language:
+# typescript` rule reads .ts and never .tsx. `demo-mode-by-default-ts.yml`
+# records this repo learning that the hard way, so it is measured here rather
+# than assumed — 30 .tsx files in the park call make(Auto)Observable, and the
+# five twins with hits add 29 findings the .ts halves cannot see.
+#
+# Keep this file's `rule:` block IDENTICAL to `store-delegation-getter.yml`.
+# Suppressing needs THIS id: `ast-grep-ignore: store-delegation-getter-tsx`.
+#
+# ── wave 1, store rule 5 of 7 ──────────────────────────────────────────
+#
+# A getter whose entire body is `return this.someStore.prop` — a store aliasing
+# another store's field. It adds a second name for one piece of state, so call
+# sites disagree about which name is canonical, and the alias silently outlives
+# the field it forwards to.
+#
+# THE NEGATIVE IS THE WHOLE DESIGN OF THIS RULE. The identical shape,
+# `return this.data.x`, is the house data-wrapper pattern and is completely
+# legal: a `Model` class holding a plain record and exposing its fields as
+# observable getters. Measured across SiteCraft, observatory, byok and metro,
+# single-line `return this.X.y` getters break down as:
+#
+#     89 × this.data.*            byok Model, metro domain stores — LEGAL
+#      2 × this.connectionStore.* — the real store→store alias
+#
+# So the discriminator is the intermediate NAME, and the rule matches only
+# `Store`-suffixed ones — the same `[Ss]tore` convention mobx-effect-observable-dep
+# and mobx-usestate-from-store already key on.
+#
+# KNOWN AND DELIBERATE MISS: a rootStore reference conventionally named `root`
+# (WireDrill annotates `{ root: false }`), so `return this.root.user` is a real
+# store→store alias this rule does not catch. Widening to `root` would put
+# `this.data`-shaped names back in scope by degrees; the good fixture pins the
+# miss so it stays a decision rather than becoming a surprise.
+id: store-delegation-getter-tsx
+language: tsx
+severity: warning
+ignores:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+message: |
+  A getter that only forwards another store's field. Now the value has two
+  names, and every call site has to know which one is current — the alias keeps
+  compiling long after the field behind it moves or changes meaning.
+  Read it where it lives (`rootStore.userStore.name`), or, if this store really
+  owns the concept, hold the value rather than a pointer to someone else's.
+  A computed that DERIVES something (combines, filters, formats) is the point of
+  computeds and is not this — this fires only on a body that is a bare
+  `return this.otherStore.field`.
+  Not this rule: `return this.data.x` on a model wrapping a plain record. That
+  is the sanctioned data-wrapper pattern and stays silent.
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: method_definition
+    - regex: '^((private|public|protected|static|override)\s+)*get\s'
+    - inside:
+        stopBy: end
+        matches: store-class
+    - has:
+        field: body
+        all:
+          - kind: statement_block
+          - has:
+              kind: return_statement
+              has:
+                kind: member_expression
+                has:
+                  field: object
+                  all:
+                    - kind: member_expression
+                    - has:
+                        field: object
+                        kind: this
+                    - has:
+                        field: property
+                        regex: '[Ss]tore$'
+          # Body is ONLY that return — anything computed on the way makes it a
+          # real derivation rather than an alias.
+          - not:
+              has:
+                any:
+                  - kind: if_statement
+                  - kind: lexical_declaration
+                  - kind: variable_declaration
+                  - kind: expression_statement
+                  - kind: for_statement
+                  - kind: for_in_statement
+                  - kind: while_statement
+                  - kind: switch_statement
+                  - kind: try_statement

package/rules/store-delegation-getter.yml

@@ -0,0 +1,93 @@
+# ── wave 1, store rule 5 of 7 ──────────────────────────────────────────
+#
+# A getter whose entire body is `return this.someStore.prop` — a store aliasing
+# another store's field. It adds a second name for one piece of state, so call
+# sites disagree about which name is canonical, and the alias silently outlives
+# the field it forwards to.
+#
+# THE NEGATIVE IS THE WHOLE DESIGN OF THIS RULE. The identical shape,
+# `return this.data.x`, is the house data-wrapper pattern and is completely
+# legal: a `Model` class holding a plain record and exposing its fields as
+# observable getters. Measured across SiteCraft, observatory, byok and metro,
+# single-line `return this.X.y` getters break down as:
+#
+#     89 × this.data.*            byok Model, metro domain stores — LEGAL
+#      2 × this.connectionStore.* — the real store→store alias
+#
+# So the discriminator is the intermediate NAME, and the rule matches only
+# `Store`-suffixed ones — the same `[Ss]tore` convention mobx-effect-observable-dep
+# and mobx-usestate-from-store already key on.
+#
+# KNOWN AND DELIBERATE MISS: a rootStore reference conventionally named `root`
+# (WireDrill annotates `{ root: false }`), so `return this.root.user` is a real
+# store→store alias this rule does not catch. Widening to `root` would put
+# `this.data`-shaped names back in scope by degrees; the good fixture pins the
+# miss so it stays a decision rather than becoming a surprise.
+id: store-delegation-getter
+language: typescript
+severity: warning
+ignores:
+  - '**/*.test.ts'
+  - '**/*.spec.ts'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+message: |
+  A getter that only forwards another store's field. Now the value has two
+  names, and every call site has to know which one is current — the alias keeps
+  compiling long after the field behind it moves or changes meaning.
+  Read it where it lives (`rootStore.userStore.name`), or, if this store really
+  owns the concept, hold the value rather than a pointer to someone else's.
+  A computed that DERIVES something (combines, filters, formats) is the point of
+  computeds and is not this — this fires only on a body that is a bare
+  `return this.otherStore.field`.
+  Not this rule: `return this.data.x` on a model wrapping a plain record. That
+  is the sanctioned data-wrapper pattern and stays silent.
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: method_definition
+    - regex: '^((private|public|protected|static|override)\s+)*get\s'
+    - inside:
+        stopBy: end
+        matches: store-class
+    - has:
+        field: body
+        all:
+          - kind: statement_block
+          - has:
+              kind: return_statement
+              has:
+                kind: member_expression
+                has:
+                  field: object
+                  all:
+                    - kind: member_expression
+                    - has:
+                        field: object
+                        kind: this
+                    - has:
+                        field: property
+                        regex: '[Ss]tore$'
+          # Body is ONLY that return — anything computed on the way makes it a
+          # real derivation rather than an alias.
+          - not:
+              has:
+                any:
+                  - kind: if_statement
+                  - kind: lexical_declaration
+                  - kind: variable_declaration
+                  - kind: expression_statement
+                  - kind: for_statement
+                  - kind: for_in_statement
+                  - kind: while_statement
+                  - kind: switch_statement
+                  - kind: try_statement

package/rules/store-new-map-tsx.yml

@@ -0,0 +1,84 @@
+# ── the .tsx half of `store-new-map` ──
+#
+# ast-grep's `typescript` and `tsx` languages are DISJOINT: a `language:
+# typescript` rule reads .ts and never .tsx. `demo-mode-by-default-ts.yml`
+# records this repo learning that the hard way, so it is measured here rather
+# than assumed — 30 .tsx files in the park call make(Auto)Observable, and the
+# five twins with hits add 29 findings the .ts halves cannot see.
+#
+# Keep this file's `rule:` block IDENTICAL to `store-new-map.yml`.
+# Suppressing needs THIS id: `ast-grep-ignore: store-new-map-tsx`.
+#
+# ── wave 1, store rule 3 of 7 ──────────────────────────────────────────
+#
+# A plain `new Map()` held as a store field. `makeAutoObservable` makes the FIELD
+# observable — reassigning it notifies — but not the map's contents: `.set()`
+# and `.delete()` mutate in place and no observer wakes up. The usual symptom is
+# a cache that updates and a UI that does not, "fixed" by reassigning a fresh
+# Map on every write.
+#
+# The negative that matters is the legal one, and it is why this rule reads the
+# annotation object rather than just the initializer: a field explicitly
+# annotated `{ _cache: false }` is deliberately NOT observable — a private
+# memo/dedup cache nothing renders from. That is a correct pattern and must stay
+# silent. A shared `$FIELD` metavariable ties the field's name to the annotation
+# entry, so the check is per-field rather than per-class.
+id: store-new-map-tsx
+language: tsx
+severity: warning
+ignores:
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+message: |
+  A plain `Map` as an observable store field. The field reference is
+  observable; the map's CONTENTS are not — `.set()` and `.delete()` mutate in
+  place and notify nobody, so anything rendering from this map silently stops
+  updating.
+  Use `observable.map()`, whose mutations are tracked:
+    entries = new Map<string, Row>()  →  entries = observable.map<string, Row>()
+  If this is a private cache nothing renders from, say so in the annotation and
+  the rule steps aside:
+    makeAutoObservable(this, { _cache: false })
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: public_field_definition
+    - has:
+        field: name
+        pattern: $FIELD
+    - has:
+        field: value
+        kind: new_expression
+        has:
+          field: constructor
+          kind: identifier
+          regex: '^Map$'
+    - inside:
+        stopBy: end
+        matches: store-class
+    # Annotated non-observable for this exact field name — the legal escape.
+    - not:
+        inside:
+          stopBy: end
+          kind: class_declaration
+          has:
+            stopBy: end
+            all:
+              - kind: pair
+              - has:
+                  field: key
+                  pattern: $FIELD
+              - has:
+                  field: value
+                  regex: '^false$'

package/rules/store-new-map.yml

@@ -0,0 +1,73 @@
+# ── wave 1, store rule 3 of 7 ──────────────────────────────────────────
+#
+# A plain `new Map()` held as a store field. `makeAutoObservable` makes the FIELD
+# observable — reassigning it notifies — but not the map's contents: `.set()`
+# and `.delete()` mutate in place and no observer wakes up. The usual symptom is
+# a cache that updates and a UI that does not, "fixed" by reassigning a fresh
+# Map on every write.
+#
+# The negative that matters is the legal one, and it is why this rule reads the
+# annotation object rather than just the initializer: a field explicitly
+# annotated `{ _cache: false }` is deliberately NOT observable — a private
+# memo/dedup cache nothing renders from. That is a correct pattern and must stay
+# silent. A shared `$FIELD` metavariable ties the field's name to the annotation
+# entry, so the check is per-field rather than per-class.
+id: store-new-map
+language: typescript
+severity: warning
+ignores:
+  - '**/*.test.ts'
+  - '**/*.spec.ts'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+message: |
+  A plain `Map` as an observable store field. The field reference is
+  observable; the map's CONTENTS are not — `.set()` and `.delete()` mutate in
+  place and notify nobody, so anything rendering from this map silently stops
+  updating.
+  Use `observable.map()`, whose mutations are tracked:
+    entries = new Map<string, Row>()  →  entries = observable.map<string, Row>()
+  If this is a private cache nothing renders from, say so in the annotation and
+  the rule steps aside:
+    makeAutoObservable(this, { _cache: false })
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: public_field_definition
+    - has:
+        field: name
+        pattern: $FIELD
+    - has:
+        field: value
+        kind: new_expression
+        has:
+          field: constructor
+          kind: identifier
+          regex: '^Map$'
+    - inside:
+        stopBy: end
+        matches: store-class
+    # Annotated non-observable for this exact field name — the legal escape.
+    - not:
+        inside:
+          stopBy: end
+          kind: class_declaration
+          has:
+            stopBy: end
+            all:
+              - kind: pair
+              - has:
+                  field: key
+                  pattern: $FIELD
+              - has:
+                  field: value
+                  regex: '^false$'

package/rules/store-no-runinaction-tsx.yml

@@ -0,0 +1,71 @@
+# ── the .tsx half of `store-no-runinaction` ──
+#
+# ast-grep's `typescript` and `tsx` languages are DISJOINT: a `language:
+# typescript` rule reads .ts and never .tsx. `demo-mode-by-default-ts.yml`
+# records this repo learning that the hard way, so it is measured here rather
+# than assumed — 30 .tsx files in the park call make(Auto)Observable, and the
+# five twins with hits add 29 findings the .ts halves cannot see.
+#
+# Keep this file's `rule:` block IDENTICAL to `store-no-runinaction.yml`.
+# Suppressing needs THIS id: `ast-grep-ignore: store-no-runinaction-tsx`.
+#
+# ── wave 1, store rule 1 of 7 ──────────────────────────────────────────
+#
+# The report's gap number 1: the most-repeated store rule in the corpus had no
+# mechanical check at all, and the one script that did grep for it
+# (mobx-models/scripts/lint-mobx.sh) was wired to nothing and has since been
+# deleted.
+#
+# Scoped by the CLASS, not by the path. `**/stores/**` would have been the
+# obvious glob and it is the wrong one twice over: it misses a store that lives
+# beside its feature, and it catches plain helper classes that happen to sit in
+# the folder. "Has a make(Auto)Observable call in it" is the actual definition
+# of the thing the rule is about.
+#
+# Note the callee is matched as an identifier rather than with
+# `pattern: makeAutoObservable($$$)`. A pattern does not match a call carrying
+# explicit type arguments, and SiteCraft writes
+# `makeAutoObservable<this, '_buildTimer' | 'buildManager'>(this, {…})` — which
+# silently cost the whole of project.store.ts, 7 real call sites, until the
+# count came up short against the grep.
+id: store-no-runinaction-tsx
+language: tsx
+severity: error
+ignores:
+  # A test may drive a store's state directly to set up a scenario; that is the
+  # sanctioned way to test a store without a render. All 6 of tg-gallery's
+  # runInAction sites are tests, which is why the report counts it as 0.
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**'
+utils:
+  store-class:
+    kind: class_declaration
+    has:
+      stopBy: end
+      kind: call_expression
+      has:
+        field: function
+        kind: identifier
+        regex: '^make(Auto)?Observable$'
+message: |
+  `runInAction` inside a store class. Every method is already an action —
+  `makeAutoObservable` made it one — so this wraps an action in an action and
+  buys nothing. Where it appears is the tell: after an `await`, because the
+  continuation of an async method is NOT covered by the method's action, and
+  each `runInAction` is a hand-patched hole in that coverage.
+  Convert the method to a `flow`, which resumes inside an action at every yield
+  and needs no patching:
+    async load() { const x = await f(); runInAction(() => { this.x = x }) }
+    → load = flow(function* (this: Store) { this.x = yield f() })
+  See the mobx-models skill.
+rule:
+  all:
+    - kind: call_expression
+    - has:
+        field: function
+        kind: identifier
+        regex: '^runInAction$'
+    - inside:
+        stopBy: end
+        matches: store-class