vouchington-tooling 0.13.4 → 0.15.0

package/ast-grep/rules/no-three-sequential-awaits.yml

@@ -1,11 +1,12 @@
 id: no-three-sequential-awaits
-language: TypeScript
+language: Tsx
 severity: error
 message: 'Avoid 3 sequential await statements; abstract dependent work or parallelize independent work with Promise.all().'
 files:
   - '**/*.ts'
   - '**/*.mts'
   - '**/*.cts'
+  - '**/*.tsx'
 ignores:
   - '**/*.test.ts'
   - '**/*.test.mts'
@@ -18,19 +19,23 @@ ignores:
   - '**/*.mock.test.cts'
   - '**/*.stories.ts'
   - '**/*.stories.mts'
-  - 'backend/test-helpers/**'
-  - 'test-helpers/**'
-  - 'test-infra/**'
-  - 'web/test-helpers/**'
+  - backend/test-helpers/**
+  - test-helpers/**
+  - test-infra/**
+  - web/test-helpers/**
   - '**/test-helpers/**'
-  - 'playwright/**'
-  - 'playwright/setup/**'
-  - 'integration-tests/**'
-  - 'seed/**'
+  - playwright/**
+  - playwright/setup/**
+  - integration-tests/**
+  - seed/**
   - '**/seeds/**'
-  - 'backend/scripts/seeds/**'
-  - 'backend/scripts/seed/**'
-  - 'backend/scripts/explain-analyze/**'
+  - backend/scripts/seeds/**
+  - backend/scripts/seed/**
+  - backend/scripts/explain-analyze/**
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/*.mock.test.tsx'
+  - '**/*.stories.tsx'
 rule:
   all:
     - not:
@@ -45,6 +50,10 @@ rule:
                 - pattern:
                     context: await $P
                     selector: expression_statement
+                - not:
+                    pattern: await params
+                - not:
+                    pattern: await searchParams
                 - not:
                     has:
                       pattern: Promise.all($$)
@@ -53,18 +62,30 @@ rule:
                       pattern: Promise.allSettled($$)
             - all:
                 - pattern: const $W = await $P
+                - not:
+                    pattern: const $W = await params
+                - not:
+                    pattern: const $W = await searchParams
                 - not:
                     pattern: const $W = await Promise.all($$$)
                 - not:
                     pattern: const $W = await Promise.allSettled($$$)
             - all:
                 - pattern: let $W = await $P
+                - not:
+                    pattern: let $W = await params
+                - not:
+                    pattern: let $W = await searchParams
                 - not:
                     pattern: let $W = await Promise.all($$$)
                 - not:
                     pattern: let $W = await Promise.allSettled($$$)
             - all:
                 - pattern: var $W = await $P
+                - not:
+                    pattern: var $W = await params
+                - not:
+                    pattern: var $W = await searchParams
                 - not:
                     pattern: var $W = await Promise.all($$$)
                 - not:
@@ -73,6 +94,10 @@ rule:
                 - pattern:
                     context: $W = await $P
                     selector: expression_statement
+                - not:
+                    pattern: $W = await params
+                - not:
+                    pattern: $W = await searchParams
                 - not:
                     pattern: $W = await Promise.all($$$)
                 - not:
@@ -86,6 +111,10 @@ rule:
             - pattern:
                 context: await $A
                 selector: expression_statement
+            - not:
+                pattern: await params
+            - not:
+                pattern: await searchParams
             - not:
                 has:
                   pattern: Promise.all($$)
@@ -94,18 +123,30 @@ rule:
                   pattern: Promise.allSettled($$)
         - all:
             - pattern: const $X = await $A
+            - not:
+                pattern: const $X = await params
+            - not:
+                pattern: const $X = await searchParams
             - not:
                 pattern: const $X = await Promise.all($$$)
             - not:
                 pattern: const $X = await Promise.allSettled($$$)
         - all:
             - pattern: let $X = await $A
+            - not:
+                pattern: let $X = await params
+            - not:
+                pattern: let $X = await searchParams
             - not:
                 pattern: let $X = await Promise.all($$$)
             - not:
                 pattern: let $X = await Promise.allSettled($$$)
         - all:
             - pattern: var $X = await $A
+            - not:
+                pattern: var $X = await params
+            - not:
+                pattern: var $X = await searchParams
             - not:
                 pattern: var $X = await Promise.all($$$)
             - not:
@@ -114,6 +155,10 @@ rule:
             - pattern:
                 context: $X = await $A
                 selector: expression_statement
+            - not:
+                pattern: $X = await params
+            - not:
+                pattern: $X = await searchParams
             - not:
                 pattern: $X = await Promise.all($$$)
             - not:
@@ -126,6 +171,10 @@ rule:
                   - pattern:
                       context: await $B
                       selector: expression_statement
+                  - not:
+                      pattern: await params
+                  - not:
+                      pattern: await searchParams
                   - not:
                       has:
                         pattern: Promise.all($$)
@@ -134,18 +183,30 @@ rule:
                         pattern: Promise.allSettled($$)
               - all:
                   - pattern: const $Y = await $B
+                  - not:
+                      pattern: const $Y = await params
+                  - not:
+                      pattern: const $Y = await searchParams
                   - not:
                       pattern: const $Y = await Promise.all($$$)
                   - not:
                       pattern: const $Y = await Promise.allSettled($$$)
               - all:
                   - pattern: let $Y = await $B
+                  - not:
+                      pattern: let $Y = await params
+                  - not:
+                      pattern: let $Y = await searchParams
                   - not:
                       pattern: let $Y = await Promise.all($$$)
                   - not:
                       pattern: let $Y = await Promise.allSettled($$$)
               - all:
                   - pattern: var $Y = await $B
+                  - not:
+                      pattern: var $Y = await params
+                  - not:
+                      pattern: var $Y = await searchParams
                   - not:
                       pattern: var $Y = await Promise.all($$$)
                   - not:
@@ -154,6 +215,10 @@ rule:
                   - pattern:
                       context: $Y = await $B
                       selector: expression_statement
+                  - not:
+                      pattern: $Y = await params
+                  - not:
+                      pattern: $Y = await searchParams
                   - not:
                       pattern: $Y = await Promise.all($$$)
                   - not:
@@ -173,6 +238,10 @@ rule:
                     - pattern:
                         context: await $C
                         selector: expression_statement
+                    - not:
+                        pattern: await params
+                    - not:
+                        pattern: await searchParams
                     - not:
                         has:
                           pattern: Promise.all($$)
@@ -181,18 +250,30 @@ rule:
                           pattern: Promise.allSettled($$)
                 - all:
                     - pattern: const $Z = await $C
+                    - not:
+                        pattern: const $Z = await params
+                    - not:
+                        pattern: const $Z = await searchParams
                     - not:
                         pattern: const $Z = await Promise.all($$$)
                     - not:
                         pattern: const $Z = await Promise.allSettled($$$)
                 - all:
                     - pattern: let $Z = await $C
+                    - not:
+                        pattern: let $Z = await params
+                    - not:
+                        pattern: let $Z = await searchParams
                     - not:
                         pattern: let $Z = await Promise.all($$$)
                     - not:
                         pattern: let $Z = await Promise.allSettled($$$)
                 - all:
                     - pattern: var $Z = await $C
+                    - not:
+                        pattern: var $Z = await params
+                    - not:
+                        pattern: var $Z = await searchParams
                     - not:
                         pattern: var $Z = await Promise.all($$$)
                     - not:
@@ -201,6 +282,10 @@ rule:
                     - pattern:
                         context: $Z = await $C
                         selector: expression_statement
+                    - not:
+                        pattern: $Z = await params
+                    - not:
+                        pattern: $Z = await searchParams
                     - not:
                         pattern: $Z = await Promise.all($$$)
                     - not:
@@ -409,3 +494,126 @@ examples:
       }
     isValid: false
     file: 'backend/services/example.mts'
+  - code: |
+      async function run() {
+        await one()
+        await two()
+        await three()
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        const { id } = await params
+        const topic = await getTopic(id)
+        const aliases = await getAliases(id)
+        return <div>{topic.name}{aliases.length}</div>
+      }
+    isValid: true
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await Promise.all([one(), two(), three()])
+        return <div />
+      }
+    isValid: true
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginTransaction()
+        await applyChange(transaction)
+        await transaction.commit()
+        return <div />
+      }
+    isValid: true
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginBoundedTransaction({ timeoutMs: 1000 })
+        await applyFirstChange(transaction)
+        await applySecondChange(transaction)
+        await transaction.commit()
+        return <div />
+      }
+    isValid: true
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginTransaction()
+        await applyFirstChange(transaction)
+        await applySecondChange(transaction)
+        await applyThirdChange(transaction)
+        await transaction.commit()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await unrelatedFirst()
+        await unrelatedSecond()
+        await unrelatedThird()
+        await using transaction = await beginTransaction()
+        await applyChange(transaction)
+        await transaction.commit()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginTransaction()
+        await applyFirstChange(transaction)
+        await applySecondChange(transaction)
+        await other.commit()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginTransaction()
+        await applyChange(transaction)
+        await transaction.commit()
+        await afterFirst()
+        await afterSecond()
+        await afterThird()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using outer = await acquire()
+        {
+          await using inner = await acquire()
+          await innerFirst(inner)
+          await innerSecond(inner)
+          await innerThird(inner)
+          await inner.commit()
+        }
+        await outer.commit()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using transaction = await beginTransaction()
+        await applyFirstChange(transaction)
+        await applySecondChange(transaction)
+        await transaction.rollback()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx
+  - code: |
+      async function run() {
+        await using resource = await acquire()
+        await useFirst(resource)
+        await useSecond(resource)
+        await resource.dispose()
+        return <div />
+      }
+    isValid: false
+    file: web/app/example.tsx

package/ast-grep/rules/nullable-options.yml

@@ -1,5 +1,5 @@
 id: nullable-options
-language: TypeScript
+language: Tsx
 severity: error
 message: >-
   This helper option member is declared optional-nullable (`T | null` with `?`), so a bare `??`/`||`

package/ast-grep/rules/pagination-no-exact-limit-has-next.yml

@@ -1,5 +1,5 @@
 id: pagination-no-exact-limit-has-next
-language: TypeScript
+language: Tsx
 severity: error
 message: 'Do not infer another page from an exact page-size boundary; fetch limit + 1 and test rows.length > limit.'
 files:

package/ast-grep/rules/playwright-no-bare-meta-press.yml

@@ -1,5 +1,5 @@
 id: playwright-no-bare-meta-press
-language: TypeScript
+language: Tsx
 severity: error
 message: "use 'ControlOrMeta+' instead of 'Meta+' in Playwright .press() calls; bare Meta+ fails on Linux CI"
 files:

package/ast-grep/rules/storybook-no-webpack-final.yml

@@ -1,5 +1,5 @@
 id: storybook-no-webpack-final
-language: TypeScript
+language: Tsx
 severity: error
 message: 'Storybook must use viteFinal, not webpackFinal; this project uses @storybook/nextjs-vite'
 files:

package/ast-grep/sgconfig.yml

@@ -1,9 +1,8 @@
 ruleDirs:
   - rules
 languageGlobs:
-  TypeScript:
+  Tsx:
     - '**/*.ts'
     - '**/*.mts'
     - '**/*.cts'
-  Tsx:
     - '**/*.tsx'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.13.4",
+  "version": "0.15.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {

package/skills/agent-workflow/SKILL.md

@@ -22,9 +22,12 @@ branching, review, and release policy.
    checks with a concrete reason.
 6. Review the diff for accidental files, secrets, generated output, broken documentation links,
    and assumptions that belong in local instructions instead.
+7. When feedback arrives on an open change, give every surfaced item a disposition and drive it to
+   closure before hand-off; do not leave items unaddressed or silently absorb or defer them.
 
 For portable implementation and review checks, read [implementation](references/implementation.md),
-[review](references/review.md), and [evidence sweep](references/evidence-sweep.md). The older
+[review](references/review.md), [review response](references/review-response.md), and
+[evidence sweep](references/evidence-sweep.md). The older
 [implementation and review](references/implementation-and-review.md) remains a compact overview.
 Local instructions remain authoritative for commands, commits, review systems, and release policy.
 

package/skills/agent-workflow/references/review-response.md

@@ -0,0 +1,32 @@
+# Review response
+
+Applies when responding to feedback on an open change — a human reviewer, an automated reviewer, or
+a shepherding tool that surfaces both. This is the response side of [review](review.md); its closing
+line, to record unresolved risk as an explicit decision or follow-up and never as an unnoticed gap,
+is what the ladder below operationalizes.
+
+Give every surfaced item exactly one disposition before its resolution runs, recorded where the
+review conversation lives. Invalid — wrong, already satisfied by the current diff, or out of an
+already-settled scope — gets a reason and closes with no code change and no follow-up. Blocking —
+correctness, security, data safety, or a gap against a linked requirement — gets fixed, pushed, and
+confirmed on the change's head commit before closing; closing first can leave an unfixed commit
+behind a closed conversation. Non-blocking gets folded into an already-planned push when the fix is
+cheap and low-risk, and otherwise gets recorded as a follow-up only when leaving it undone would
+change behavior, structure, or risk: reuse or extend an existing follow-up before opening a new one,
+and group related items from the same round into one. A correct item that clears none of those bars
+— a style preference, a restatement, polish the change is fine without — is declined with a reason
+and no follow-up; that is the expected outcome for a minor suggestion, not a lapse. Escalate — work
+the change cannot absorb as feedback, such as a large architectural or ownership change — is
+recorded where decisions are tracked and reported for direction rather than implemented or silently
+downgraded to a follow-up.
+
+Read every outstanding item before editing and drain the round locally; the cost of iterating is the
+push, not the commit, because a push re-runs checks and re-triggers automated reviewers. Declining a
+round without pushing is what lets it converge instead of regenerating the same suggestions on every
+cycle. By hand-off, every item carries a disposition and reaches closure — an escalation through its
+decision record rather than an open conversation — except where the review surface itself withholds
+the capability to close an item; say so and leave it rather than forcing a resolution it never
+authorized.
+
+This skill supplies no review system, resolution mechanism, issue tracker, label, or severity
+vocabulary; a consumer wrapper owns those.

package/ast-grep/rules/no-dynamic-server-components-tsx.yml

@@ -1,71 +0,0 @@
-# NOTE: This rule flags calls to `dynamic` or `nextDynamic` (next/dynamic) that use a dynamic import.
-# It cannot verify the import source — it matches by function name.
-# If you have other functions named `dynamic` or `nextDynamic`, add a suppression comment.
-id: no-dynamic-server-components-tsx
-language: Tsx
-severity: error
-message: "dynamic()/nextDynamic() may wrap a server component — ensure the target has 'use client'"
-# NOTE: ast-grep maps `.tsx` to language `Tsx`, not `TypeScript`. This rule
-# only scans `.tsx` files; see no-dynamic-server-components.yml for the
-# companion rule that covers `.ts` files.
-files:
-  - 'web/**/*.tsx'
-ignores:
-  - '**/*.test.tsx'
-  - '**/*.spec.tsx'
-rule:
-  any:
-    - pattern: '$FN(() => import($PATH))'
-    - pattern: '$FN(() => { return import($PATH); })'
-    - pattern: '$FN(() => import($PATH).then($$$))'
-    - pattern: '$FN(() => import($PATH), $OPTS)'
-    - pattern: '$FN(() => { return import($PATH); }, $OPTS)'
-    - pattern: '$FN(() => import($PATH).then($$$), $OPTS)'
-constraints:
-  FN:
-    regex: '^(dynamic|nextDynamic)$'
-  PATH:
-    regex: "^['\"`](\\.\\./|\\./|@/)"
-  # NOTE: `$OPTS` is only bound by the two-argument pattern arms above. This
-  # `not` constraint filters out `{ ssr: false }` only for those arms; the
-  # single-argument dynamic import arms still match and remain violations.
-  OPTS:
-    not:
-      regex: '(?:\bssr\b|[''"]ssr[''"])\s*:\s*false\b'
-examples:
-  - code: "const Comp = dynamic(() => import('./my-component'))"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: 'const Comp = dynamic(() => import(`./my-component`))'
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('../components/comp'))"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./add-tag-form').then(m => ({ default: m.AddTagForm })))"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = nextDynamic(() => import('./my-component'))"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./c'), { loading: () => null })"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./c'), { not_ssr: false })"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./c'), { ssr: falsey })"
-    isValid: false
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./c'), { ssr: false })"
-    isValid: true
-    file: 'web/app/page.tsx'
-  - code: 'const Comp = dynamic(() => import("./c"), { "ssr": false })'
-    isValid: true
-    file: 'web/app/page.tsx'
-  - code: "const Comp = dynamic(() => import('./c'), { 'ssr': false })"
-    isValid: true
-    file: 'web/app/page.tsx'
-  - code: "const Comp = lazy(() => import('./my-component'))"
-    isValid: true
-    file: 'web/app/page.tsx'

package/ast-grep/rules/no-enable-indexscan-off-tsx.yml

@@ -1,33 +0,0 @@
-# NOTE: ast-grep maps `.tsx` to language `Tsx`, not `TypeScript`. This rule
-# only scans `.tsx` files; see no-enable-indexscan-off.yml for the companion
-# rule that covers `.ts/.mts/.cts` files.
-id: no-enable-indexscan-off-tsx
-language: Tsx
-severity: error
-message: >-
-  Do not use `enable_indexscan = off` — it disables index scans repo-wide within the transaction
-  (not just for HNSW vector search), forcing a full sequential scan. For HNSW overfiltering on a
-  small hard-capped result window, use `applyFilteredVectorScan()` from `@modules/search-utils`
-  (pgvector `hnsw.iterative_scan`) instead.
-rule:
-  any:
-    - kind: string
-    - kind: template_string
-  regex: '(?i)enable_indexscan[\s\S]{0,12}(=|to)[\s\S]{0,12}off'
-examples:
-  - code: |-
-      import sql from 'sql-template-strings'
-      export const query = sql`SET LOCAL enable_indexscan = off`
-    isValid: false
-    file: 'web/lib/__tests__/example.tsx'
-  - code: |-
-      import sql from 'sql-template-strings'
-      export const query = sql`SET LOCAL enable_indexscan TO off`
-    isValid: false
-    file: 'web/lib/__tests__/example.tsx'
-  - code: |-
-      export function Example() {
-        return <div>hnsw.iterative_scan = strict_order</div>
-      }
-    isValid: true
-    file: 'web/components/example.tsx'

package/ast-grep/rules/no-exports-in-tests-folder-tsx.yml

@@ -1,42 +0,0 @@
-# NOTE: `__tests__` directories must contain tests only. Shared helpers, registries,
-# fixtures, and other imported support modules belong in a nearby `test-helpers/`
-# directory so test roots stay easy to scan.
-# NOTE: ast-grep maps `.tsx` to language `Tsx`, not `TypeScript`. This rule
-# only scans `.tsx` files; see no-exports-in-tests-folder.yml for the companion
-# rule that covers `.ts/.mts/.cts` files.
-id: no-exports-in-tests-folder-tsx
-language: Tsx
-severity: error
-message: 'Do not export from files under __tests__; move shared test support to a test-helpers directory.'
-files:
-  - '**/__tests__/**/*.tsx'
-rule:
-  all:
-    - kind: export_statement
-    - not:
-        pattern: export {}
-examples:
-  - code: |
-      export function renderThing() {
-        return <div />
-      }
-    isValid: false
-    file: 'web/components/example/__tests__/comment-tree-test-helpers.tsx'
-  - code: 'export type RenderThing = () => JSX.Element'
-    isValid: false
-    file: 'web/components/__tests__/render-helpers.tsx'
-  - code: |
-      it('renders shell exports', () => {
-        expect(`export NEXT_PORT=3901`).toContain('export')
-      })
-    isValid: true
-    file: 'web/components/example/__tests__/comment-tree.test.tsx'
-  - code: |
-      function renderThing() {
-        return <div />
-      }
-    isValid: true
-    file: 'web/components/example/__tests__/comment-tree.test.tsx'
-  - code: 'export {}'
-    isValid: true
-    file: 'web/components/example/__tests__/global-jsx.test.tsx'

package/ast-grep/rules/no-self-comparison-assertion-tsx.yml

@@ -1,43 +0,0 @@
-id: no-self-comparison-assertion-tsx
-language: Tsx
-severity: error
-message: 'This compares an expression against itself (e.g. expect(result.id).toBe(result.id)). ast-grep metavariables enforce identical text, so both sides read the same value the same way; nearly every real occurrence of this shape is a copy-paste bug where the second operand should have been an independently derived expected value. Compare against that instead, or a fixture-provided value the code under test did not produce. (Two syntactic shapes are exempted because they cannot be tautological by construction: an expression containing a call anywhere in it, e.g. expect(f(a)).toBe(f(a)) or expect((await load()).id).toBe((await load()).id), is a fresh invocation on each side and legitimately tests that the call is deterministic/pure; and a postfix/prefix increment or decrement, e.g. expect(index++).toBe(index++), advances state between the two reads. A getter or other stateful property access is NOT exempted -- ast-grep cannot see whether a given `.foo` is a plain field or a getter with side effects, and every real violation this rule has caught in this repo is a plain field, so this stays flagged by design; if you are deliberately asserting that such an accessor is stable across two reads, add an `ast-grep-ignore: no-self-comparison-assertion-tsx` comment with that rationale instead of weakening this rule.)'
-files:
-  - '**/*.test.tsx'
-  - '**/*.spec.tsx'
-rule:
-  pattern: 'expect($X).toBe($X)'
-constraints:
-  X:
-    not:
-      any:
-        - kind: 'true'
-        - kind: 'false'
-        - kind: 'number'
-        - kind: 'string'
-        - kind: 'null'
-        - kind: 'undefined'
-        - kind: 'call_expression'
-        - kind: 'update_expression'
-        - has:
-            kind: 'call_expression'
-            stopBy: end
-examples:
-  - code: 'expect(item.id).toBe(item.id)'
-    isValid: false
-    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
-  - code: 'expect(item.id).toBe(expectedId)'
-    isValid: true
-    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
-  - code: 'expect(formatItemLabel(item)).toBe(formatItemLabel(item))'
-    isValid: true
-    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
-  - code: 'expect((await loadItem()).id).toBe((await loadItem()).id)'
-    isValid: true
-    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'
-  - code: 'expect(item.id).toBe(item.id)'
-    isValid: true
-    file: 'web/components/example/add-to-list-menu-item.tsx'
-  - code: 'expect(index++).toBe(index++)'
-    isValid: true
-    file: 'web/components/example/__tests__/add-to-list-menu-item.mock.test.tsx'