belt 0.6.9 → 0.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7f8eec96efe780f5d58b8242c0f2c4a8d6dc0e46f53e4484d1b10072ab059aa
-  data.tar.gz: a065c3fbd7b2a5ada177a4b516a07314408988c53e498e302e88b0903c01029c
+  metadata.gz: b3fc587d6980e4a754477a032f264e7f36de83898b451b0134741e7ccbe46706
+  data.tar.gz: 34797d0fa6c1e05d3873a57ec3d2219c9c9fcea4cc13c443ed17c5d1b509b550
 SHA512:
-  metadata.gz: 3aca3754425f363160d92b60b9385a8b3efaada2a4182e059361acf42e6763001ee9f53834386705e5b638a54c32e2608025f154a284e3280053de096558f99e
-  data.tar.gz: 4c314ee70436b6fd009493051349e83e2986956d0e42f7cf22d3a55461ad7f05024aecc7901428da8873fba8d1e0c5c03bf6559763a098c4822b3dadec105945
+  metadata.gz: 52ef8567694bcae88ca060b71f04e8ba4deb9766c1e99971bdb52ba3bcbdc66f9e54abc7fc888681bd37d90b2d7ada71de602484929c8dadfa97a58a3456bf15
+  data.tar.gz: 6ff546e948f0dd67b25d9386e7db16c10a7b4fb7387594c608dfb898d567ee947cf0c50e6999275fe8a170b15944d77a45a40f6a56d7f763a8235b41b41a3a7f

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.6.10
+
+### Changed
+
+- **SEO prerender is a belt deploy step, not app code.** `belt deploy frontend`
+  now prerenders any frontend with a `src/seo.js` manifest after `npm run build`:
+  it builds `src/entry-server.*` with `vite build --ssr` (when present) and writes
+  per-page HTML (title, description, canonical, Open Graph, JSON-LD),
+  `robots.txt`, `sitemap.xml` and `llms.txt` into the build output, so the
+  `--delete` sync reproduces them on every deploy. The script ships in the gem
+  (`lib/belt/frontend/prerender.mjs`), so existing apps opt in with just a
+  manifest instead of copying `scripts/prerender.js`. New React frontends build
+  with plain `vite build`. Frontends whose build already prerenders (0.6.6–0.6.9
+  templates) are detected and skipped; frontends without `src/seo.js` deploy as
+  before. (Fizzy #1930)
+
+### Added
+
+- **`belt frontend prerender [--frontend NAME]`** builds a frontend and runs the
+  SEO prerender locally.
+- **`public/robots.txt` overrides the generated robots.txt** in indexable
+  environments. Non-indexable environments still get `Disallow: /`.
+
 ## 0.6.9
 
 ### Fixed

data/lib/belt/cli/frontend_deploy_command.rb

@@ -7,6 +7,7 @@ require_relative 'app_detection'
 require_relative 'env_resolver'
 require_relative 'environment_config'
 require_relative 'frontend_env_map'
+require_relative 'frontend_prerender'
 require_relative 'frontend_registry'
 require_relative 'terraform_command'
 
@@ -15,7 +16,7 @@ module Belt
     class FrontendDeployCommand
       include AppDetection
 
-      PAGES_MANIFEST = '.belt-pages.json'
+      PAGES_MANIFEST = FrontendPrerender::PAGES_MANIFEST
       # Uploaded with no-cache instead of the immutable header hashed assets get
       REVALIDATED_FILES = %w[*.html robots.txt sitemap.xml llms.txt].freeze
 
@@ -112,9 +113,10 @@ module Belt
         env = frontend_build_env
         puts "   Injecting env: #{env.keys.sort.join(', ')}" if env.any?
         run!(env, 'npm', 'run', 'build', chdir: @frontend.path)
+        FrontendPrerender.new(@frontend, env: env).run
       end
 
-      # BELT_ENV and VITE_SITE_URL drive the SEO prerender step (scripts/prerender.js):
+      # BELT_ENV and VITE_SITE_URL drive the SEO prerender step (FrontendPrerender):
       # only indexable environments get crawled, and canonical/sitemap URLs need the
       # site's origin. The env map or the shell can override either.
       def frontend_build_env
@@ -162,7 +164,7 @@ module Belt
         upload_prerendered_pages(dist, bucket, pages)
       end
 
-      # scripts/prerender.js writes dist/.belt-pages.json mapping each page's S3 key
+      # The prerender step writes dist/.belt-pages.json mapping each page's S3 key
       # to its file ({ "about" => "about.html" }). CloudFront has no directory
       # indexes, so /about must be an object named `about` served as text/html.
       def prerendered_pages(dist)

data/lib/belt/cli/frontend_env_command.rb

@@ -4,6 +4,7 @@ require_relative 'app_detection'
 require_relative 'env_resolver'
 require_relative 'environment_config'
 require_relative 'frontend_env_map'
+require_relative 'frontend_prerender'
 require_relative 'frontend_registry'
 require_relative 'terraform_command'
 
@@ -11,6 +12,7 @@ module Belt
   module CLI
     # belt frontend env <environment> [--frontend NAME]
     # belt frontend list
+    # belt frontend prerender [--frontend NAME]
     #
     # Smart-merges terraform outputs into <frontend>/.env using the declarative map
     # (<frontend>/env.yml or .belt/frontend_env.yml for the default frontend).
@@ -25,6 +27,8 @@ module Belt
           run_env(args)
         when 'list', 'ls'
           run_list
+        when 'prerender'
+          run_prerender(args)
         when nil, '-h', '--help', 'help'
           puts usage
           exit(subcommand.nil? ? 1 : 0)
@@ -50,6 +54,19 @@ module Belt
         end
       end
 
+      # Local check of the SEO prerender `belt deploy frontend` runs: builds the
+      # frontend and prerenders from src/seo.js. Not indexable unless BELT_ENV or
+      # SEO_INDEXABLE says so; VITE_SITE_URL from the shell sets canonical URLs.
+      def self.run_prerender(args)
+        name = FrontendRegistry.extract_flag!(args, '--frontend') || args.reject { |a| a.start_with?('-') }.first
+        frontend = FrontendRegistry.new.resolve!(name)
+        prerender = FrontendPrerender.new(frontend)
+        abort "No #{frontend.path}/src/seo.js — nothing to prerender. See `belt explain seo`." unless prerender.manifest
+
+        abort "\n✗ npm run build failed in #{frontend.path}/" unless system('npm', 'run', 'build', chdir: frontend.path)
+        prerender.run
+      end
+
       def self.run_env(args)
         frontend_name = FrontendRegistry.extract_flag!(args, '--frontend')
         env = EnvResolver.resolve(args)
@@ -88,6 +105,7 @@ module Belt
           Usage:
             belt frontend env <environment> [--frontend NAME]
             belt frontend list
+            belt frontend prerender [--frontend NAME]   Build + SEO prerender locally (src/seo.js)
             belt frontend --help
 
           Env map (optional, per frontend):

data/lib/belt/cli/frontend_prerender.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+
+module Belt
+  module CLI
+    # Belt-owned SEO/AEO prerender step, run after a frontend's `npm run build`.
+    #
+    # Opt-in by manifest: a frontend with src/seo.js gets per-page HTML (title,
+    # description, canonical, Open Graph, JSON-LD), robots.txt, sitemap.xml and
+    # llms.txt written into its build output, so `aws s3 sync --delete`
+    # reproduces them on every deploy. When src/entry-server.* exists it is built
+    # with `vite build --ssr` and each page's markup is prerendered too. No
+    # manifest → nothing happens.
+    class FrontendPrerender
+      SCRIPT = File.expand_path('../frontend/prerender.mjs', __dir__)
+      MANIFESTS = %w[src/seo.js src/seo.mjs].freeze
+      SSR_ENTRIES = %w[src/entry-server.jsx src/entry-server.tsx src/entry-server.js src/entry-server.ts].freeze
+      # Inside node_modules so the SSR bundle resolves the app's dependencies and
+      # existing apps don't grow an untracked build directory.
+      SSR_OUT_DIR = 'node_modules/.cache/belt-ssr'
+      PAGES_MANIFEST = '.belt-pages.json'
+
+      def initialize(frontend, env: {})
+        @frontend = frontend
+        @env = env
+      end
+
+      def manifest
+        @manifest ||= MANIFESTS.find { |file| File.file?(File.join(@frontend.path, file)) }
+      end
+
+      # Frontends scaffolded by belt 0.6.6–0.6.9 run their own scripts/prerender.js
+      # inside `npm run build`; their output is already in dist.
+      def prerendered_by_build?
+        File.file?(File.join(@frontend.dist_dir, PAGES_MANIFEST))
+      end
+
+      # Returns true when it prerendered, false when the frontend didn't opt in.
+      def run
+        return false unless manifest
+
+        if prerendered_by_build?
+          puts '🔎 SEO: prerendered by the app build (scripts/prerender.js) — skipping belt prerender'
+          return false
+        end
+
+        puts "🔎 SEO: prerendering pages from #{manifest}"
+        ssr = build_ssr_bundle
+        cmd = ['node', SCRIPT,
+               '--manifest', File.expand_path(manifest, @frontend.path),
+               '--dist', File.expand_path(@frontend.dist_dir),
+               '--public', File.expand_path('public', @frontend.path)]
+        cmd.push('--ssr', ssr) if ssr
+        return true if system(@env, *cmd, chdir: @frontend.path)
+
+        abort "\n✗ SEO prerender failed: #{cmd.shelljoin}"
+      end
+
+      private
+
+      # Builds the SSR bundle and returns its entry path, or nil when there's no
+      # entry or it doesn't build (typically a module touching window/document at
+      # import time). Without it, pages still get their tags, sitemap and robots.
+      def build_ssr_bundle
+        entry = SSR_ENTRIES.find { |file| File.file?(File.join(@frontend.path, file)) }
+        return nil unless entry
+
+        out_dir = File.join(@frontend.path, SSR_OUT_DIR)
+        ok = system(@env, 'npx', 'vite', 'build', '--ssr', entry, '--outDir', SSR_OUT_DIR, '--emptyOutDir',
+                    '--logLevel', 'warn', chdir: @frontend.path)
+        unless ok
+          warn "⚠️  SSR build of #{entry} failed — pages get SEO tags but no prerendered content"
+          return nil
+        end
+
+        # Vite emits ESM; make sure Node loads it as such whatever the app's package type.
+        File.write(File.join(out_dir, 'package.json'), "#{JSON.generate(type: 'module')}\n")
+        name = File.basename(entry, '.*')
+        bundle = %w[.js .mjs].map { |ext| File.join(out_dir, "#{name}#{ext}") }.find { |f| File.file?(f) }
+        bundle && File.expand_path(bundle)
+      end
+    end
+  end
+end

data/lib/belt/cli.rb

@@ -166,6 +166,7 @@ module Belt
           dns show                                    Show root zone name servers for registrar
           frontend env <env> [--frontend NAME]        Write <frontend>/.env from terraform outputs
           frontend list                               List configured frontends
+          frontend prerender [--frontend NAME]        Build + SEO prerender a frontend locally
           routes [-g PATTERN] [-f json]               Show route definitions
           contracts [-g PATTERN] [-f json]            Show API request/response contracts
           lambda-config [-e ENV] [-f json|terraform]  Show merged lambda configuration

data/lib/belt/docs/frontend.md

@@ -89,27 +89,47 @@ fallback. See the existing env-map behavior: only mapped keys are written into
 
 Search crawlers and AI answer engines (ChatGPT, Claude, Perplexity, Google AI)
 mostly don't run JavaScript, so an SPA that ships an empty `<div id="root">` is
-invisible to them. React frontends from `belt generate frontend react` prerender
-their public pages at build time:
+invisible to them. Belt prerenders public pages as part of `belt deploy frontend`.
+It's opt-in by manifest — the app owns the content, belt owns the mechanism:
 
 ```
-src/seo.js             # site name/description, public pages, private paths
-src/entry-server.jsx   # renders <App /> at a URL (build time only)
-scripts/prerender.js   # runs at the end of `npm run build`
+src/seo.js             # the manifest: site name/description, public pages, private paths
+src/entry-server.jsx   # optional: exports render(url) → HTML of <App /> at that URL
 ```
 
-For every entry in `seo.pages`, `npm run build` writes real HTML with the page's
-rendered content, `<title>`, meta description, canonical URL, Open Graph tags and
-JSON-LD. It also writes `robots.txt`, `sitemap.xml` (needs a site URL) and
-`llms.txt`. `belt deploy frontend` uploads each page to its extensionless S3 key
-(`/pricing` → `pricing`, served as `text/html`) and serves HTML and crawler files
-with `no-cache`.
+React frontends from `belt generate frontend react` ship both. Any other Vite
+frontend opts in by adding `src/seo.js` (same shape as the React template's). A
+frontend without one deploys exactly as before.
+
+After `npm run build`, belt builds `src/entry-server.*` with `vite build --ssr`
+(into `node_modules/.cache/belt-ssr`) and, for every entry in `seo.pages`, writes
+real HTML into the build output with the page's rendered content, `<title>`, meta
+description, canonical URL, Open Graph tags and JSON-LD. It also writes
+`robots.txt`, `sitemap.xml` (from the same page list; needs a site URL) and
+`llms.txt`. No SSR entry, or one that fails to build, still gets the tags,
+sitemap and robots — just no prerendered content. Because it all lands in the
+build output, every deploy's `s3 sync --delete` reproduces it; nothing is
+uploaded out of band. Each page goes to its extensionless S3 key (`/pricing` →
+`pricing`, served as `text/html`), and HTML and crawler files are served with
+`no-cache`.
+
+`robots.txt`: in indexable environments a project `public/robots.txt` is used
+verbatim; otherwise belt generates `Allow: /`, a `Disallow:` per private path and
+the `Sitemap:` line. Non-indexable environments always get `Disallow: /`.
+
+Preview locally with `belt frontend prerender [--frontend NAME]` (builds, then
+prerenders into `dist/`). Frontends scaffolded by belt 0.6.6–0.6.9 prerender inside
+`npm run build` (`scripts/prerender.js`); belt sees their `dist/.belt-pages.json`
+and skips its own step.
 
 **When you add a public route, add it to `seo.pages`** with a specific title and a
 one- or two-sentence description that says plainly what the page is. Login-gated
 routes go in `privatePaths`. Components on public pages must render without
 `window`/`document`/`localStorage` — touch those in `useEffect`. A page that throws
-during prerender still gets its tags, but no content, and the build warns.
+during prerender still gets its tags, but no content, and the deploy warns.
+The SSR build uses the app's `vite.config.js`, so a library that touches the
+browser at import time (Cognito/Amplify, analytics) can be stubbed with a plugin
+that only applies when `isSsrBuild` is true — public pages render signed-out.
 
 Only environments in `seo.indexableEnvironments` (default `['prod']`) are
 indexable; every other environment and local builds ship `Disallow: /` and

data/lib/{templates/frontend/react/scripts/prerender.js → belt/frontend/prerender.mjs}

@@ -1,31 +1,51 @@
 /**
- * Post-build SEO/AEO step (runs as part of `npm run build`).
+ * Belt's SEO/AEO prerender step. `belt deploy frontend` (and `belt frontend
+ * prerender`) run it after `npm run build` for any frontend with a src/seo.js
+ * manifest. The app owns the content (seo.js); belt owns the mechanism.
  *
  * Search and AI answer-engine crawlers mostly don't run JavaScript, so an SPA's
- * empty <div id="root"> tells them nothing. Using src/seo.js, this writes into dist/:
+ * empty <div id="root"> tells them nothing. From the manifest this writes into dist/:
  *
- *   index.html, <path>.html  — each page in seo.pages rendered to HTML (via
- *                              dist-ssr/entry-server.js) with its own <title>,
- *                              description, canonical URL, Open Graph tags and JSON-LD
- *   robots.txt               — allows crawlers in indexable environments, `Disallow: /` elsewhere
+ *   index.html, <path>.html  — each page in seo.pages rendered to HTML (via the SSR
+ *                              bundle of src/entry-server.*, when there is one) with its
+ *                              own <title>, description, canonical URL, Open Graph tags
+ *                              and JSON-LD
+ *   robots.txt               — allows crawlers in indexable environments, `Disallow: /`
+ *                              elsewhere. A project public/robots.txt wins when indexable.
  *   sitemap.xml              — every public page (needs a site URL)
  *   llms.txt                 — plain-text site summary for LLMs (https://llmstxt.org)
  *   .belt-pages.json         — S3 key → file map; `belt deploy frontend` uploads each page
  *                              to its extensionless key (/about → about.html) as text/html
  *
+ * Usage: node prerender.mjs --manifest src/seo.js --dist dist [--ssr entry-server.js] [--public public]
+ *
  * Environment:
  *   VITE_SITE_URL   canonical origin (belt deploy injects the frontend URL)
  *   BELT_ENV        environment being built (belt deploy injects it)
  *   SEO_INDEXABLE   "true"/"false" to override seo.indexableEnvironments
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import seo from '../src/seo.js'
+import { dirname, join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { parseArgs } from 'node:util'
+
+const { values: args } = parseArgs({
+  options: {
+    manifest: { type: 'string' },
+    dist: { type: 'string' },
+    ssr: { type: 'string' },
+    public: { type: 'string' }
+  }
+})
+if (!args.manifest || !args.dist) {
+  console.error('Usage: node prerender.mjs --manifest src/seo.js --dist dist [--ssr entry-server.js] [--public public]')
+  process.exit(1)
+}
 
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
-const DIST = join(ROOT, 'dist')
-const SSR_ENTRY = join(ROOT, 'dist-ssr', 'entry-server.js')
+const DIST = resolve(args.dist)
+const SSR_ENTRY = args.ssr ? resolve(args.ssr) : null
+const PROJECT_ROBOTS = args.public ? join(resolve(args.public), 'robots.txt') : null
+const seo = (await import(pathToFileURL(resolve(args.manifest)).href)).default
 
 const siteUrl = (process.env.VITE_SITE_URL || seo.siteUrl || '').replace(/\/+$/, '')
 const indexable = process.env.SEO_INDEXABLE
@@ -44,6 +64,7 @@ const escapeHtml = (s) =>
 const absolute = (path) => `${siteUrl}${path === '/' ? '/' : path}`
 
 async function loadRenderer() {
+  if (!SSR_ENTRY) return null
   if (!existsSync(SSR_ENTRY)) {
     console.warn(`⚠️  ${SSR_ENTRY} not found — pages get SEO tags but no prerendered content`)
     return null
@@ -116,6 +137,7 @@ function pageHtml(template, page, body) {
 
 function robotsTxt() {
   if (!indexable) return 'User-agent: *\nDisallow: /\n'
+  if (PROJECT_ROBOTS && existsSync(PROJECT_ROBOTS)) return readFileSync(PROJECT_ROBOTS, 'utf-8')
   const lines = ['User-agent: *', 'Allow: /', ...privatePaths.map((p) => `Disallow: ${p}`)]
   if (siteUrl) lines.push('', `Sitemap: ${siteUrl}/sitemap.xml`)
   return `${lines.join('\n')}\n`
@@ -135,7 +157,7 @@ function llmsTxt() {
 async function main() {
   const indexFile = join(DIST, 'index.html')
   if (!existsSync(indexFile)) {
-    console.error('dist/index.html not found — run `vite build` first')
+    console.error(`${indexFile} not found — run \`vite build\` first`)
     process.exit(1)
   }
   if (!pages.some((page) => page.path === '/')) pages.unshift({ path: '/', title: seo.siteName })
@@ -162,6 +184,7 @@ async function main() {
   writeFileSync(join(DIST, 'llms.txt'), llmsTxt())
   if (siteUrl) writeFileSync(join(DIST, 'sitemap.xml'), sitemapXml())
 
+  if (PROJECT_ROBOTS && indexable && existsSync(PROJECT_ROBOTS)) console.log('SEO: robots.txt from public/robots.txt')
   if (!siteUrl) console.warn('⚠️  No site URL (VITE_SITE_URL or seo.siteUrl) — skipped canonical URLs and sitemap.xml')
   console.log(
     `SEO: prerendered ${pages.length} page(s), ${indexable ? 'indexable' : 'noindex'}` +
@@ -169,4 +192,4 @@ async function main() {
   )
 }
 
-main()
+await main()

data/lib/belt/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.6.9'
+  VERSION = '0.6.10'
 
   # Ruby version new apps run on in Lambda. Rendered into the conveyor-belt
   # provider block (`ruby_version`) by `belt new` / `belt generate environment`.

data/lib/templates/frontend/react/package.json.erb

@@ -5,7 +5,7 @@
   "type": "module",
   "scripts": {
     "dev": "vite",
-    "build": "vite build && vite build --ssr src/entry-server.jsx --outDir dist-ssr && node scripts/prerender.js",
+    "build": "vite build",
     "preview": "vite preview"
   },
   "dependencies": {

data/lib/templates/frontend/react/src/entry-server.jsx

@@ -2,7 +2,8 @@ import { renderToString } from 'react-dom/server'
 import { StaticRouter } from 'react-router-dom/server'
 import App from './App'
 
-// Build-time render used by scripts/prerender.js — not shipped to the browser.
+// Build-time render used by belt's SEO prerender (`belt deploy frontend`) — not
+// shipped to the browser.
 export function render(url) {
   return renderToString(
     <StaticRouter location={url}>

data/lib/templates/frontend/react/src/seo.js.erb

@@ -1,10 +1,11 @@
 // SEO/AEO config — what search engines and AI answer engines (Google, Bing,
 // ChatGPT, Claude, Perplexity) see. Most of those crawlers don't run JavaScript,
-// so `npm run build` prerenders every page listed here to real HTML.
+// so `belt deploy frontend` prerenders every page listed here to real HTML.
 //
 // For each page the build writes static HTML with its own <title>, description,
 // canonical URL, Open Graph tags and JSON-LD, plus robots.txt, sitemap.xml and
-// llms.txt for the whole site (scripts/prerender.js).
+// llms.txt for the whole site. Preview locally with `belt frontend prerender`.
+// A public/robots.txt replaces the generated one in indexable environments.
 //
 // Rules of thumb:
 //   - Every public route gets an entry in `pages` with a specific title and a

data/lib/templates/new_app/AGENTS.md.erb

@@ -276,8 +276,8 @@ answer engines (`belt explain frontend`). When you add or change a public page:
   `localStorage` during render (use `useEffect`), and no content that only appears
   after an API call if crawlers need to see it.
 - Use one `<h1>` per page and real links (`<Link>`/`<a href>`), not click handlers.
-- Check `npm run build` output: `SEO: prerendered N page(s)` with no warnings, and
-  `dist/<page>.html` contains the content.
+- Run `belt frontend prerender`: expect `SEO: prerendered N page(s)` with no
+  warnings, and `frontend/dist/<page>.html` containing the content.
 
 Only `prod` is indexable; other environments ship `noindex`.
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.6.10
 platform: ruby
 authors:
 - Stowzilla
@@ -137,6 +137,7 @@ files:
 - lib/belt/cli/frontend_deploy_command.rb
 - lib/belt/cli/frontend_env_command.rb
 - lib/belt/cli/frontend_env_map.rb
+- lib/belt/cli/frontend_prerender.rb
 - lib/belt/cli/frontend_registry.rb
 - lib/belt/cli/frontend_setup_command.rb
 - lib/belt/cli/generate_command.rb
@@ -179,6 +180,7 @@ files:
 - lib/belt/docs/structure.md
 - lib/belt/docs/testing.md
 - lib/belt/errors.rb
+- lib/belt/frontend/prerender.mjs
 - lib/belt/helpers/cors_origin.rb
 - lib/belt/helpers/error_logging.rb
 - lib/belt/helpers/response.rb
@@ -214,7 +216,6 @@ files:
 - lib/templates/frontend/react/env.yml.example
 - lib/templates/frontend/react/index.html.erb
 - lib/templates/frontend/react/package.json.erb
-- lib/templates/frontend/react/scripts/prerender.js
 - lib/templates/frontend/react/src/App.jsx
 - lib/templates/frontend/react/src/entry-server.jsx
 - lib/templates/frontend/react/src/index.css