CHANGELOG.md (1)

11-12: Unify list style and fix minor grammar ("a webpack-compatible API").

Consistent list markers and a small grammar tweak will satisfy markdownlint (MD004) and read more naturally.

-- Rspack support as an alternative bundler to webpack. Configure `bundler: 'rspack'` in `shakapacker.yml` to use Rspack's faster Rust-based bundling with webpack-compatible
+* Rspack support as an alternative bundler to webpack. Configure `bundler: 'rspack'` in `shakapacker.yml` to use Rspack's faster Rust-based bundling with a webpack-compatible
   APIs, built-in SWC loader, and CSS extraction. Automatic bundler detection in `bin/shakapacker` with fallback support for webpack configurations.

package/rspack/rules/raw.js (1)

1-5: Prefer EOF newline and consider adding a quick test for ?raw imports.

Prettier flags missing newline at EOF. Also, adding a unit/integration test that asserts import x from './file.txt?raw' yields raw source would lock this in.

 module.exports = {
   resourceQuery: /raw/,
   type: "asset/source"
-}
+}
+

I can sketch a minimal Jest test using in-memory compilation if you’d like.

docs/rspack.md (3)

3-3: Grammar: insert article (“a webpack-compatible API”).

-Shakapacker supports [Rspack](https://rspack.rs) as an alternative bundler to Webpack. Rspack is a fast Rust-based web bundler with webpack-compatible API that can significantly speed up your build times.
+Shakapacker supports [Rspack](https://rspack.rs) as an alternative bundler to Webpack. Rspack is a fast Rust-based web bundler with a webpack-compatible API that can significantly speed up your build times.

---

31-33: Duplicate “Configuration” heading. Rename the second for clarity (MD024).

-## Configuration
+## Rspack configuration file

---

13-17: Trim trailing spaces and normalize capitalization (“Rspack”).

These small edits fix markdown lint warnings and keep style consistent.

-# or  
+# or
 pnpm add @rspack/core @rspack/cli -D
-# or
+# or
 bun add @rspack/core @rspack/cli -D

-# Development server (automatically uses rspack when bundler: 'rspack')  
+# Development server (automatically uses Rspack when bundler: 'rspack')
 ./bin/shakapacker-dev-server

-- **5-20x faster** incremental builds  
+- **5-20x faster** incremental builds
 - **Faster HMR** (Hot Module Replacement)

Also applies to: 125-127, 138-140

package.json (1)

17-23: Missing TypeScript declarations for subpath exports

Our check shows only package/index.d.ts exists and there’s no typesVersions in package.json. Consumers importing:

• shakapacker/rspack
• shakapacker/swc
• shakapacker/esbuild

will not get any .d.ts files.

Please consider one of the following optional refactors:

• Add declaration files next to each subpath entrypoint:
  • package/rspack/index.d.ts
  • package/swc/index.d.ts
  • package/esbuild/index.d.ts
• Add a typesVersions map in package.json to point TypeScript at these files.
• Or embed JSDoc typedefs and generate .d.ts on publish.

Let me know if you’d like help drafting these typings!

package/rspack/rules/erb.js (2)

15-16: Use string for env var value to avoid cross-platform spawn issues.

Process env values should be strings. Using number 1 can be coerced, but explicit strings are safer.

Apply:

-          ...process.env,
-          DISABLE_SPRING: 1
+          ...process.env,
+          DISABLE_SPRING: "1"

---

21-21: Prettier: ensure newline at end of file.

Static analysis flagged a missing newline at EOF. Add a trailing newline to satisfy prettier.

Apply:

-}))
+}))
+

package/rspack/rules/file.js (2)

16-18: Potential false-positive match due to prefix-only check.

Using startsWith on the raw string can mis-match siblings (e.g., /foo/bar and /foo/barista). The diff above addresses this by using path.relative and longest-prefix selection.

---

29-29: Prettier: missing trailing newline.

Insert a newline at end of file to satisfy prettier.

package/rspack/environments/test.js (1)

14-14: Prettier: missing trailing newline.

Insert a newline at end of file to satisfy prettier.

lib/install/bin/shakapacker-rspack (1)

4-4: Prefer dir over FILE for path calculation.

Minor readability/consistency tweak; the rest of the script already uses dir.

-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __dir__)

lib/install/config/webpack/rspack.config.js (1)

6-6: Add a trailing newline at EOF

Keeps linters and Git diffs happy.

Apply this diff:

-module.exports = rspackConfig
+module.exports = rspackConfig
+

package/rspack/environments/development.js (1)

4-4: Fix Prettier issues (whitespace and EOF newline)

• Line 4 has trailing whitespace.
• Add a newline at end of file.

Apply this diff:

-const devServerConfig = require("../../webpackDevServerConfig") 
+const devServerConfig = require("../../webpackDevServerConfig")
@@
-module.exports = merge(baseConfig, devConfig)
+module.exports = merge(baseConfig, devConfig)
+

Also applies to: 19-19

package/rspack/rules/index.js (3)

7-31: Consider splitting JS and TS handling for SWC parser correctness

Using the TypeScript parser for all JS/TS extensions can be surprising for plain JS and may affect parsing/transform semantics. Recommend separate rules for JS (ecmascript parser) and TS (typescript parser).

Apply this diff:

-// Use Rspack's built-in SWC loader for JS/TS/JSX/TSX files
-rules.push({
-  test: /\.(js|jsx|ts|tsx|mjs)$/,
-  exclude: /node_modules/,
-  type: "javascript/auto",
-  use: [
-    {
-      loader: "builtin:swc-loader",
-      options: {
-        jsc: {
-          parser: {
-            syntax: "typescript",
-            tsx: true,
-            jsx: true
-          },
-          transform: {
-            react: {
-              runtime: "automatic"
-            }
-          }
-        }
-      }
-    }
-  ]
-})
+// Use Rspack's built-in SWC loader
+// JS/JSX/MJS
+rules.push({
+  test: /\.(js|jsx|mjs)$/,
+  exclude: /node_modules/,
+  type: "javascript/auto",
+  use: [
+    {
+      loader: "builtin:swc-loader",
+      options: {
+        jsc: {
+          parser: { syntax: "ecmascript", jsx: true },
+          transform: { react: { runtime: "automatic" } }
+        }
+      }
+    }
+  ]
+})
+
+// TS/TSX
+rules.push({
+  test: /\.(ts|tsx)$/,
+  exclude: /node_modules/,
+  type: "javascript/auto",
+  use: [
+    {
+      loader: "builtin:swc-loader",
+      options: {
+        jsc: {
+          parser: { syntax: "typescript", tsx: true },
+          transform: { react: { runtime: "automatic" } }
+        }
+      }
+    }
+  ]
+})

---

16-21: Minor: jsx is redundant when tsx is true

SWC implies JSX handling when tsx is enabled. If you keep a single TS rule, jsx: true can be dropped for clarity.

---

45-45: Align with ESLint/Prettier: spacing and newline-after-import

• Remove trailing spaces in the “Less rules” comment.
• Insert a blank line after require statements not followed by another require.
• Add a trailing newline at EOF.

Apply this diff:

-// Less rules  
+// Less rules
@@
-const erb = require("./erb")
-rules.push(erb)
+const erb = require("./erb")
+
+rules.push(erb)
@@
-const file = require("./file")
-rules.push(file)
+const file = require("./file")
+
+rules.push(file)
@@
-const raw = require("./raw")
-rules.push(raw)
+const raw = require("./raw")
+
+rules.push(raw)
@@
-module.exports = rules
+module.exports = rules
+

Also applies to: 58-60, 62-64, 66-68, 69-69

package/rspack/environments/production.js (3)

15-26: Silence ESLint’s global-require warning for optional compression plugin.

The inline require is intentional to keep compression-webpack-plugin optional, but it triggers global-require. Add a one-line disable to keep the pattern explicit and lint-clean.

-if (moduleExists("compression-webpack-plugin")) {
-  const CompressionPlugin = require("compression-webpack-plugin")
+if (moduleExists("compression-webpack-plugin")) {
+  // eslint-disable-next-line global-require
+  const CompressionPlugin = require("compression-webpack-plugin")
   plugins.push(
     new CompressionPlugin({
       filename: "[path][base].gz[query]",
       algorithm: "gzip",
       test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/,
       threshold: 8192,
       minRatio: 0.8
     })
   )
 }

---

28-35: Guard minimizer plugins for broader Rspack version compatibility.

If a consumer is on an older Rspack that doesn’t expose these minimizer constructors, this will throw at startup. Consider guarding and letting minimize: true fall back to built-ins.

-productionConfig.optimization = {
-  minimize: true,
-  minimizer: [
-    new rspack.SwcJsMinimizerRspackPlugin(),
-    new rspack.LightningCssMinimizerRspackPlugin()
-  ]
-}
+productionConfig.optimization = {
+  minimize: true,
+  ...(rspack.SwcJsMinimizerRspackPlugin && rspack.LightningCssMinimizerRspackPlugin
+    ? {
+        minimizer: [
+          new rspack.SwcJsMinimizerRspackPlugin(),
+          new rspack.LightningCssMinimizerRspackPlugin()
+        ]
+      }
+    : {})
+}

If you prefer to keep the explicit minimizers, please confirm the minimum @rspack/core version in package.json aligns with these constructors.

---

41-41: Prettier: ensure newline at EOF.

Prettier requests a trailing newline. Save once to add it.

-module.exports = merge(baseConfig, productionConfig)
+module.exports = merge(baseConfig, productionConfig)
+

spec/shakapacker/config_path_spec.rb (1)

49-51: Optionally assert the error message for better signal.

You can also verify we emit the expected guidance when no configs are found.

Example:

expect($stderr).to receive(:puts).with(/rspack config .* not found/i)
expect { Shakapacker::RspackRunner.new([]) }.to raise_error(SystemExit)

If you want, I can add a separate example covering the fallback path where a webpack config exists and a deprecation is printed.

lib/shakapacker/dev_server_runner.rb (1)

66-71: Minor: only set WEBPACK_SERVE for webpack.

This env var is a webpack-dev-server hint and is unnecessary for Rspack.

-        env["SHAKAPACKER_CONFIG"] = @shakapacker_config
-        env["WEBPACK_SERVE"] = "true"
+        env["SHAKAPACKER_CONFIG"] = @shakapacker_config
+        env["WEBPACK_SERVE"] = "true" if get_bundler_type == "webpack"

package/rspack/rules/stylus.js (1)

18-18: Prettier: ensure newline at EOF.

Add the trailing newline to satisfy Prettier.

-)
+)
+

package/rspack/rules/css.js (3)

3-22: Unify CSS handling via getStyleRule for consistency and correctness (fixes importLoaders, PostCSS, and CSS Modules).

This rule diverges from the shared getStyleRule behavior used elsewhere (e.g., less/sass). As written:

• importLoaders is 1 while there are no loaders after css-loader, which is incorrect for @import processing.
• PostCSS is not attempted when present.
• CSS Modules behavior differs (modules: false vs modules: { auto: true }).

Adopting getStyleRule aligns behavior across style rules and avoids future drift.

Apply this diff:

 const { rspack } = require("@rspack/core")
-const inliningCss = require("../../utils/inliningCss")
-const { moduleExists } = require("../../utils/helpers")
+const inliningCss = require("../../utils/inliningCss")
+const { getStyleRule } = require("../../utils/getStyleRule")

 const { CssExtractRspackPlugin } = rspack

-// Simple CSS rule for rspack - don't use getStyleRule to avoid complexity
-module.exports = moduleExists("css-loader") ? {
-  test: /\.(css)$/i,
-  type: 'javascript/auto',
-  use: [
-    inliningCss ? "style-loader" : CssExtractRspackPlugin.loader,
-    {
-      loader: "css-loader",
-      options: {
-        sourceMap: true,
-        importLoaders: 1,
-        modules: false
-      }
-    }
-  ]
-} : null
+// Delegate to shared getStyleRule for consistent css-loader/postcss handling
+module.exports = getStyleRule(/\.(css)$/i, [
+  inliningCss ? "style-loader" : CssExtractRspackPlugin.loader
+])

---

15-18: If keeping the bespoke rule: fix importLoaders to 0 and consider PostCSS.

With only css-loader in the chain (extraction loader does not count), importLoaders should be 0. Also consider adding PostCSS when available to match other style rules.

Apply this diff:

-        importLoaders: 1,
-        modules: false
+        importLoaders: 0,
+        modules: false

Optional: add PostCSS when present

   use: [
     inliningCss ? "style-loader" : CssExtractRspackPlugin.loader,
     {
       loader: "css-loader",
       options: {
         sourceMap: true,
-        importLoaders: 0,
+        importLoaders: 1,
         modules: false
       }
-    }
+    },
+    // only if postcss-loader is installed:
+    // require("../../utils/helpers").canProcess("postcss-loader", (loaderPath) => ({
+    //   loader: loaderPath,
+    //   options: { sourceMap: true }
+    // }))
   ]

---

8-22: Prettier violations reported by ESLint.

Formatting issues (indentation, quotes, and trailing newlines) are flagged by Prettier. The refactor above will incidentally satisfy these, but if you retain the current structure, please run the formatter.

lib/shakapacker/runner.rb (2)

44-46: Unused private method get_bundler_type.

Currently unused in this class. Either remove or use where appropriate (e.g., dev server runner).

-      def get_bundler_type
-        @config.bundler
-      end
+      # def get_bundler_type
+      #   @config.bundler
+      # end

---

48-73: Clear rspack config fallback with deprecation guidance. Consider exit vs exit!.

The fallback/warning path is helpful. Minor: exit! skips at_exit and ensure blocks; if that’s intentional in CLI context, fine. Otherwise, Kernel.exit(1) is safer.

package/rspack/rules/less.js (2)

21-22: Prefer resolving node_modules from the app root, not the library directory.

path.resolve(__dirname, "node_modules") points to this package’s node_modules, not the application’s. Using process.cwd() better reflects the Rails app context during compilation.

Apply this diff:

-          paths: [path.resolve(__dirname, "node_modules"), sourcePath, ...paths]
+          paths: [path.resolve(process.cwd(), "node_modules"), sourcePath, ...paths]

---

27-27: Prettier: add trailing newline.

ESLint reports a missing newline at end of file.

-)
+)
+

lib/shakapacker/rspack_runner.rb (1)

1-1: Remove unused require "shellwords".

Not used in this file.

-require "shellwords"

lib/install/bin/shakapacker (1)

12-16: Consider extracting environment resolution logic for consistency.

The environment resolution logic ENV["RAILS_ENV"] || ENV["NODE_ENV"] || "development" appears both here (line 15) and at line 3. Consider using the value already set at line 3 to avoid duplication.

   config = Shakapacker::Configuration.new(
     root_path: Pathname.new(APP_ROOT),
     config_path: Pathname.new(File.join(APP_ROOT, "config/shakapacker.yml")),
-    env: ENV["RAILS_ENV"] || ENV["NODE_ENV"] || "development"
+    env: ENV["RAILS_ENV"]
   )

package/rspack/index.js (1)

40-40: Add trailing newline for consistency.

-  merge: rspackMerge
+  merge: rspackMerge
+

package/rspack/environments/base.js (3)

80-80: Use consistent quote style.

The codebase appears to use double quotes for strings. Consider maintaining consistency.

-      fileName: config.manifestPath.split('/').pop(), // Get just the filename
+      fileName: config.manifestPath.split("/").pop(), // Get just the filename

---

94-134: Consider refactoring the entrypoints loop for better readability.

While the for...of loop works correctly, consider using Object.entries().forEach() or reduce() to align with the functional programming style used elsewhere in the codebase. This would also address the ESLint warning about avoiding loops.

-        for (const [entrypointName, entrypointFiles] of Object.entries(entrypoints)) {
-          const jsFiles = entrypointFiles.filter(file => file.endsWith('.js'))
-          const cssFiles = entrypointFiles.filter(file => file.endsWith('.css'))
-          
-          // Use a helper function to resolve file paths consistently
-          const resolveFilePath = (file) => {
-            // Try exact match first
-            if (manifest[file]) return manifest[file]
-            
-            // Try filename only
-            const filename = file.split('/').pop()
-            if (manifest[filename]) return manifest[filename]
-            
-            // For hashed files, try to find the base name without hash
-            // e.g., "css/org-350a7e61.css" -> "org.css"
-            const baseMatch = filename.match(/^(.+?)-[a-f0-9]+(\.\w+)$/)
-            if (baseMatch) {
-              const baseName = baseMatch[1] + baseMatch[2] // "org.css"
-              if (manifest[baseName]) return manifest[baseName]
-            }
-            
-            // For webpack chunk files with full directory path
-            // e.g., "js/598-7f94a9abddc251f3.js" -> "js/598-js"
-            const chunkMatch = file.match(/^(.+\/)?(\d+)-[a-f0-9]+\.(js|css)$/)
-            if (chunkMatch) {
-              const [, dir = '', chunkNum, ext] = chunkMatch
-              const chunkKey = `${dir}${chunkNum}-${ext}` // "js/598-js"
-              if (manifest[chunkKey]) return manifest[chunkKey]
-            }
-            
-            // Fallback to original file path
-            return file
-          }
-          
-          entrypointsManifest[entrypointName] = {
-            assets: {
-              js: jsFiles.map(resolveFilePath),
-              css: cssFiles.map(resolveFilePath)
-            }
-          }
-        }
+        const entrypointsManifest = Object.entries(entrypoints).reduce(
+          (acc, [entrypointName, entrypointFiles]) => {
+            const jsFiles = entrypointFiles.filter((file) =>
+              file.endsWith(".js")
+            )
+            const cssFiles = entrypointFiles.filter((file) =>
+              file.endsWith(".css")
+            )
+
+            // Use a helper function to resolve file paths consistently
+            const resolveFilePath = (file) => {
+              // Try exact match first
+              if (manifest[file]) return manifest[file]
+
+              // Try filename only
+              const filename = file.split("/").pop()
+              if (manifest[filename]) return manifest[filename]
+
+              // For hashed files, try to find the base name without hash
+              // e.g., "css/org-350a7e61.css" -> "org.css"
+              const baseMatch = filename.match(/^(.+?)-[a-f0-9]+(\.\w+)$/)
+              if (baseMatch) {
+                const baseName = baseMatch[1] + baseMatch[2] // "org.css"
+                if (manifest[baseName]) return manifest[baseName]
+              }
+
+              // For webpack chunk files with full directory path
+              // e.g., "js/598-7f94a9abddc251f3.js" -> "js/598-js"
+              const chunkMatch = file.match(/^(.+\/)?(\d+)-[a-f0-9]+\.(js|css)$/)
+              if (chunkMatch) {
+                const [, dir = "", chunkNum, ext] = chunkMatch
+                const chunkKey = `${dir}${chunkNum}-${ext}` // "js/598-js"
+                if (manifest[chunkKey]) return manifest[chunkKey]
+              }
+
+              // Fallback to original file path
+              return file
+            }
+
+            acc[entrypointName] = {
+              assets: {
+                js: jsFiles.map(resolveFilePath),
+                css: cssFiles.map(resolveFilePath)
+              }
+            }
+            return acc
+          },
+          {}
+        )

---

219-219: Add trailing newline for consistency.

   module: {
     rules
   }
-}
+}
+

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: marvinthepa
PR: shakacode/shakapacker#520
File: spec/shakapacker/utils_manager_spec.rb:68-89
Timestamp: 2024-10-09T10:47:17.620Z
Learning: In `spec/shakapacker/utils_manager_spec.rb`, the code within the context `"when lockfile is in Rails.root, but pwd is different"` is not duplicated for each package manager.

Learnt from: marvinthepa
PR: shakacode/shakapacker#520
File: spec/shakapacker/utils_manager_spec.rb:104-116
Timestamp: 2024-10-09T10:50:16.512Z
Learning: In `spec/shakapacker/utils_manager_spec.rb`, `error_unless_package_manager_is_obvious` is not a test method, so extracting into a shared context may not be helpful.

Learnt from: marvinthepa
PR: shakacode/shakapacker#520
File: lib/shakapacker/utils/manager.rb:19-19
Timestamp: 2024-10-09T10:46:03.499Z
Learning: In the Shakapacker project, within `lib/shakapacker/runner.rb`, `PackageJson.read(app_path)` is used to read `package.json` using the application path, ensuring the correct path is used regardless of the current working directory.

Learnt from: marvinthepa
PR: shakacode/shakapacker#520
File: lib/shakapacker/utils/manager.rb:19-19
Timestamp: 2024-10-09T10:46:03.499Z
Learning: In `lib/install/template.rb` of the Shakapacker project, calls to `PackageJson.read` are wrapped inside `Dir.chdir(Rails.root)`, ensuring that `package.json` is read from the Rails root directory.

package/rspack/rules/sass.js (3)

1-3: Gate Sass rule on loader availability and import helper (align with other preprocessors).

If sass-loader isn’t installed, the current unguarded rule will break builds. Import canProcess and use it to guard rule creation (same pattern as Stylus/others).

Apply this diff:

 const { rspack } = require("@rspack/core")
 const { getStyleRule } = require("../../utils/getStyleRule")
+const { canProcess } = require("../../utils/helpers")
 const inliningCss = require("../../utils/inliningCss")

---

7-15: Build the loader from the resolved path; keep options; future-proof for ERB variants.

Construct the Sass loader using the resolved path returned by canProcess to avoid resolution issues and to match patterns used elsewhere.

Apply this diff:

-const sassLoader = {
-  loader: "sass-loader",
-  options: {
-    sourceMap: true,
-    sassOptions: {
-      quietDeps: true
-    }
-  }
-}
+const makeSassLoader = (resolvedPath) => ({
+  loader: resolvedPath,
+  options: {
+    sourceMap: true,
+    sassOptions: {
+      quietDeps: true
+    }
+  }
+})

---

17-22: Wrap export with canProcess and include .erb variants; also fixes config-time crashes.

This prevents crashes when Sass isn’t used and adds support for .scss.erb/.sass.erb which is common in Rails apps.

Apply this diff:

-// getStyleRule handles css-loader and postcss-loader internally
-// We only need to pass the extraction loader and sass-loader
-module.exports = getStyleRule(/\.(scss|sass)$/i, [
-  inliningCss ? "style-loader" : CssExtractRspackPlugin.loader,
-  sassLoader
-])
+// getStyleRule handles css-loader and postcss-loader internally
+// We only need to pass the extraction loader and sass-loader
+module.exports = canProcess("sass-loader", (resolvedPath) =>
+  getStyleRule(/\.(scss|sass)(\.erb)?$/i, [
+    inliningCss ? "style-loader" : CssExtractRspackPlugin.loader,
+    makeSassLoader(resolvedPath)
+  ])
+)

package/rspack/rules/sass.js (2)

22-22: Prettier: ensure file ends with a single newline.

Static analysis flagged a missing trailing newline.

Apply this diff (if needed):

 ])
+ 

---

19-21: Optional: guard style-loader resolution when inlining CSS.

If inliningCss is true but style-loader isn’t installed, builds will fail. You can resolve it via canProcess('style-loader') and fallback to extraction if missing. This keeps DX consistent across projects that don’t inline.

Proposed inline tweak (illustrative; adjust to your helpers’ return shape):

-    inliningCss ? "style-loader" : CssExtractRspackPlugin.loader,
+    inliningCss
+      ? (canProcess("style-loader", (p) => p) || CssExtractRspackPlugin.loader)
+      : CssExtractRspackPlugin.loader,

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

package/rspack/rules/raw.js (2)

3-4: Tighten the resourceQuery to avoid false positives like “?draw”

Current /raw/ will match any query containing “raw” (e.g., ?draw, ?b=rawness). Use a stricter regex to match ?raw, ?raw=..., or ?a=1&raw precisely.

Apply this diff:

-  resourceQuery: /raw/,
+  resourceQuery: /^\?raw(?:$|&|=)/,

---

3-4: Optional: Limit “?raw” to text-like assets or document its scope

asset/source returns a string. If someone imports a binary (e.g., PNG) with “?raw”, they’ll get a string which is likely not useful. Consider restricting via test to common text extensions (e.g., .txt, .md, .svg) or explicitly document that “?raw” is intended for textual resources.

package/rspack/environments/production.js (3)

7-11: Verify compatibility of compression-webpack-plugin with Rspack.

compression-webpack-plugin is designed for Webpack. While many Webpack plugins work with Rspack, compatibility isn’t universal. Please confirm it runs correctly in your Rspack builds, or guard it behind a config flag.

If needed, consider making compression configurable (enable/disable, algorithm brotli/gzip) through the project config.

---

13-17: Make production source maps configurable.

Hard-coding devtool: "source-map" may be undesirable for some apps due to bundle size and source exposure. Consider driving this from config (e.g., allow "hidden-source-map" or "false").

Apply this diff to read from config if available:

-  devtool: "source-map",
+  // Prefer making this configurable; fallback preserves current behavior
+  devtool: process.env.SHAKAPACKER_PROD_DEVTOOL || "source-map",

---

23-31: Optional: exclude .map from precompression or allow opt-in.

Precompressing source maps increases build time and storage; many servers compress them on-the-fly. Consider excluding .map files by default or making it configurable.

-      test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/,
+      test: /\.(js|css|html|json|ico|svg|eot|otf|ttf)$/,

package/rspack/environments/base.js (2)

109-111: Make filename extraction robust across OS path separators.

When deriving filename, handle both "/" and "".

Apply this diff:

-              const filename = file.split("/").pop()
+              const filename = file.split(/[\\/]/).pop()

---

185-186: Avoid hardcoding mode in base; derive from environment or omit.

Base is merged into both dev and prod. Hardcoding "production" increases the risk of accidentally running dev builds with prod defaults if a future change forgets to override. Derive from isProduction or drop mode here.

Apply this diff:

-  mode: "production",
+  mode: isProduction ? "production" : "development",

Alternatively, remove the mode from base and set it only in environment-specific configs.

package/index.d.ts (1)

85-92: Optional: Alias RuleSetRule to avoid ambiguity across bundlers.

Both modules use a RuleSetRule type but from different sources (webpack vs @rspack/core). To reduce cognitive load and prevent accidental mixups in future edits, consider aliasing the Rspack one:

-declare module 'shakapacker/rspack' {
-  import type { RspackOptions, RuleSetRule } from '@rspack/core'
+declare module 'shakapacker/rspack' {
+  import type { RspackOptions, RuleSetRule as RspackRuleSetRule } from '@rspack/core'
   import type { Config, Env } from 'shakapacker'
   ...
-  export const rules: RuleSetRule[]
+  export const rules: RspackRuleSetRule[]

package.json (1)

62-81: Consider making webpack an optional peer for Rspack-only installs.

If Rspack usage is supported without installing webpack, requiring "webpack" as a hard peer will create unnecessary warnings for Rspack users. Mark it optional in peerDependenciesMeta.

   "peerDependenciesMeta": {
     "@types/babel__core": {
       "optional": true
     },
     "@types/webpack": {
       "optional": true
     },
     "webpack-subresource-integrity": {
       "optional": true
     },
+    "webpack": {
+      "optional": true
+    },
     "@rspack/core": {
       "optional": true
     },
     "@rspack/cli": {
       "optional": true
     },
     "rspack-manifest-plugin": {
       "optional": true
     }
   },

If webpack remains a hard requirement by design, consider adding a short note in the Rspack docs clarifying that webpack must still be present to avoid peer warnings.

Also applies to: 82-101

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.