Pro RSC migration: tutorial on React on Rails Pro with a React Server Components demo

[ihabadham]

Migrates this tutorial to React on Rails Pro with the Pro Node Renderer for SSR, and adds a React Server Components demo at /server-components. RSC is a Pro-only feature (enable_rsc_support doesn't exist in the OSS gem), so demonstrating RSC in this tutorial inherently moves the whole app to Pro — that's the entry ticket, not scope drift.

What changes

Dependencies. Gem and npm move from react_on_rails to react_on_rails_pro 16.6.0. React pinned to ~19.0.4 (RSC's minimum). Adds react-on-rails-pro-node-renderer and react-on-rails-rsc.

SSR runtime. Server-side rendering moves from ExecJS to the Pro Node Renderer (renderer/node-renderer.js, port 3800). The renderer wires additionalContext: { URL, AbortController } for react-router-dom, stubTimers: false so React's RSC server renderer can use setTimeout for Flight-protocol yielding, and replayServerAsyncOperationLogs: true to surface async-server-component console output back through consoleReplayScript.

RSC demo. A new page at /server-components exercises React Server Components end-to-end: server-only library imports (Node os + lodash) that never reach the browser, async server components streamed via <Suspense>, the donut pattern (a 'use client' component nested in a server tree), and client-driven server-component re-fetching with react-error-boundary + useRSC().refetchComponent. See the React Server Components section in the README for the architecture.

Verification

• Each sub-PR was reviewed independently before squashing into this base.
• Manually QA'd on the deployed review app.
• Request and system specs cover the RSC payload endpoint and the demo page interactions (spec/requests/server_components_spec.rb, spec/system/server_components_demo_spec.rb).
• Lint, RSpec, and JS test workflows run for the first time on this PR — sub-PRs target the base branch and skip those workflows by trigger filter.

Follow-ups (post-merge)

• Switch config/shakapacker.yml back to rspack once shakacode/react_on_rails_rsc#29 ships native rspack support for the RSC plugin. A TODO in config/shakapacker.yml tracks the flip.
• Comprehensive CLAUDE.md and AGENTS.md updates documenting the new architecture for future agents — tracked in Comprehensive CLAUDE.md and AGENTS.md update #730.

Stack history

Three sub-PRs squash-merged into this base:

• Sub-PR 1 (Pro RSC migration 1/3: Swap gem and npm to react_on_rails_pro #726) — gem + npm migration to react_on_rails_pro.
• Sub-PR 2 (Pro RSC migration 2/3: switch SSR to the Pro Node renderer on webpack #728) — Pro Node Renderer + webpack switch + deploy infra.
• Sub-PR 3 (Pro RSC migration 3/3: React Server Components demo on webpack #729) — RSC demo page + tests.

The webpack switch in Sub-PR 2 is a tactical reversal of #702 (which moved this tutorial to rspack); react-on-rails-rsc/WebpackPlugin requires webpack APIs that rspack 2.0.0-beta.7's compatibility layer doesn't cover yet.

Summary by CodeRabbit

Release Notes

• New Features

  • Added React Server Components demo with streaming Suspense boundaries and error recovery
  • Implemented Node-based renderer for optimized server-side React rendering
  • Added live server activity monitoring with manual refresh and error simulation controls

• Dependencies

  • Upgraded to React on Rails Pro with Node Renderer integration
  • Bumped Shakapacker to stable release (10.0.0)
  • Updated React to version 19 with Server Components support

• Infrastructure

  • Switched build system to Webpack for React Server Components plugin compatibility
  • Updated container deployment to run Rails and Node renderer concurrently
  • Enhanced development environment with dedicated React Server Components build watcher

[coderabbitai]

Walkthrough

This pull request adds comprehensive React Server Components (RSC) and Node renderer support to the application. It updates core dependencies from react_on_rails to react_on_rails_pro, introduces new RSC-specific webpack configuration, creates server-side React components, adds a Node-based renderer process, integrates RSC payload streaming into Rails, and updates deployment, development, and testing infrastructure to support the new rendering pipeline.

Changes

Cohort / File(s)	Summary
Core Dependencies & Package Management Gemfile, package.json, .env.example	Upgrades react_on_rails to react_on_rails_pro (16.6.0), adds react-on-rails-pro-node-renderer and react-on-rails-rsc packages, bumps shakapacker to stable 10.0.0, pins React/React-DOM to ~19.0.4, and defines environment variables for RSC/renderer configuration.
Webpack & Bundler Configuration config/webpack/bundlerUtils.js, config/webpack/clientWebpackConfig.js, config/webpack/commonWebpackConfig.js, config/webpack/rscWebpackConfig.js, config/webpack/serverWebpackConfig.js, config/webpack/webpackConfig.js, config/shakapacker.yml	Switches default bundler from rspack to webpack (pending rspack RSC plugin), adds RSCWebpackPlugin to client config, introduces dedicated RSC webpack configuration with server-side rendering and react-server condition names, creates rscWebpackConfig() for RSC-only builds, refactors server config to support RSC mode with extractLoader helper, remaps react-on-rails to react-on-rails-pro via webpack alias, and updates bundler detection logic.
React on Rails Pro Integration client/app/bundles/comments/startup/..., client/app/libs/requestsManager.js, client/app/packs/..., client/app/bundles/comments/components/...	Updates all client-side modules to import react-on-rails-pro instead of react-on-rails, adds 'use client' directives to client components (Footer, SimpleCommentScreen, NavigationBar, RescriptShow, App, RouterApp variants, serverRegistration, Stimulus bundle, stores registration), and extends NavigationBar with link to new /server-components route.
New React Server Components & Islands client/app/bundles/server-components/components/..., client/app/bundles/server-components/ror_components/...	Creates CommentsFeed (async server component with markdown rendering and sanitization), ServerComponentsPage (page layout with ServerInfo, TogglePanel, LiveActivityRefresher, and CommentsFeed), ServerInfo (Node server metrics display), TogglePanel (collapsible client component), LiveActivity (async component with simulated errors and delays), and LiveActivityRefresher (client component with error boundary and refresh controls).
Rails Configuration & Routing config/initializers/react_on_rails_pro.rb, config/routes.rb, app/controllers/pages_controller.rb, app/views/pages/server_components.html.erb	Adds React on Rails Pro initializer with NodeRenderer configuration (renderer URL/password from env, RSC bundle settings, error fallback behavior), registers /server-components route and rsc_payload_route DSL hook, creates server_components controller action fetching and serializing comments, and adds corresponding ERB view streaming ServerComponentsPage component.
Node Renderer & Development Setup renderer/node-renderer.js, Procfile.dev, .github/workflows/rspec_test.yml, .controlplane/Dockerfile, .controlplane/templates/...	Creates Node renderer bootstrap configuring react-on-rails-pro-node-renderer with env-driven port/workers/password/log-level, adds wp-rsc and node-renderer processes to Procfile.dev, updates CI workflow to launch and wait for renderer on port 3800, changes container startup to run renderer and Rails concurrently via wait -n, and extends Control Plane templates with renderer environment variables and resource configuration (1Gi memory, capacityAI enabled).
Path Constants & Navigation client/app/bundles/comments/constants/paths.js	Adds SERVER_COMPONENTS_PATH constant ('/server-components') for RSC demo route navigation.
Linting & Development .eslintrc, .gitignore, Procfile.dev	Disables react/prop-types ESLint rule, adds renderer/.node-renderer-bundles/ to gitignore, and updates Procfile comments to reference webpack for CSS/SSR watching.
Documentation & Metadata README.md	Expands README with RSC and Node Renderer details: updates technology list, adds "React Server Components (RSC)" section documenting demo route/bundles/env-vars, describes streaming/Suspense/error-boundary features, explains three-bundle architecture (client/SSR/RSC), and updates development process documentation for six-process stack.
Testing client/__tests__/webpack/bundlerUtils.spec.js, spec/requests/server_components_spec.rb, spec/system/server_components_demo_spec.rb	Updates bundler utility tests to verify webpack bundler selection (removing rspack-only expectations), adds request spec validating HTTP 200 and "React Server Components Demo" text, and adds system spec exercising page navigation, ServerInfo metrics display, LiveActivity refresh/error/retry workflows.

Sequence Diagram(s)

sequenceDiagram
    participant Client as Client Browser
    participant Rails as Rails Server
    participant NodeRenderer as Node Renderer
    participant DB as Database

    Client->>Rails: GET /server-components
    Rails->>DB: Fetch Comments
    DB-->>Rails: Comments[]
    Rails->>NodeRenderer: Stream RSC Payload<br/>(ServerComponentsPage with comments)
    NodeRenderer->>NodeRenderer: Render Server Components<br/>(ServerInfo, CommentsFeed,<br/>LiveActivity)
    NodeRenderer-->>Rails: NDJSON Chunks<br/>(HTML segments)
    Rails-->>Client: HTTP 200 + Streamed HTML
    Client->>Client: Hydrate & Mount Components<br/>(Client Islands: TogglePanel,<br/>LiveActivityRefresher)
    Client->>Rails: GET /rsc_payload/live-activity<br/>(on refresh)
    Rails->>NodeRenderer: Stream LiveActivity<br/>RSC Payload
    NodeRenderer-->>Rails: Updated Activity HTML
    Rails-->>Client: NDJSON Stream
    Client->>Client: Error Boundary Fallback<br/>(on error)
    Client->>Rails: GET /rsc_payload/live-activity<br/>(retry)
    Rails->>NodeRenderer: Re-render LiveActivity
    NodeRenderer-->>Rails: HTML Chunk
    Rails-->>Client: Success HTML
    Client->>Client: Reset Error Boundary<br/>& Display Content

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~50 minutes

Poem

🐰 A hop and a skip, the renderer's here,
Server components streaming without a fear,
Suspense and errors, all handled with care,
Webpack and Pro, a duo so rare!
React on Rails hops into the new year! 🌟

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 7.69% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and specifically describes the main changes: migration to React on Rails Pro and addition of a React Server Components demo, which are the primary objectives of the PR.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch ihabadham/feature/pro-rsc/base

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

🚀 Quick Review App Commands

Welcome! Here are the commands you can use in this PR:

/deploy-review-app

Deploy your PR branch for testing

/delete-review-app

Remove the review app when done

/help

Show detailed instructions, environment setup, and configuration options.

---

[claude]

Code Review — Sub-PR 1: Dependency Swap (react-on-rails → react-on-rails-pro)

Overview

This PR is the integration base branch for the React on Rails Pro + RSC migration. The diff from Sub-PR 1 (#726) performs a clean dependency swap: react_on_rails → react_on_rails_pro in both the Ruby and JS ecosystems, promotes both shakapacker and react_on_rails_pro from RC to stable, and adds a webpack alias shim for third-party packages that can't be source-rewritten.

---

✅ What's done well

• Consistent import updates: All 10 first-party JS files that imported react-on-rails are correctly updated to react-on-rails-pro. No missed files.
• Webpack alias is correctly scoped: Using 'react-on-rails$' (with $) avoids rewriting sub-path imports, which is exactly right since Pro's package exports differ from core's. The in-code comment explains the rationale clearly.
• RC → stable promotions: Both shakapacker and react_on_rails_pro move from RC to stable (10.0.0, 16.6.0). Good.
• PR description: Thorough stack explanation, clear sub-PR plan, and explicit CI note. Sets reviewers up well.

---

⚠️ Issues to address before merging to master

1. License key — CI will fail without it

react_on_rails_pro validates a REACT_ON_RAILS_PRO_LICENSE environment variable at startup. The PR description delegates the license story to Sub-PR 2, but this integration branch is where the full CI suite runs (per the description's own CI note). If the secret isn't already in the repo's CI environment, rspec_test.yml / lint_test.yml will fail as soon as the Rails process boots.

Action: Verify the REACT_ON_RAILS_PRO_LICENSE secret is present in the repo's GitHub Actions secrets before this PR runs CI, or add it as part of this base branch rather than Sub-PR 2.

2. Significant new dependency footprint in react_on_rails_pro

The lock file adds: async, console, fiber-annotation, fiber-local, fiber-storage, http-2, httpx, io-event, jwt, metrics, traces. These are all real dependencies of Pro's NodeRenderer (async HTTP/2 calls with JWT auth to the renderer process) but they represent a meaningful expansion of the gem surface — 11 new gems. This is expected for Pro but worth calling out for maintainers watching bundle size.

3. react_on_rails (core) still in the lockfile as a transitive dep

react_on_rails_pro (16.6.0) depends on react_on_rails (= 16.6.0), so core is still installed — it just moves from a direct dependency to a transitive one. This is intentional (Pro wraps Core), but developers grepping Gemfile.lock for react_on_rails will find both. A one-line comment in the Gemfile would save confusion:

# react_on_rails (core) is installed as a transitive dep of react_on_rails_pro
gem "react_on_rails_pro", "16.6.0"

4. Webpack alias carries an implicit API-compatibility assumption

The alias redirects any third-party require('react-on-rails') call to react-on-rails-pro. This works only if Pro exports an API that is a superset of (or compatible with) what rescript-react-on-rails actually calls at runtime. If rescript-react-on-rails uses an API that diverged between core and Pro, the alias will silently produce runtime errors.

Suggestion: Add a brief note to the comment (or the PR) confirming that rescript-react-on-rails's usage was verified against Pro's exports.

---

Minor

• pack-config-diff@^0.1.0 appears as a new transitive dep of shakapacker@10.0.0 (not in the RC). It's a YAML diff utility — benign, but worth confirming it was introduced intentionally by the shakapacker stable release and not a lockfile artifact.
• ClientRouterAppExpress.jsx still imports browserHistory from react-router v3 — pre-existing, out of scope, but flagged for awareness.

---

Summary

The mechanical swap is clean and correct. The main blocker before this can land on master is confirming the Pro license secret is in CI. The webpack alias and dependency footnotes are advisory.

🤖 Generated with Claude Code

[claude]

Code Review — PR #727 (Pro RSC Migration: Stacked Base)

This is a thorough, well-documented migration. The inline rationale throughout is a strong signal that the tradeoffs (webpack-over-rspack temporarily, React version pin, single-container deployment) were thought through deliberately. Below is a full pass with a few items worth resolving before the stack lands on master.

---

Overview

The PR correctly splits work across three sub-PRs and integrates them here:

• Pro RSC migration 1/3: Swap gem and npm to react_on_rails_pro #726 — gem/npm dependency swap to react_on_rails_pro 16.6.0 stable + react-on-rails-pro alias shim
• Sub-PR 2 — NodeRenderer initializer, renderer/node-renderer.js launcher, Procfile/CI integration, webpack Pro transforms
• Sub-PR 3 — RSCWebpackPlugin wiring (client references discovery already wired in serverWebpackConfig.js)

The overall approach aligns with canonical Pro references (react_on_rails_pro/spec/dummy, marketplace demo), and the decision to fail loudly (renderer_use_fallback_exec_js = false) is the right default for a tutorial app that's explicitly demoing Pro features.

---

Issues

1. babelLoader.options.caller is replaced, not merged (serverWebpackConfig.js:113–114)

babelLoader.options.caller = { ssr: true };

If babel-loader was already configured with other caller fields (e.g., { name: 'webpack', supportsStaticESM: true }), this line silently drops them. A safer pattern:

babelLoader.options.caller = { ...babelLoader.options.caller, ssr: true };

2. getBundler() silently falls through to webpack for any non-rspack value (bundlerUtils.js:14)

_cachedBundler = config.assets_bundler === 'rspack' ? require('@rspack/core') : require('webpack');

The old code threw on invalid values; the new code silently loads webpack for 'invalid-bundler', undefined, or a typo. The test throws when assets_bundler is invalid was removed without a replacement. During the webpack era this is fine, but when the repo flips back to rspack someone could introduce a typo and get unexpected webpack behavior.

At minimum, consider adding a validation check or a clear comment that this is intentional fallback behavior, and adding back a test for the invalid-value case (even if it now documents "falls back to webpack, logs a warning").

3. wait -n requires bash ≥ 4.3 (.controlplane/Dockerfile CMD)

CMD ["bash", "-c", "node renderer/node-renderer.js & RENDERER_PID=$! ; bundle exec thrust bin/rails server & RAILS_PID=$! ; wait -n ; exit 1"]

wait -n (wait for any child) is a bash 4.3+ feature. Debian/Ubuntu-based images ship bash 5.x so this is almost certainly fine, but it's worth one line of confirmation that the Dockerfile's base image includes bash ≥ 4.3 (Alpine's sh would silently ignore -n). The bash -c invocation ensures the shell is bash — just worth verifying the version.

Also: RENDERER_PID and RAILS_PID are captured but never referenced again in this one-liner; they can be omitted without any behavioral change. Minor, but removes noise.

4. React version pin ~19.0.4 (resolves to 19.0.5) (package.json:78–79)

The pin is clearly intentional and the .env.example comment on react-on-rails-rsc explains it, but the package.json itself doesn't document why it's pegged to ~19.0.4 instead of ^19.0.0. A comment in package.json (or the PR description already has this) noting the pin is RSC-compatibility-driven would help maintainers not accidentally loosen it. Consider adding a brief inline comment similar to the webpack TODO comment in shakapacker.yml.

---

Observations (no action required, but worth noting)

RSCWebpackPlugin imported unconditionally in Sub-PR 2: serverWebpackConfig.js already imports react-on-rails-rsc/WebpackPlugin even though rscWebpackConfig.js (Sub-PR 3) hasn't landed yet. The plugin is wired to the server bundle's clientReferences scan right now, not gated to the RSC bundle path only. This is consistent with the canonical refs and is by design — the server bundle needs client-reference discovery even before the RSC bundle exists — but it's worth confirming this is intentional and not accidentally running RSC plugin in production before Sub-PR 3 is complete.

additionalContext: { URL, AbortController } (renderer/node-renderer.js:43): Both are available as Node.js globals since Node 18. If the CI/prod environment is Node 18+, this is fine. If there's any chance of Node 16 (which has URL but not AbortController as a global until 15.0), startup would throw a confusing ReferenceError. Given the project's other modern dependencies, Node 18+ is almost certainly guaranteed, but a engines field in package.json or a Node version check here would make it explicit.

CI renderer health check design: The polling loop in rspec_test.yml is solid — it checks both liveness and port readiness and fails fast if the PID disappears. One suggestion: consider redirecting the renderer's stdout/stderr to a log file so that on failure there's a dedicated artifact. Right now the output is interleaved in the step, which can be hard to parse if the CI log is long.

org.yml "do not re-apply" warning: The comment is accurate and important — re-applying the template would overwrite production secrets. Consider making this even more prominent (e.g., # ⚠️ WARNING: Re-applying this template overwrites all secret values.), since ControlPlane engineers may apply templates without reading all comments.

capacityAI: true in rails.yml: Good choice to let CapacityAI grow from the 1Gi baseline. Just worth confirming that the ControlPlane org has CapacityAI enabled at the org level, since it's a feature that must be opted into.

---

Summary

The stacked structure is clean, the rationale is well-documented, and the security choices (explicit fail-loud, no fallback ExecJS) are correct. The three items above — babel caller merge, silent bundler fallback, and wait -n bash version — are the ones worth addressing before the stack merges to master. Everything else is low-risk polish.

🤖 Generated with Claude Code

[claude]

Code Review — React on Rails Pro + RSC Migration (sub-PR stack base)

Overview

This is the integration branch for a well-structured stacked-PR migration: react_on_rails → react_on_rails_pro, ExecJS → NodeRenderer, and a new RSC demo page. The architecture choices (single-container renderer, 'use client' boundary placement, upstream RSCWebpackPlugin) are sound and align with the canonical Pro references. A few items worth addressing before the stack merges to master:

---

Bugs / Correctness

Dead code: Babel SSR caller on a SWC project
config/webpack/serverWebpackConfig.js sets babelLoader.options.caller = { ssr: true } but shakapacker.yml sets javascript_transpiler: swc, so extractLoader(rule, 'babel-loader') will always return undefined and this block never executes. The optimisation never fires. Either remove the block or extend it to cover swc-loader (SWC has its own caller mechanism via jsc.caller).

Stale closure in LiveActivityRefresher retry handler
buildRetry captures refreshKey from the render scope at error-boundary render time. If React batches multiple state updates between when the boundary renders and when the user clicks Retry, newKey = refreshKey + 1 can be off. Prefer the functional-update form: setRefreshKey(prev => prev + 1) and derive newKey from the callback.

---

Security

img src schemes in CommentsFeed markdown sanitisation
allowedSchemes: ['https', 'http'] is present (good), but img tags are in allowedTags. HTTP image references can be used as tracking pixels in comments. Since comments are user-supplied and the tutorial is public-facing, consider dropping img from allowedTags entirely, or restricting to HTTPS-only at minimum.

---

Naming / Clarity

RouterApp.server.jsx carries both a .server suffix and 'use client'
The .server.jsx convention signals "this is a React Server Component" to most readers and tooling, but 'use client' is required here because this file is a client component used for traditional SSR hydration. The naming contradiction will confuse contributors. Consider renaming to RouterApp.ssr.jsx (matching the existing RouterApp.client.jsx pair) or adding a one-line comment explaining that the .server.jsx name predates RSC and refers to the legacy SSR entrypoint.

---

Performance / Build

Default build now produces three bundles
webpackConfig.js now builds [clientConfig, serverConfig, rscWebpackConfig()] in the default case. CI already has separate SERVER_BUNDLE_ONLY and RSC_BUNDLE_ONLY paths, so full triple-bundle builds are rare there. Worth documenting in the PR or a CLAUDE.md note that the default dev build is heavier than before, and that RSC_BUNDLE_ONLY exists for iterating on RSC-only changes.

---

Infrastructure

react pinned to ~19.0.4 (patch-only): intentional for RSC API stability — good call, worth keeping.

REACT_ON_RAILS_PRO_LICENSE referenced via cpln secret in app.yml: the rails.yml template also needs to inherit it (or it's already covered by inheritEnv: true on the GVC — worth verifying that the GVC env includes the secret pointer before first deploy).

TODO: flip back to rspack in shakapacker.yml — a follow-up ticket tracking shakacode/react_on_rails_rsc#29 would prevent this from being forgotten.

---

Minor

• parseIntegerEnv in node-renderer.js: min is always caller-supplied, but there's no guard if it's omitted — the comparison parsed < undefined silently passes. A default of 0 or an explicit check would make the contract clear.
• The RSC_SUSPENSE_DEMO_DELAY=true in app.yml is intentional for the review-app. A comment in the template (or a link to the .env.example entry) would help future operators understand why it differs from the production default.

[ihabadham]

/deploy-review-app

[github-actions]

🎉 ✨ Deploy Complete! 🚀

🌐 ➡️ Open Review App

Deployment successful for PR #727, commit 227fd25

🎮 Control Plane Console
📋 View Completed Action Build and Deploy Logs

[claude]

Code Review — PR #727 (Pro RSC migration integration branch)

Overall: The migration is well-structured and the stacked-PR approach is the right call for a change this size. The RSC demo page clearly illustrates the key patterns (server-only imports, async components, Suspense streaming, client/server composition via the donut pattern, and RSCRoute + ErrorBoundary). The webpack config refactor is clean and the CI changes are correct.

A few issues worth addressing before this lands on master:

---

🔴 High — Dockerfile: SIGTERM not forwarded to child processes

The CMD uses bash as PID 1 with two backgrounded children:

CMD ["bash", "-c", "node renderer/node-renderer.js & RENDERER_PID=$! ; bundle exec thrust bin/rails server & RAILS_PID=$! ; wait -n ; exit 1"]

When Control Plane (or Kubernetes) sends SIGTERM for graceful shutdown, it goes to bash (PID 1). Bash in non-interactive mode does not forward signals to child processes. Both Rails and the Node renderer will be SIGKILL-ed after the grace period expires — no graceful drain, no clean shutdown of in-flight requests.

A trap is the minimal fix:

bash -c '
  trap "kill $RENDERER_PID $RAILS_PID 2>/dev/null; wait" SIGTERM SIGINT
  node renderer/node-renderer.js & RENDERER_PID=$!
  bundle exec thrust bin/rails server & RAILS_PID=$!
  wait -n
  kill $RENDERER_PID $RAILS_PID 2>/dev/null
  exit 1
'

A proper process supervisor (supervisord, s6-overlay) would be the production-grade solution, but for a tutorial app the trap approach is acceptable.

---

🟡 Medium — 'use client' on RouterApp.server.jsx is semantically wrong

RouterApp.server.jsx uses StaticRouter and is the server-side SSR entry — it is the opposite of a client component. Adding 'use client' to it tells the RSC webpack plugin to treat it as a client reference, which means it would be excluded from the RSC bundle and a client stub would be emitted instead. If anything imports this file in the RSC bundle graph, it won't get the real StaticRouter-based implementation.

Please verify:

1. This file is NOT imported by any server component in the new RSC bundle.
2. The directive was added to prevent the RSC plugin from scanning it, not because it should be client-hydrated.

If the intent is simply to keep it out of the RSC bundle, an inline comment explaining that is essential — otherwise reviewers will rightly question it.

---

🟡 Medium — bundlerUtils.js: invalid bundler names now silently fall through to webpack

The old code threw a clear error on invalid assets_bundler values. The new code treats any non-'rspack' value as webpack:

_cachedBundler = config.assets_bundler === 'rspack' ? require('@rspack/core') : require('webpack');

If someone misspells rspack in shakapacker.yml (e.g., rsPack, Rspack), they'll silently get a webpack build with no warning. Consider logging a warning when the value is neither 'rspack' nor 'webpack'.

---

🟡 Medium — wait -n requires bash ≥ 4.3 (check base image)

wait -n (wait for any single child) was added in bash 4.3. If the Docker base image ships an older bash, this will silently become an infinite wait. Alpine images in particular have shipped bash 3.x. Worth adding a bash --version check in the entrypoint, or pinning to a Debian/Ubuntu base where bash 4.x+ is guaranteed.

---

🟠 Low — sanitize-html allows http image sources (mixed-content risk)

allowedSchemes: ['https', 'http'],

Including http in allowedSchemes means user-authored markdown can embed images over plain HTTP. When the page is served over HTTPS, browsers will block these mixed-content images. Since comment authors could include any http:// image URL, this will produce silent breakage on HTTPS deployments. Restrict to ['https'] unless there's a specific reason to support HTTP sources.

---

🟢 Positive callouts

• The extractLoader helper in serverWebpackConfig.js is a clean reusable abstraction.
• renderer/node-renderer.js has solid input validation for env vars (parseIntegerEnv) and the stubTimers: false + replayServerAsyncOperationLogs: true rationale comments are exactly the kind of "why" documentation that prevents future regressions.
• The RENDERER_PID dead-code issue in the Dockerfile is minor — once the signal trap is added, the PIDs become necessary anyway.
• Request specs (server_components_spec.rb) covering both the page shell and the RSC payload endpoint (including the populated-comments case) are a good baseline.
• The .env.example is clear and well-documented.

🤖 Generated with Claude Code

[github-actions]

🎉 ✨ Deploy Complete! 🚀

🌐 ➡️ Open Review App

Deployment successful for PR #727, commit d29de5f

🎮 Control Plane Console
📋 View Completed Action Build and Deploy Logs

[claude]

PR #727 Review — Pro RSC Migration (base integration branch)

Overview

This is a well-scoped integration branch for migrating from the OSS react_on_rails gem/npm package to the Pro stack, enabling React Server Components. The stacked sub-PR approach is good practice for a migration of this size. The PR description, inline comments, and README additions are thorough.

The dependency upgrades from RC to stable and the three-bundle webpack pipeline are structurally sound. Observations below are mostly edge-case hardening and a few correctness concerns.

---

Correctness

RouterApp.server.jsx has 'use client' — this file uses StaticRouter and is the entry point for traditional SSR (not RSC). Adding 'use client' marks it as a client reference in the RSC bundle, preventing it from running as a server component — that part is intentional. But the semantic mismatch ('use client' on a file named .server.jsx) will confuse contributors. A short comment explaining the intent would prevent a future developer from removing the directive thinking it's a mistake.

ServerComponentsPage is a sync arrow function, not async — it wraps an async CommentsFeed in a <Suspense> boundary, so this is fine at runtime. No change needed, just worth noting.

---

Security

sanitizeHtml allows http:// for image src in CommentsFeed.jsx — user-submitted Markdown can embed images over plain HTTP. On a tutorial app serving user comments, this could leak referer data or trigger mixed-content warnings in an HTTPS context. Restricting allowedSchemes to ['https'] for img tags would harden this. See inline comment.

Renderer password fallback and NODE_ENV — both renderer/node-renderer.js and config/initializers/react_on_rails_pro.rb gate the dev-default password on NODE_ENV === 'production'. A staging environment that uses NODE_ENV=staging or omits NODE_ENV entirely would silently fall back to local-dev-renderer-password. This is noted in .env.example but not enforced. Consider logging a warning when RENDERER_PASSWORD is blank outside of a strict development/test context.

---

Reliability / Performance

Docker CMD does not forward signals — running both processes under bash -c "..." means the container runtime's SIGTERM is delivered to the bash process only. Neither the Node renderer nor Rails/Thruster will receive it; they will be force-killed when the stop timeout expires, dropping in-flight SSR requests. Adding a trap that forwards the signal to both child PIDs (or using a lightweight init like tini) would give both processes a graceful shutdown window. See inline comment.

ErrorBoundary + .finally(resetErrorBoundary) in LiveActivityRefresher — if refetchComponent itself rejects (e.g. network error while retrying), .finally(() => resetErrorBoundary()) still resets the boundary. The component re-renders, RSCRoute fires another fetch, and if the server is still down it throws again immediately — a tight error-boundary oscillation. Resetting only on success and leaving the fallback UI up on a failed retry would be safer. See inline comment.

marked instance at module scope with gfmHeadingId — gfmHeadingId() maintains an internal counter for unique heading IDs. Because the marked instance is created once at module scope and shared across all RSC renders, the counter increments across requests, making heading IDs non-deterministic and potentially mismatched between server payload and client hydration. Constructing new Marked() per render (and calling .use(gfmHeadingId()) on each) would give deterministic IDs. See inline comment.

---

CI

nc may not be installed on GitHub-hosted runners — the Node renderer health check in rspec_test.yml calls nc -z localhost 3800. Netcat is not present by default on ubuntu-22.04/ubuntu-24.04 runners. curl -s http://localhost:3800 >/dev/null 2>&1 or wget -q --spider http://localhost:3800 would be more portable. See inline comment.

---

Minor

• package.json pins react/react-dom to ~19.0.4 (patch-only). If React 19.1 ships RSC bug-fixes the app won't pick them up without a manual bump. ^19.0.4 is more typical for an OSS tutorial; the strictness deserves a comment if intentional.
• The bundlerUtils.spec.js change drops the 'throws when assets_bundler is invalid' test without replacement. An invalid value now silently falls through to require('webpack') and throws a module-not-found error rather than a descriptive message. A test covering the invalid-bundler path would preserve the regression guard.

[claude]

Code Review: Pro RSC Migration

Overall this is a well-structured migration from react_on_rails OSS to react_on_rails_pro 16.6.0 with an RSC demo at /server-components. The sub-PR squash strategy produces a clean history. Observations focus on correctness, maintainability, and one security item.

What works well

• Deployment: wait -n; exit 1 cleanly restarts the whole container unit on child failure.
• Sanitization in CommentsFeed: sanitize-html server-side before dangerouslySetInnerHTML avoids XSS.
• parseIntegerEnv in node-renderer.js is a clean, defensive env var validation helper.
• bundlerUtils.js supports both webpack and rspack without duplicating config.
• Test coverage: request specs (RSC payload endpoint) and system specs (Capybara) cover happy path and error-boundary/retry.

Issue 1 — RouterApp.server.jsx with use-client directive

The use-client directive is correct from the RSC bundle's perspective (this is an SSR boundary, not an RSC server component). But the .server.jsx suffix means the opposite of the React community convention where .server.jsx signals an RSC Server Component. Consider renaming to RouterApp.ssr.jsx, or adding a prominent comment explaining why a .server.jsx file carries use-client.

Issue 2 — Race condition in buildRetry (LiveActivityRefresher.jsx)

The Retry handler calls setRefreshKey(newKey) then refetchComponent(...). setRefreshKey triggers the resetKeys prop on ErrorBoundary, resetting the boundary and re-mounting RSCRoute before refetchComponent resolves. The cache-priming intent is there, but the auto-reset fires from the state update — not after the await. RSCRoute may start a new fetch (cache miss) rather than hitting the pre-primed entry. Consider removing resetKeys from ErrorBoundary and relying solely on resetErrorBoundary() in .finally() to guarantee the reset happens after cache priming.

Issue 3 — Dockerfile: no SIGTERM forwarding to children

When the container receives SIGTERM (docker stop / ControlPlane scale-down), bash in a non-interactive script does not forward it to background children — they get SIGHUP at best or SIGKILL after the stop timeout. In-flight SSR requests are dropped without graceful drain. Acceptable for this tutorial, but worth a TODO comment. Graceful shutdown needs a trap handler forwarding the signal to child PIDs.

Issue 4 — rscWebpackConfig.js: inconsistent return in the function-wrapper

In the typeof rule.use === function branch, the code normalizes result into resultArray, then returns the original result (not resultArray) in the no-JS-loader path. No functional bug (webpack treats null/undefined and empty-array equivalently), but the asymmetry is a minor readability concern.

Issue 5 — README title still references Rspack

The heading reads ES2024, Rspack, Ruby on Rails Demo while the body correctly notes the temporary webpack switch. Either update the title to webpack for now, or drop the bundler name entirely to avoid churn on the flip-back.

Issue 6 — sanitize-html allows http:// image sources

allowedSchemes includes http, matching sanitize-html defaults, but http image URLs produce mixed-content warnings in HTTPS deployments. For a tutorial others copy from, restricting to https-only is safer.

Summary: the race condition in the Retry flow and the .server.jsx naming inversion are the two items most worth revisiting before merge. The rest are low-severity or cosmetic.

[greptile-apps]

Greptile Summary

Migrates the tutorial from react_on_rails OSS to react_on_rails_pro 16.6.0 and adds a full RSC demo at /server-components, including the Pro Node Renderer, RSC webpack bundle, server-only components (os, lodash), a Suspense streaming feed, and the donut pattern with ErrorBoundary + refetchComponent. The migration is thorough and the new architecture is well-commented and spec-covered.

Confidence Score: 4/5

Safe to merge; all findings are P2 and non-blocking.

No P0 or P1 issues. The three P2 findings are: a cache-prime race in buildRetry that causes an extra network fetch on retry (functionally still recovers), an http scheme in sanitize-html config that can cause mixed-content warnings, and an untracked background PID in CI. None block correctness or security.

client/app/bundles/server-components/components/LiveActivityRefresher.jsx (retry cache race) and client/app/bundles/server-components/components/CommentsFeed.jsx (mixed-content scheme).

Important Files Changed

Filename	Overview
renderer/node-renderer.js	New Pro Node Renderer entry point; well-structured with env validation, integer parsing guard, and clear commentary on each non-default option.
config/initializers/react_on_rails_pro.rb	Pro initializer; password fallback mirrors JS side, renderer_use_fallback_exec_js: false ensures loud failure rather than silent ExecJS degradation in production.
config/webpack/serverWebpackConfig.js	Export shape changed from bare function to { default, extractLoader }; all consumers updated. Adds RSCWebpackPlugin, babel-loader caller flag for SSR, and switches target to node.
config/webpack/rscWebpackConfig.js	New RSC bundle config derived from serverWebpackConfig; correctly handles both array and function forms of rule.use, aliases react-dom/server to false, and sets react-server conditionNames.
client/app/bundles/server-components/components/LiveActivityRefresher.jsx	Client component for RSCRoute + ErrorBoundary demo; buildRetry race means refetchComponent doesn't actually prime the cache before the boundary resets via resetKeys.
client/app/bundles/server-components/components/CommentsFeed.jsx	Async server component with marked + sanitize-html; sanitization is server-side only (correct), but allowedSchemes includes http which can cause mixed-content issues on HTTPS pages.
client/app/bundles/server-components/ror_components/ServerComponentsPage.jsx	Root RSC page demonstrating server-only imports, donut pattern, Suspense streaming, and RSCRoute; structure and patterns are sound.
app/controllers/pages_controller.rb	Adds server_components action with stream_view_containing_react_components; set_comments scoped to index/no_router only to avoid unnecessary DB queries on RSC page.
.github/workflows/rspec_test.yml	Adds Node renderer startup step with 30-second readiness poll; RENDERER_PID not exported to $GITHUB_ENV so it can't be killed in a cleanup step if the renderer crashes mid-suite.
.controlplane/Dockerfile	CMD runs Rails + Node renderer in a single container via bash background jobs; wait -n exits on first child failure so ControlPlane restarts the whole unit.

Sequence Diagram

sequenceDiagram
    participant Browser
    participant Rails
    participant NodeRenderer
    participant RSCRuntime

    Note over Browser,RSCRuntime: Initial page load (/server-components)
    Browser->>Rails: GET /server-components
    Rails->>NodeRenderer: stream_view_containing_react_components (SSR)
    NodeRenderer->>RSCRuntime: render ServerComponentsPage (RSC bundle)
    RSCRuntime-->>NodeRenderer: Flight protocol stream
    NodeRenderer-->>Rails: streamed HTML chunks
    Rails-->>Browser: streamed HTTP response

    Note over Browser,RSCRuntime: Client-driven RSC refresh (Refresh button)
    Browser->>Rails: GET /rsc_payload/LiveActivity
    Rails->>NodeRenderer: RSC payload generation
    NodeRenderer->>RSCRuntime: render LiveActivity (rsc-bundle)
    RSCRuntime-->>NodeRenderer: NDJSON chunks
    NodeRenderer-->>Rails: NDJSON stream
    Rails-->>Browser: NDJSON (application/x-ndjson)
    Browser->>Browser: RSCRoute reconciles streamed payload

    Note over Browser,RSCRuntime: Error boundary retry flow
    Browser->>Browser: Simulate Error — ErrorBoundary catches
    Browser->>Rails: refetchComponent (pre-warms cache)
    Browser->>Browser: resetErrorBoundary — RSCRoute re-renders from cache

Loading

_{Reviews (1): Last reviewed commit: "Disable react/prop-types project-wide; d..." | Re-trigger Greptile}

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d29de5f3c5

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 7

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

README.md (1)

76-93: ⚠️ Potential issue | 🟡 Minor

Fix broken TOC anchors reported by markdownlint.

The table of contents includes fragments that don’t resolve (#about-shakacode, #open-code-of-conduct), which triggers MD051.

📝 Minimal fix

-  + [About ShakaCode](`#about-shakacode`)
   + [RubyMine and WebStorm](`#rubymine-and-webstorm`)
-+ [Open Code of Conduct](`#open-code-of-conduct`)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@README.md` around lines 76 - 93, The TOC contains links whose fragment
identifiers don't match actual heading anchors (triggering MD051): update the
table-of-contents entries for "#about-shakacode" and "#open-code-of-conduct" to
match the real heading text/anchors (e.g., ensure they are exactly
"#about-shakacode" or change them to the actual generated anchors like
"#about-shakacode-1" or rename the headings to "About ShakaCode" and "Open Code
of Conduct" so the fragments resolve), or alternatively remove/replace the
broken entries so the markdown TOC fragments match the corresponding headings;
verify other TOC entries (e.g., "Demoed Functionality", "Basic Demo Setup")
still match their headings to satisfy markdownlint MD051.

🧹 Nitpick comments (1)

.controlplane/templates/rails.yml (1)

18-35: Raise the baseline, but watch resource pressure.

Bumping the container to 1Gi makes sense with Rails and the co-located renderer in the same pod. Please keep an eye on OOM kills and CPU throttling after rollout, since CapacityAI can only adapt within the single-replica budget.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.controlplane/templates/rails.yml around lines 18 - 35, Keep the bumped
baseline memory: 1Gi but explicitly monitor for OOM kills and CPU throttling
after rollout; if you observe resource pressure, update
defaultOptions.autoscaling.maxScale from 1 to allow multiple replicas or relax
the single-replica constraint in defaultOptions, and/or tune
defaultOptions.capacityAI thresholds so CapacityAI can increase CPU/memory
within the replica before scaling; ensure alerts/metrics are in place to detect
OOM and CPU throttling when memory: 1Gi is used.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In @.controlplane/Dockerfile:
- Around line 83-87: The current CMD starts renderer/node-renderer.js in
background and immediately starts Rails, then unconditionally exits 1 on any
child exit; change it so the renderer is started and the container waits for the
renderer to signal readiness (e.g., poll a renderer health endpoint or block on
a readiness file/socket) before launching bundle exec thrust bin/rails server,
and when either child exits use the actual exit code of that process rather than
exit 1; update the CMD/bash logic around renderer/node-renderer.js,
RENDERER_PID, RAILS_PID and the wait -n usage to capture and propagate the
child's exit status (exit $STATUS) and ensure the other process is
terminated/cleaned up.

In @.controlplane/templates/app.yml:
- Around line 37-40: The template currently hard-codes the environment variable
RSC_SUSPENSE_DEMO_DELAY to 'true'; change this so the demo delay is off by
default by removing the hard-coded 'true' assignment and either set
RSC_SUSPENSE_DEMO_DELAY to 'false' or omit the variable entirely from the shared
template, and instead document/override it in review-app specific overlays (so
only review apps enable the delay); update any comments to reflect that the
default is off and that review-apps must explicitly set
RSC_SUSPENSE_DEMO_DELAY='true' when needed.

In `@app/controllers/pages_controller.rb`:
- Around line 5-7: There is no blank line after the module inclusion which
triggers RuboCop Layout/EmptyLinesAfterModuleInclusion; update the
PagesController by inserting one empty line immediately after the include
ReactOnRailsPro::Stream statement so that the include line and the before_action
:set_comments (and any other subsequent declarations) are separated by a blank
line.

In `@client/app/bundles/server-components/components/TogglePanel.jsx`:
- Around line 5-29: Convert the arrow component to a function declaration
(change const TogglePanel = (...) => to function TogglePanel({ title, children
}) { ... }) to satisfy the react/function-component-definition rule; keep the
isOpen and setIsOpen state but also call React's useId (or accept an id prop) to
create a stable id for the collapsible region, then add accessibility
attributes: on the toggle button add aria-expanded={isOpen} and
aria-controls={contentId}, and give the content container the matching
id={contentId} (and include role="region" or aria-labelledby if desired);
reference the TogglePanel function, isOpen, setIsOpen, and useId/contentId when
making these changes.

In `@client/app/packs/stores-registration.js`:
- Around line 1-4: Move the explanatory comment so the top-of-file directive
stays first: leave the "'use client';" directive as the very first statement,
then add a single blank line and place the existing comment immediately after it
(above the import ReactOnRails line). This keeps "'use client'" at the top while
satisfying the lines-around-directive requirement by not putting any comment
before the directive.

In `@config/initializers/react_on_rails_pro.rb`:
- Line 18: The current assignment to config.renderer_password uses a hardcoded
fallback which is unsafe; change it to require an explicit value in
non-development/test environments by removing the default and raising if
ENV["RENDERER_PASSWORD"] is blank (e.g. set config.renderer_password =
ENV["RENDERER_PASSWORD"].presence and, for production (use Rails.env.production?
or !Rails.env.development? && !Rails.env.test?), raise a clear error like
"RENDERER_PASSWORD must be set in production" when blank), or alternatively load
from Rails credentials for production and still raise if neither is present;
update the code around config.renderer_password to implement this check.

In `@config/webpack/rscWebpackConfig.js`:
- Around line 16-35: The current rules.forEach mutates rule.use and uses a
nested ternary; instead produce immutable updates: replace the forEach with a
map over rules to build a new array (e.g., const newRules = rules.map(rule => {
... })) and return a newRule object for each input rule rather than reassigning
properties. For the function branch (identify originalUse and rscLoaderWrapper)
create a wrappedUse function (const wrappedUse = function(data) { const result =
originalUse.call(this, data); const resultArray = Array.isArray(result) ? result
: result ? [result] : []; if (extractLoader({ use: resultArray },
'babel-loader') || extractLoader({ use: resultArray }, 'swc-loader')) { return
[...resultArray, { loader: 'react-on-rails-rsc/WebpackLoader' }]; } return
result; }); then return { ...rule, use: wrappedUse }; for the array branch,
return { ...rule, use: [...rule.use, { loader:
'react-on-rails-rsc/WebpackLoader' }] } and keep other rules unchanged; this
removes in-place param reassignment and replaces the nested ternary with
explicit branching while still using extractLoader to detect babel/swc loaders.

---

Outside diff comments:
In `@README.md`:
- Around line 76-93: The TOC contains links whose fragment identifiers don't
match actual heading anchors (triggering MD051): update the table-of-contents
entries for "#about-shakacode" and "#open-code-of-conduct" to match the real
heading text/anchors (e.g., ensure they are exactly "#about-shakacode" or change
them to the actual generated anchors like "#about-shakacode-1" or rename the
headings to "About ShakaCode" and "Open Code of Conduct" so the fragments
resolve), or alternatively remove/replace the broken entries so the markdown TOC
fragments match the corresponding headings; verify other TOC entries (e.g.,
"Demoed Functionality", "Basic Demo Setup") still match their headings to
satisfy markdownlint MD051.

---

Nitpick comments:
In @.controlplane/templates/rails.yml:
- Around line 18-35: Keep the bumped baseline memory: 1Gi but explicitly monitor
for OOM kills and CPU throttling after rollout; if you observe resource
pressure, update defaultOptions.autoscaling.maxScale from 1 to allow multiple
replicas or relax the single-replica constraint in defaultOptions, and/or tune
defaultOptions.capacityAI thresholds so CapacityAI can increase CPU/memory
within the replica before scaling; ensure alerts/metrics are in place to detect
OOM and CPU throttling when memory: 1Gi is used.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 5308d56a-d8eb-4aac-9bc2-c6896aa83eaa

📥 Commits

Reviewing files that changed from the base of the PR and between 5cf245f and d29de5f.

⛔ Files ignored due to path filters (2)

• Gemfile.lock is excluded by !**/*.lock
• yarn.lock is excluded by !**/yarn.lock, !**/*.lock

📒 Files selected for processing (47)

• .controlplane/Dockerfile
• .controlplane/templates/app.yml
• .controlplane/templates/org.yml
• .controlplane/templates/rails.yml
• .env.example
• .eslintrc
• .github/workflows/rspec_test.yml
• .gitignore
• Gemfile
• Procfile.dev
• README.md
• app/controllers/pages_controller.rb
• app/views/pages/server_components.html.erb
• client/__tests__/webpack/bundlerUtils.spec.js
• client/app/bundles/comments/components/Footer/ror_components/Footer.jsx
• client/app/bundles/comments/components/NavigationBar/NavigationBar.jsx
• client/app/bundles/comments/components/SimpleCommentScreen/ror_components/SimpleCommentScreen.jsx
• client/app/bundles/comments/constants/paths.js
• client/app/bundles/comments/rescript/ReScriptShow/ror_components/RescriptShow.jsx
• client/app/bundles/comments/startup/App/ror_components/App.jsx
• client/app/bundles/comments/startup/ClientRouterAppExpress.jsx
• client/app/bundles/comments/startup/NavigationBarApp/ror_components/NavigationBarApp.jsx
• client/app/bundles/comments/startup/RouterApp/ror_components/RouterApp.client.jsx
• client/app/bundles/comments/startup/RouterApp/ror_components/RouterApp.server.jsx
• client/app/bundles/comments/startup/serverRegistration.jsx
• client/app/bundles/server-components/components/CommentsFeed.jsx
• client/app/bundles/server-components/components/LiveActivityRefresher.jsx
• client/app/bundles/server-components/components/ServerInfo.jsx
• client/app/bundles/server-components/components/TogglePanel.jsx
• client/app/bundles/server-components/ror_components/LiveActivity.jsx
• client/app/bundles/server-components/ror_components/ServerComponentsPage.jsx
• client/app/libs/requestsManager.js
• client/app/packs/stimulus-bundle.js
• client/app/packs/stores-registration.js
• config/initializers/react_on_rails_pro.rb
• config/routes.rb
• config/shakapacker.yml
• config/webpack/bundlerUtils.js
• config/webpack/clientWebpackConfig.js
• config/webpack/commonWebpackConfig.js
• config/webpack/rscWebpackConfig.js
• config/webpack/serverWebpackConfig.js
• config/webpack/webpackConfig.js
• package.json
• renderer/node-renderer.js
• spec/requests/server_components_spec.rb
• spec/system/server_components_demo_spec.rb

[github-actions]

✅ Review app for PR #727 was successfully deleted

View Completed Delete Logs

Control Plane Organization