shakapacker 9.6.0.rc.0 → 9.6.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5240d4875989d1257b2c24656db7b29c5d052a9c99e22b9203565bf615aaf43
-  data.tar.gz: 855e3c61ff9169c2f4a34cc864d80f41299e48fd2530fb0def09e5bd9e07651f
+  metadata.gz: 68ba8fdde7f793bee53354a639cf21695963ff564e3478de1e19711f9e71704d
+  data.tar.gz: f5baa408e07f17e89cb0ba19abe652a4eeba151400b5014b4381156221e25811
 SHA512:
-  metadata.gz: 719593b91e0dd86f68db334fe533a76e05ebf7862e04162039b066182bc52642e4c200d0394e6f3cbfaea8a8600d5340d20d9a5cd54bd389c40e4d4ff8c1f055
-  data.tar.gz: 80f22641a2e9cba2ab9a8ccda6095133e636165185914b8ae1b6f7a85f1b860834913dc4a697db7d1785f001420e47aefad34584389c0221dc7eb7e0f9778957
+  metadata.gz: 3845c0fd8e02339a077dd2a385bc2ed32905e62f56f786177c5761ddca3fab1b521bb92aeb1469458657cb139273137079a33e1ebbffba9574cf1e192e56fac2
+  data.tar.gz: 81d6113206160b9184bc1a0016cbe52d0c0ee565cd951da3b613ae99dd58ea83279d6ee60bfa6be8f14a2d524900941ed7568c8169ba2d855a9734c856260cc3

data/.github/workflows/claude-code-review.yml

@@ -12,6 +12,7 @@ jobs:
       contents: read
       pull-requests: write
       issues: write
+      id-token: write
 
     steps:
       - name: Checkout repository

data/CHANGELOG.md

@@ -11,6 +11,8 @@
 
 Changes since the last non-beta release.
 
+## [v9.6.0-rc.0] - March 5, 2026
+
 ### Security
 
 - Removed default `Access-Control-Allow-Origin: *` header from dev server configuration. This header allowed any website to access dev server resources. **If your setup runs webpack-dev-server on a different port from your Rails server, uncomment the `headers` section in `config/shakapacker.yml` to restore cross-origin asset loading.** [PR #936](https://github.com/shakacode/shakapacker/pull/936) by [justin808](https://github.com/justin808). Fixes [#935](https://github.com/shakacode/shakapacker/issues/935).
@@ -35,6 +37,7 @@ Changes since the last non-beta release.
 
 ### Changed
 
+- **Changed default file rule type from `asset/resource` to `asset`**. [PR #901](https://github.com/shakacode/shakapacker/pull/901) by [justin808](https://github.com/justin808). Static assets (images, fonts, SVGs) now use webpack/rspack's `asset` type instead of `asset/resource`, allowing the bundler to automatically inline small files as data URIs for better performance.
 - Allow `compression-webpack-plugin` v12. [PR #937](https://github.com/shakacode/shakapacker/pull/937) by [G-Rath](https://github.com/G-Rath).
 - **BREAKING: sass-loader now defaults to modern Sass API**. [PR #879](https://github.com/shakacode/shakapacker/pull/879) by [justin808](https://github.com/justin808). The sass-loader configuration now uses `api: "modern"` instead of the deprecated legacy API. This improves compatibility with plugins like sass-resources-loader that require the modern API. If you experience issues after upgrading, you can revert to the legacy API by customizing your webpack config:
 
@@ -63,6 +66,7 @@ Changes since the last non-beta release.
 - **Fixed orphaned webpack/rspack processes when foreman receives SIGTERM**. [PR #888](https://github.com/shakacode/shakapacker/pull/888) by [jordan-brough](https://github.com/jordan-brough). When running under foreman, sending SIGTERM to foreman (e.g. `kill <pid>`) would kill the Ruby shakapacker process but leave the webpack/rspack child process running as an orphan. DevServerRunner now uses `exec` to replace the Ruby process entirely, and Runner uses `spawn` with SIGTERM forwarding to ensure the child process is properly terminated.
 - **Fixed missing-environment fallback to use production instead of development**. [PR #894](https://github.com/shakacode/shakapacker/pull/894) by [justin808](https://github.com/justin808). When a Rails environment (e.g., staging) is not defined in `shakapacker.yml`, Shakapacker now falls back to the `production` configuration instead of `development`. This ensures unknown environments get production-optimized webpack/rspack builds by default.
 - **Fixed installer writing wrong shakapacker version in package.json**. [PR #899](https://github.com/shakacode/shakapacker/pull/899) by [justin808](https://github.com/justin808). The `shakapacker:install` generator now keeps the `package.json` dependency value in sync with the exact version or path that was requested, instead of relying on the post-install value which could differ.
+- **Fixed `privateOutputPath` not being computed in JavaScript config**. [PR #891](https://github.com/shakacode/shakapacker/pull/891) by [ihabadham](https://github.com/ihabadham). The `private_output_path` setting from `shakapacker.yml` is now properly resolved to an absolute path and exposed as `privateOutputPath` in the JavaScript configuration, matching the behavior already present in the Ruby configuration.
 - **Fixed installer not updating `shakapacker.yml` when selecting a non-default transpiler**. [PR #895](https://github.com/shakacode/shakapacker/pull/895) by [codex-rs](https://github.com/apps/codex-rs). Installing with `JAVASCRIPT_TRANSPILER=babel` (or `esbuild`) now correctly updates `config/shakapacker.yml` to match the selected transpiler instead of leaving it set to `swc`. Previously, a quote mismatch in the `gsub_file` call meant the config was never actually updated, and the condition also excluded `JAVASCRIPT_TRANSPILER=babel` from the update entirely. Additionally, `JAVASCRIPT_TRANSPILER=babel` no longer installs SWC packages.
 - **Fixed ENOENT crash on clean builds when using `webpack-assets-manifest` v6 with `merge: true`**. [PR #931](https://github.com/shakacode/shakapacker/pull/931) by [justin808](https://github.com/justin808). Seeds an empty `{}` manifest file before instantiating the plugin, so the merge read succeeds on first build rather than throwing an unhandled ENOENT.
 - **Improved error message when manifest is empty or missing**. [PR #872](https://github.com/shakacode/shakapacker/pull/872) by [justin808](https://github.com/justin808). When the bundler is still compiling (empty manifest) or hasn't run yet (missing manifest file), users now see clear, actionable error messages instead of the generic 7-point checklist.
@@ -116,7 +120,7 @@ Changes since the last non-beta release.
 
 - **Added `SHAKAPACKER_SKIP_PRECOMPILE_HOOK` environment variable to skip precompile hook**. [PR #850](https://github.com/shakacode/shakapacker/pull/850) by [justin808](https://github.com/justin808). Set `SHAKAPACKER_SKIP_PRECOMPILE_HOOK=true` to skip the precompile hook during compilation. This is useful when using process managers like Foreman or Overmind to run the hook once before starting multiple webpack processes, preventing duplicate hook execution. **Migration tip:** If you have a custom `bin/dev` script that starts multiple webpack processes, you can now run the precompile hook once in the script and set this environment variable to prevent each webpack process from running the hook again. See the [precompile hook documentation](./docs/precompile_hook.md#skipping-the-hook) for implementation examples.
 
-## [v9.3.4-beta.0] - November 17, 2025
+## [v9.3.4] - November 17, 2025
 
 ### Fixed
 
@@ -864,10 +868,11 @@ Note: [Rubygem is 6.3.0.pre.rc.1](https://rubygems.org/gems/shakapacker/versions
 
 See [CHANGELOG.md in rails/webpacker (up to v5.4.3)](https://github.com/rails/webpacker/blob/master/CHANGELOG.md)
 
-[Unreleased]: https://github.com/shakacode/shakapacker/compare/v9.5.0...main
+[Unreleased]: https://github.com/shakacode/shakapacker/compare/v9.6.0-rc.0...main
+[v9.6.0-rc.0]: https://github.com/shakacode/shakapacker/compare/v9.5.0...v9.6.0-rc.0
 [v9.5.0]: https://github.com/shakacode/shakapacker/compare/v9.4.0...v9.5.0
 [v9.4.0]: https://github.com/shakacode/shakapacker/compare/v9.3.4...v9.4.0
-[v9.3.4-beta.0]: https://github.com/shakacode/shakapacker/compare/v9.3.3...v9.3.4-beta.0
+[v9.3.4]: https://github.com/shakacode/shakapacker/compare/v9.3.3...v9.3.4
 [v9.3.3]: https://github.com/shakacode/shakapacker/compare/v9.3.2...v9.3.3
 [v9.3.2]: https://github.com/shakacode/shakapacker/compare/v9.3.1...v9.3.2
 [v9.3.1]: https://github.com/shakacode/shakapacker/compare/v9.3.0...v9.3.1

data/docs/releasing.md

@@ -9,6 +9,7 @@ This guide is for Shakapacker maintainers who need to publish a new release.
    ```bash
    bundle install              # Installs gem-release
    yarn global add release-it  # Installs release-it for npm publishing
+   gh --version                # Required only if you plan to run sync_github_release
    ```
 
 2. **Ensure you have publishing access:**
@@ -18,6 +19,8 @@ This guide is for Shakapacker maintainers who need to publish a new release.
 3. **Enable 2FA on both platforms:**
    - npm: 2FA is required for publishing
    - RubyGems: 2FA is required for publishing
+4. **If you plan to run `sync_github_release`, authenticate GitHub CLI:**
+   - Run `gh auth login` and ensure your account/token has write access to this repository
 
 ## Release Process
 
@@ -26,9 +29,7 @@ This guide is for Shakapacker maintainers who need to publish a new release.
 Before running the release task:
 
 1. Ensure all desired changes are merged to `main` branch
-2. Update `CHANGELOG.md` with the new version and release notes
-3. Commit the CHANGELOG changes
-4. Ensure your working directory is clean (`git status` shows no uncommitted changes)
+2. Ensure your working directory is clean (`git status` shows no uncommitted changes)
 
 ### 2. Run the Release Task
 
@@ -36,38 +37,89 @@ The automated release task handles the entire release process:
 
 ```bash
 # For a specific version (e.g., 9.1.0)
-bundle exec rake create_release[9.1.0]
+bundle exec rake "create_release[9.1.0]"
 
 # For a beta release (note: use period, not dash)
-bundle exec rake create_release[9.2.0.beta.1]  # Creates npm package 9.2.0-beta.1
+bundle exec rake "create_release[9.2.0.beta.1]"  # Creates npm package 9.2.0-beta.1
+
+# For a release candidate
+bundle exec rake "create_release[9.6.0.rc.0]"
+
+# Auto-calculate next prerelease and confirm before publishing
+bundle exec rake "create_prerelease[9.6.0]"      # defaults to rc -> 9.6.0.rc.0 or 9.6.0.rc.1, etc.
+bundle exec rake "create_prerelease[9.6.0,rc]"   # -> 9.6.0.rc.0 or 9.6.0.rc.1, etc.
+bundle exec rake "create_prerelease[9.6.0,beta]" # -> 9.6.0.beta.0 or 9.6.0.beta.1, etc.
 
 # For a patch version bump (auto-increments)
-bundle exec rake create_release
+bundle exec rake create_release  # prompts to confirm computed patch version
 
 # Dry run to test without publishing
-bundle exec rake create_release[9.1.0,true]
+bundle exec rake "create_release[9.1.0,true]"
+
+# Override version policy checks (monotonic + changelog/bump consistency)
+RELEASE_VERSION_POLICY_OVERRIDE=true bundle exec rake "create_release[9.1.0]"
+bundle exec rake "create_release[9.1.0,false,true]"
 ```
 
+Dry runs use a temporary git worktree so version bumps and installs do not modify your current checkout.
+
+`create_release` and `create_prerelease` validate release-version policy before publishing:
+- Target version must be greater than the latest tagged release.
+- If the versioned target changelog section exists (`## [vX.Y.Z...]`; not `UNRELEASED`), it maps to expected bump type:
+  - Breaking changes => major bump
+  - Added/New Features/Features/Enhancements => minor bump
+  - Fixed/Fixes/Bug Fixes/Security/Improved/Deprecated => patch bump
+  - Other headings => no inferred bump level (consistency check is skipped)
+
+Use override only when needed:
+- `RELEASE_VERSION_POLICY_OVERRIDE=true`
+- Or task arg override (`create_release[..., ..., true]`, `create_prerelease[..., ..., ..., true]`)
+
 ### 3. What the Release Task Does
 
 The `create_release` task automatically:
 
-1. **Pulls latest changes** from the repository
-2. **Bumps version numbers** in:
+1. **Validates release prerequisites**:
+   - Verifies npm authentication
+2. **Pulls latest changes** from the repository
+3. **Bumps version numbers** in:
    - `lib/shakapacker/version.rb` (Ruby gem version)
    - `package.json` (npm package version - converted from Ruby format)
-3. **Publishes to npm:**
+4. **Publishes to npm:**
    - Prompts for npm OTP (2FA code)
    - Creates git tag
    - Pushes to GitHub
-4. **Publishes to RubyGems:**
+5. **Publishes to RubyGems:**
    - Prompts for RubyGems OTP (2FA code)
-5. **Updates spec/dummy lockfiles:**
+6. **Updates spec/dummy lockfiles:**
    - Runs `bundle install` to update `Gemfile.lock`
    - Runs `npm install` to update `package-lock.json` (yarn.lock may also be updated for multi-package-manager compatibility testing)
-6. **Commits and pushes lockfile changes** automatically
+7. **Commits and pushes lockfile changes** automatically
+
+### 4. Sync GitHub Release (Optional, After Publish)
+
+If you want GitHub Releases, do that as a separate step after publishing.
+Requires GitHub CLI (`gh`) with write access to this repository:
+
+Legacy note: `SKIP_GITHUB_RELEASE=true` is no longer used by release tasks. GitHub release creation is now an explicit, separate step via `sync_github_release`.
+
+1. Run `bundle exec rake update_changelog`
+2. Update `CHANGELOG.md` with the published version section
+   - For prerelease entries, use npm semver header format with dashes, for example `## [v9.6.0-rc.1]`
+3. Commit `CHANGELOG.md`
+4. Run:
+
+```bash
+# Stable
+bundle exec rake "sync_github_release[9.6.0]"
+
+# Prerelease
+bundle exec rake "sync_github_release[9.6.0.rc.1]"
+```
+
+`sync_github_release` reads release notes from the matching `CHANGELOG.md` section and creates/updates the GitHub release for the corresponding tag.
 
-### 4. Version Format
+### 5. Version Format
 
 **Important:** Use Ruby gem version format (no dashes):
 
@@ -83,28 +135,35 @@ The task automatically converts Ruby gem format to npm semver format:
 
 ```bash
 # Regular release
-bundle exec rake create_release[9.1.0]  # Gem: 9.1.0, npm: 9.1.0
+bundle exec rake "create_release[9.1.0]"  # Gem: 9.1.0, npm: 9.1.0
 
 # Beta release
-bundle exec rake create_release[9.2.0.beta.1]  # Gem: 9.2.0.beta.1, npm: 9.2.0-beta.1
+bundle exec rake "create_release[9.2.0.beta.1]"  # Gem: 9.2.0.beta.1, npm: 9.2.0-beta.1
 
 # Release candidate
-bundle exec rake create_release[10.0.0.rc.1]  # Gem: 10.0.0.rc.1, npm: 10.0.0-rc.1
+bundle exec rake "create_release[10.0.0.rc.1]"  # Gem: 10.0.0.rc.1, npm: 10.0.0-rc.1
+
+# Auto-next prerelease (recommended)
+bundle exec rake "create_prerelease[10.0.0,rc]"  # picks rc.0 then rc.1, etc., with confirmation
 ```
 
-### 5. During the Release
+The `create_prerelease` task defaults to `rc` if prerelease type is omitted. Use `beta` explicitly when needed.
+
+### 6. During the Release
 
 1. When prompted for **npm OTP**, enter your 2FA code from your authenticator app
 2. Accept defaults for release-it options
 3. When prompted for **RubyGems OTP**, enter your 2FA code
-4. The script will automatically commit and push lockfile updates
+4. If using patch auto-bump (`create_release` with no version), confirm the computed patch version when prompted
+5. If using `create_prerelease`, confirm the computed next prerelease version when prompted
+6. The script will automatically commit and push lockfile updates
 
-### 6. After Release
+### 7. After Release
 
 1. Verify the release on:
    - [npm](https://www.npmjs.com/package/shakapacker)
    - [RubyGems](https://rubygems.org/gems/shakapacker)
-   - [GitHub releases](https://github.com/shakacode/shakapacker/releases)
+   - [GitHub releases](https://github.com/shakacode/shakapacker/releases) if you ran `sync_github_release`
 
 2. Check that the lockfile commit was pushed:
 
@@ -141,6 +200,26 @@ If publishing fails partway through:
 3. If RubyGems failed: Fix the issue and manually run `gem release`
 4. Then manually update and commit spec/dummy lockfiles
 
+### GitHub Release Sync Fails
+
+If package publishing succeeds but `sync_github_release` fails:
+
+1. Fix GitHub auth (`gh auth login`) or permissions
+2. Ensure `CHANGELOG.md` has matching header `## [vX.Y.Z...]` (npm format for prereleases)
+3. Rerun only:
+
+   ```bash
+   bundle exec rake "sync_github_release[<gem_version>]"
+   ```
+
+### Legacy `SKIP_GITHUB_RELEASE` Usage
+
+If your CI or local runbook still sets `SKIP_GITHUB_RELEASE=true`:
+
+1. `create_release` and `create_prerelease` now always skip GitHub release creation by design
+2. Remove `SKIP_GITHUB_RELEASE` from scripts to avoid confusion
+3. Run `sync_github_release` explicitly when you want to create or update a GitHub release
+
 ### Wrong Version Format
 
 If you accidentally use npm format (with dashes):

data/lib/install/template.rb

@@ -18,7 +18,7 @@ install_dir = File.expand_path(File.dirname(__FILE__))
 # Installation strategy:
 # - USE_BABEL_PACKAGES installs both babel AND swc for compatibility
 # - Otherwise install only the specified transpiler
-if ENV["USE_BABEL_PACKAGES"] == "true" || ENV["USE_BABEL_PACKAGES"] == "1"
+if Shakapacker::Install::Env.truthy_env?("USE_BABEL_PACKAGES")
   @transpiler_to_install = "babel"
   @install_swc_compat_packages = true
   say "📦 Installing Babel packages (USE_BABEL_PACKAGES is set)", :yellow
@@ -52,7 +52,7 @@ end
 # Detect TypeScript usage
 # Auto-detect from tsconfig.json or explicit via SHAKAPACKER_USE_TYPESCRIPT env var
 @use_typescript = File.exist?(Rails.root.join("tsconfig.json")) ||
-  ENV["SHAKAPACKER_USE_TYPESCRIPT"] == "true"
+  Shakapacker::Install::Env.truthy_env?("SHAKAPACKER_USE_TYPESCRIPT")
 assets_bundler = ENV["SHAKAPACKER_ASSETS_BUNDLER"] || "webpack"
 config_extension = @use_typescript ? "ts" : "js"
 
@@ -225,7 +225,7 @@ Dir.chdir(Rails.root) do
 
   # Inline fetch_peer_dependencies and fetch_common_dependencies
   peers = PackageJson.read(install_dir).fetch(ENV["SHAKAPACKER_ASSETS_BUNDLER"] || "webpack")
-  common_deps = ENV["SKIP_COMMON_LOADERS"] ? {} : PackageJson.read(install_dir).fetch("common")
+  common_deps = Shakapacker::Install::Env.truthy_env?("SKIP_COMMON_LOADERS") ? {} : PackageJson.read(install_dir).fetch("common")
   peers = peers.merge(common_deps)
 
   # Add transpiler-specific dependencies based on detected/configured transpiler

data/lib/shakapacker/version.rb

@@ -1,4 +1,4 @@
 module Shakapacker
   # Change the version in package.json too, please!
-  VERSION = "9.6.0.rc.0".freeze
+  VERSION = "9.6.0.rc.1".freeze
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shakapacker",
-  "version": "9.6.0-rc.0",
+  "version": "9.6.0-rc.1",
   "description": "Use webpack to manage app-like JavaScript modules in Rails",
   "homepage": "https://github.com/shakacode/shakapacker",
   "bugs": {

data/test/package/rspack/index.test.js

@@ -0,0 +1,251 @@
+/* eslint-disable jest/no-conditional-in-test */
+
+const { chdirTestApp } = require("../../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+// Mock config to ensure assets_bundler is set to rspack
+jest.mock("../../../package/config", () => {
+  const actual = jest.requireActual("../../../package/config")
+  return {
+    ...actual,
+    assets_bundler: "rspack"
+  }
+})
+
+// Mock helpers before requiring the rspack module
+jest.mock("../../../package/utils/helpers", () => {
+  const original = jest.requireActual("../../../package/utils/helpers")
+  const moduleExists = jest.fn(() => true)
+  return {
+    ...original,
+    moduleExists
+  }
+})
+
+// Mock validateDependencies to prevent actual validation
+jest.mock("../../../package/utils/validateDependencies", () => ({
+  validateRspackDependencies: jest.fn()
+}))
+
+describe("rspack/index", () => {
+  let rspackIndex
+  let validateRspackDependencies
+
+  beforeEach(() => {
+    jest.resetModules()
+    rspackIndex = require("../../../package/rspack/index")
+    ;({
+      validateRspackDependencies
+    } = require("../../../package/utils/validateDependencies"))
+  })
+
+  afterAll(() => process.chdir(rootPath))
+
+  describe("exports", () => {
+    test("exports webpack-merge v5 functions", () => {
+      expect(rspackIndex.merge).toBeInstanceOf(Function)
+      expect(rspackIndex.mergeWithRules).toBeInstanceOf(Function)
+      expect(rspackIndex.mergeWithCustomize).toBeInstanceOf(Function)
+      expect(rspackIndex.unique).toBeInstanceOf(Function)
+    })
+
+    test("exports config object", () => {
+      expect(rspackIndex.config).toHaveProperty("source_path")
+      expect(rspackIndex.config).toHaveProperty("public_output_path")
+    })
+
+    test("exports devServer object", () => {
+      expect(rspackIndex.devServer).toBeDefined()
+    })
+
+    test("exports generateRspackConfig function", () => {
+      expect(rspackIndex.generateRspackConfig).toBeInstanceOf(Function)
+    })
+
+    test("exports baseConfig object", () => {
+      expect(rspackIndex.baseConfig).toBeDefined()
+      expect(rspackIndex.baseConfig).toHaveProperty("mode")
+    })
+
+    test("exports env object", () => {
+      expect(rspackIndex.env).toHaveProperty("railsEnv")
+      expect(rspackIndex.env).toHaveProperty("nodeEnv")
+    })
+
+    test("exports rules array", () => {
+      expect(Array.isArray(rspackIndex.rules)).toBe(true)
+      expect(rspackIndex.rules.length).toBeGreaterThan(0)
+    })
+
+    test("exports moduleExists function", () => {
+      expect(typeof rspackIndex.moduleExists).toBe("function")
+    })
+
+    test("exports canProcess function", () => {
+      expect(rspackIndex.canProcess).toBeInstanceOf(Function)
+    })
+
+    test("exports inliningCss value", () => {
+      expect(typeof rspackIndex.inliningCss).toBe("boolean")
+    })
+  })
+
+  describe("generateRspackConfig", () => {
+    test("returns a valid rspack config object", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config).toBeDefined()
+      expect(config).toHaveProperty("mode")
+      expect(config).toHaveProperty("module")
+      expect(config).toHaveProperty("plugins")
+      expect(config).toHaveProperty("optimization")
+    })
+
+    test("returns a new top-level config object on each call", () => {
+      const config1 = rspackIndex.generateRspackConfig()
+      const config2 = rspackIndex.generateRspackConfig()
+
+      expect(config1).not.toBe(config2)
+      config1.newKey = "new value"
+
+      expect(config2).not.toHaveProperty("newKey")
+    })
+
+    test("merges extra config", () => {
+      const config = rspackIndex.generateRspackConfig({
+        newKey: "new value",
+        output: {
+          path: "new path"
+        }
+      })
+
+      expect(config).toHaveProperty("newKey", "new value")
+      expect(config).toHaveProperty("output.path", "new path")
+    })
+
+    test("includes module rules in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.module).toBeDefined()
+      expect(config.module.rules).toBeDefined()
+      expect(Array.isArray(config.module.rules)).toBe(true)
+      // The exact number of rules depends on which optional loaders are installed,
+      // so we only verify that at least some rules exist
+      expect(config.module.rules.length).toBeGreaterThan(0)
+    })
+
+    test("includes plugins in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.plugins).toBeDefined()
+      expect(Array.isArray(config.plugins)).toBe(true)
+    })
+
+    test("includes optimization in config", () => {
+      const config = rspackIndex.generateRspackConfig()
+
+      expect(config.optimization).toBeDefined()
+      expect(config.optimization).toHaveProperty("minimize")
+    })
+
+    test("errors if multiple configs are provided", () => {
+      expect(() => rspackIndex.generateRspackConfig({}, {})).toThrow(
+        "use webpack-merge to merge configs before passing them to Shakapacker"
+      )
+    })
+
+    test("validates rspack dependencies on generation", () => {
+      rspackIndex.generateRspackConfig()
+      expect(validateRspackDependencies).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe("rules", () => {
+    test("includes JavaScript/JSX rule with builtin:swc-loader", () => {
+      const jsRule = rspackIndex.rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule).toBeDefined()
+      expect(jsRule.type).toBe("javascript/auto")
+      expect(jsRule.use).toBeDefined()
+      expect(Array.isArray(jsRule.use)).toBe(true)
+      expect(jsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("includes TypeScript rule with builtin:swc-loader", () => {
+      const tsRule = rspackIndex.rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule).toBeDefined()
+      expect(tsRule.type).toBe("javascript/auto")
+      expect(tsRule.use).toBeDefined()
+      expect(Array.isArray(tsRule.use)).toBe(true)
+      expect(tsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("includes file/asset handling rule", () => {
+      const fileRule = rspackIndex.rules.find(
+        (rule) =>
+          rule.test &&
+          (rule.test.toString().includes("png") ||
+            rule.test.toString().includes("jpg") ||
+            rule.test.toString().includes("svg"))
+      )
+
+      expect(fileRule).toBeDefined()
+    })
+
+    test("includes raw file loading rule", () => {
+      const rawRule = rspackIndex.rules.find(
+        (rule) => rule.type === "asset/source"
+      )
+
+      expect(rawRule).toBeDefined()
+    })
+  })
+
+  describe("helper functions", () => {
+    test("moduleExists returns boolean", () => {
+      const result = rspackIndex.moduleExists("some-module")
+      expect(typeof result).toBe("boolean")
+    })
+
+    test("canProcess invokes callback when module resolves", () => {
+      const callback = jest.fn((modulePath) => ({
+        processed: true,
+        path: modulePath
+      }))
+      const result = rspackIndex.canProcess("path", callback)
+
+      expect(callback).toHaveBeenCalledWith(expect.any(String))
+      expect(result).toHaveProperty("processed", true)
+      expect(result).toHaveProperty("path")
+    })
+
+    test("canProcess returns null and does not invoke callback when module is missing", () => {
+      const callback = jest.fn()
+      const result = rspackIndex.canProcess(
+        "__definitely_not_a_real_package_name__",
+        callback
+      )
+
+      expect(result).toBeNull()
+      expect(callback).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("environment integration", () => {
+    test("uses correct environment config based on NODE_ENV", () => {
+      const config = rspackIndex.generateRspackConfig()
+      const { nodeEnv } = rspackIndex.env
+
+      const expectedMode =
+        nodeEnv === "production" ? "production" : "development"
+      expect(config.mode).toBe(expectedMode)
+    })
+  })
+})

data/test/package/rspack/optimization.test.js

@@ -0,0 +1,86 @@
+/* eslint-disable func-names */
+
+// Mock requireOrError to prevent actual module loading
+jest.mock("../../../package/utils/requireOrError", () => ({
+  requireOrError: (moduleName) => {
+    if (moduleName === "@rspack/core") {
+      return {
+        SwcJsMinimizerRspackPlugin: jest.fn(function () {
+          this.name = "SwcJsMinimizerRspackPlugin"
+        }),
+        LightningCssMinimizerRspackPlugin: jest.fn(function () {
+          this.name = "LightningCssMinimizerRspackPlugin"
+        })
+      }
+    }
+    throw new Error(`Module ${moduleName} not found`)
+  }
+}))
+
+// Mock debug logger
+jest.mock("../../../package/utils/debug", () => ({
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn()
+}))
+
+describe("rspack/optimization", () => {
+  let getOptimization
+
+  beforeEach(() => {
+    jest.resetModules()
+    const optimizationModule = require("../../../package/optimization/rspack")
+    getOptimization = optimizationModule.getOptimization
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("getOptimization", () => {
+    test("returns an optimization config object", () => {
+      const optimization = getOptimization()
+
+      expect(optimization).toBeDefined()
+      expect(optimization).toHaveProperty("minimize")
+      expect(optimization).toHaveProperty("minimizer")
+    })
+
+    test("sets minimize to true", () => {
+      const optimization = getOptimization()
+
+      expect(optimization.minimize).toBe(true)
+    })
+
+    test("includes SwcJsMinimizerRspackPlugin", () => {
+      const optimization = getOptimization()
+
+      expect(Array.isArray(optimization.minimizer)).toBe(true)
+      const jsMinimizer = optimization.minimizer.find(
+        (m) => m.name === "SwcJsMinimizerRspackPlugin"
+      )
+      expect(jsMinimizer).toBeDefined()
+    })
+
+    test("includes LightningCssMinimizerRspackPlugin", () => {
+      const optimization = getOptimization()
+
+      expect(Array.isArray(optimization.minimizer)).toBe(true)
+      const cssMinimizer = optimization.minimizer.find(
+        (m) => m.name === "LightningCssMinimizerRspackPlugin"
+      )
+      expect(cssMinimizer).toBeDefined()
+    })
+
+    test("includes both minimizers in correct order", () => {
+      const optimization = getOptimization()
+
+      expect(optimization.minimizer).toHaveLength(2)
+      expect(optimization.minimizer[0].name).toBe("SwcJsMinimizerRspackPlugin")
+      expect(optimization.minimizer[1].name).toBe(
+        "LightningCssMinimizerRspackPlugin"
+      )
+    })
+  })
+})

data/test/package/rspack/plugins.test.js

@@ -0,0 +1,185 @@
+/* eslint-disable func-names, jest/prefer-strict-equal */
+
+// Mock helpers before requiring the plugins module
+jest.mock("../../../package/utils/helpers", () => {
+  const original = jest.requireActual("../../../package/utils/helpers")
+  return {
+    ...original,
+    moduleExists: jest.fn(() => true)
+  }
+})
+
+// Mock requireOrError to prevent actual module loading
+jest.mock("../../../package/utils/requireOrError", () => ({
+  requireOrError: (moduleName) => {
+    if (moduleName === "rspack-manifest-plugin") {
+      return {
+        RspackManifestPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "RspackManifestPlugin"
+        })
+      }
+    }
+    if (moduleName === "@rspack/core") {
+      return {
+        EnvironmentPlugin: jest.fn(function (env) {
+          this.env = env
+          this.name = "EnvironmentPlugin"
+        }),
+        CssExtractRspackPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "CssExtractRspackPlugin"
+        }),
+        SubresourceIntegrityPlugin: jest.fn(function (options) {
+          this.options = options
+          this.name = "SubresourceIntegrityPlugin"
+        })
+      }
+    }
+    throw new Error(`Module ${moduleName} not found`)
+  }
+}))
+
+describe("rspack/plugins", () => {
+  let getPlugins
+  let moduleExists
+  let config
+
+  beforeEach(() => {
+    jest.resetModules()
+    config = require("../../../package/config")
+    moduleExists = require("../../../package/utils/helpers").moduleExists
+    const pluginsModule = require("../../../package/plugins/rspack")
+    getPlugins = pluginsModule.getPlugins
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe("getPlugins", () => {
+    test("returns an array", () => {
+      const plugins = getPlugins()
+      expect(Array.isArray(plugins)).toBe(true)
+    })
+
+    test("includes EnvironmentPlugin with filtered env", () => {
+      const plugins = getPlugins()
+      const envPlugin = plugins.find((p) => p.name === "EnvironmentPlugin")
+      expect(envPlugin).toBeDefined()
+      // EnvironmentPlugin receives getFilteredEnv() - a security-filtered version of process.env
+      // that only includes allowlisted environment variables
+      expect(envPlugin.env).toBeDefined()
+      expect(typeof envPlugin.env).toBe("object")
+    })
+
+    test("includes RspackManifestPlugin", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      expect(manifestPlugin).toBeDefined()
+      expect(manifestPlugin.options).toBeDefined()
+      expect(manifestPlugin.options.writeToFileEmit).toBe(true)
+    })
+
+    test("rspackManifestPlugin has generate function", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      expect(manifestPlugin.options.generate).toBeInstanceOf(Function)
+    })
+
+    test("rspackManifestPlugin generate creates proper manifest structure", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      const { publicPath } = manifestPlugin.options
+
+      const files = [
+        { name: "app.js", path: `${publicPath}app-123.js` },
+        { name: "app.css", path: `${publicPath}app-456.css` }
+      ]
+
+      const entrypoints = {
+        app: ["app-123.js", "app-456.css"]
+      }
+
+      const manifest = manifestPlugin.options.generate(null, files, entrypoints)
+
+      expect(manifest["app.js"]).toBe(`${publicPath}app-123.js`)
+      expect(manifest["app.css"]).toBe(`${publicPath}app-456.css`)
+      expect(manifest).toHaveProperty("entrypoints")
+      expect(manifest.entrypoints).toHaveProperty("app")
+      expect(manifest.entrypoints.app).toHaveProperty("assets")
+    })
+
+    test("rspackManifestPlugin filters hot-update files", () => {
+      const plugins = getPlugins()
+      const manifestPlugin = plugins.find(
+        (p) => p.name === "RspackManifestPlugin"
+      )
+      const { publicPath } = manifestPlugin.options
+
+      const files = []
+      const entrypoints = {
+        app: [
+          "app-123.js",
+          "app.hot-update.js",
+          "app-456.css",
+          "app.hot-update.css"
+        ]
+      }
+
+      const manifest = manifestPlugin.options.generate(null, files, entrypoints)
+
+      expect(manifest.entrypoints.app.assets.js).toEqual([
+        `${publicPath}app-123.js`
+      ])
+      expect(manifest.entrypoints.app.assets.css).toEqual([
+        `${publicPath}app-456.css`
+      ])
+    })
+
+    test("includes CssExtractRspackPlugin when css-loader exists", () => {
+      moduleExists.mockReturnValue(true)
+
+      const plugins = getPlugins()
+      const cssPlugin = plugins.find((p) => p.name === "CssExtractRspackPlugin")
+      expect(cssPlugin).toBeDefined()
+      expect(cssPlugin.options.filename).toMatch(/^css\//)
+      expect(cssPlugin.options.emit).toBe(true)
+    })
+
+    test("does not include CssExtractRspackPlugin when css-loader is missing", () => {
+      moduleExists.mockReturnValue(false)
+
+      const plugins = getPlugins()
+      const cssPlugin = plugins.find((p) => p.name === "CssExtractRspackPlugin")
+      expect(cssPlugin).toBeUndefined()
+    })
+
+    test("includes SubresourceIntegrityPlugin when integrity is enabled", () => {
+      const originalIntegrity = config.integrity
+      config.integrity = {
+        ...originalIntegrity,
+        enabled: true,
+        hash_functions: ["sha256"]
+      }
+
+      try {
+        const plugins = getPlugins()
+        const sriPlugin = plugins.find(
+          (p) => p.name === "SubresourceIntegrityPlugin"
+        )
+
+        expect(sriPlugin).toBeDefined()
+        expect(sriPlugin.options.hashFuncNames).toEqual(["sha256"])
+      } finally {
+        config.integrity = originalIntegrity
+      }
+    })
+  })
+})

data/test/package/rspack/rules.test.js

@@ -0,0 +1,229 @@
+/* eslint-disable jest/no-conditional-in-test */
+
+// Mock helpers and debug utilities
+jest.mock("../../../package/utils/helpers", () => {
+  const original = jest.requireActual("../../../package/utils/helpers")
+  return {
+    ...original,
+    moduleExists: jest.fn(() => true),
+    canProcess: jest.fn((_rule, callback) => callback("/mocked-loader"))
+  }
+})
+
+jest.mock("../../../package/utils/debug", () => ({
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn()
+}))
+
+describe("rspack/rules", () => {
+  let rules
+
+  beforeAll(() => {
+    rules = require("../../../package/rules/rspack")
+  })
+
+  describe("rules array", () => {
+    test("exports an array", () => {
+      expect(Array.isArray(rules)).toBe(true)
+    })
+
+    test("contains multiple rules", () => {
+      expect(rules.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe("javaScript rule", () => {
+    test("includes rule for JS/JSX files", () => {
+      const jsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule).toBeDefined()
+    })
+
+    test("uses builtin:swc-loader for JavaScript", () => {
+      const jsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule.use).toBeDefined()
+      expect(Array.isArray(jsRule.use)).toBe(true)
+      expect(jsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("excludes node_modules for JavaScript", () => {
+      const jsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule.exclude).toBeDefined()
+      expect(jsRule.exclude.toString()).toContain("node_modules")
+    })
+
+    test("sets type to javascript/auto for JavaScript", () => {
+      const jsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule.type).toBe("javascript/auto")
+    })
+
+    test("configures SWC with JSX runtime automatic", () => {
+      const jsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("js|jsx|mjs")
+      )
+
+      expect(jsRule.use[0].options).toBeDefined()
+      expect(jsRule.use[0].options.jsc.parser.syntax).toBe("ecmascript")
+      expect(jsRule.use[0].options.jsc.parser.jsx).toBe(true)
+      expect(jsRule.use[0].options.jsc.transform.react.runtime).toBe(
+        "automatic"
+      )
+    })
+  })
+
+  describe("typeScript rule", () => {
+    test("includes rule for TS/TSX files", () => {
+      const tsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule).toBeDefined()
+    })
+
+    test("uses builtin:swc-loader for TypeScript", () => {
+      const tsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule.use).toBeDefined()
+      expect(Array.isArray(tsRule.use)).toBe(true)
+      expect(tsRule.use[0].loader).toBe("builtin:swc-loader")
+    })
+
+    test("excludes node_modules for TypeScript", () => {
+      const tsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule.exclude).toBeDefined()
+      expect(tsRule.exclude.toString()).toContain("node_modules")
+    })
+
+    test("sets type to javascript/auto for TypeScript", () => {
+      const tsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule.type).toBe("javascript/auto")
+    })
+
+    test("configures SWC with TypeScript parser", () => {
+      const tsRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("ts|tsx")
+      )
+
+      expect(tsRule.use[0].options).toBeDefined()
+      expect(tsRule.use[0].options.jsc.parser.syntax).toBe("typescript")
+      expect(tsRule.use[0].options.jsc.parser.tsx).toBe(true)
+      expect(tsRule.use[0].options.jsc.transform.react.runtime).toBe(
+        "automatic"
+      )
+    })
+  })
+
+  describe("css rules", () => {
+    test("includes CSS rule when css-loader is available", () => {
+      const cssRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("css")
+      )
+
+      // CSS rule should be present since moduleExists is mocked to return true
+      expect(cssRule).toBeDefined()
+    })
+  })
+
+  describe("sass rules", () => {
+    test("includes Sass rule when dependencies are available", () => {
+      const sassRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("scss|sass")
+      )
+
+      // Sass rule should be present since moduleExists is mocked to return true
+      expect(sassRule).toBeDefined()
+    })
+  })
+
+  describe("less rules", () => {
+    test("includes Less rule when less-loader is available", () => {
+      const lessRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("less")
+      )
+
+      expect(lessRule).toBeDefined()
+      expect(lessRule.test.toString()).toContain("less")
+    })
+  })
+
+  describe("stylus rules", () => {
+    test("includes Stylus rule when stylus-loader is available", () => {
+      const stylusRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("styl")
+      )
+
+      expect(stylusRule).toBeDefined()
+      expect(stylusRule.test.toString()).toContain("styl")
+    })
+  })
+
+  describe("erb rule", () => {
+    test("includes ERB rule", () => {
+      const erbRule = rules.find(
+        (rule) => rule.test && rule.test.toString().includes("erb")
+      )
+
+      expect(erbRule).toBeDefined()
+    })
+  })
+
+  describe("file/asset rule", () => {
+    test("includes file/asset handling rule", () => {
+      const fileRule = rules.find(
+        (rule) =>
+          rule.test &&
+          (rule.test.toString().includes("png") ||
+            rule.test.toString().includes("jpg") ||
+            rule.test.toString().includes("svg"))
+      )
+
+      expect(fileRule).toBeDefined()
+    })
+  })
+
+  describe("raw file rule", () => {
+    test("includes raw file loading rule", () => {
+      // Raw rule may be a direct rule or nested in oneOf
+      const rawRule =
+        rules.find(
+          (rule) =>
+            rule.type === "asset/source" &&
+            rule.resourceQuery &&
+            rule.resourceQuery.toString().includes("raw")
+        ) ||
+        rules
+          .filter((rule) => rule.oneOf)
+          .flatMap((rule) => rule.oneOf)
+          .find(
+            (subRule) =>
+              subRule.type === "asset/source" &&
+              subRule.resourceQuery &&
+              subRule.resourceQuery.toString().includes("raw")
+          )
+
+      expect(rawRule).toBeDefined()
+      expect(rawRule.type).toBe("asset/source")
+    })
+  })
+})

data/test/resolver.js

@@ -1,13 +1,44 @@
+const { resolve } = require("path")
+
 const mapping = {
   "css-loader": "this path was mocked",
   "sass-loader/package.json": "../../__mocks__/sass-loader/package.json",
   "nonexistent/package.json": "../../__mocks__/nonexistent/package.json"
 }
 
+const repoRoot = resolve(__dirname, "..")
+// Keep this map explicit to avoid accidentally rewriting third-party imports.
+// If a new local rspack TS module is required via its compiled .js path in tests,
+// add the corresponding mapping here.
+const rspackModuleAliasMap = {
+  [resolve(repoRoot, "package/plugins/rspack.js")]: resolve(
+    repoRoot,
+    "package/plugins/rspack.ts"
+  ),
+  [resolve(repoRoot, "package/rules/rspack.js")]: resolve(
+    repoRoot,
+    "package/rules/rspack.ts"
+  ),
+  [resolve(repoRoot, "package/optimization/rspack.js")]: resolve(
+    repoRoot,
+    "package/optimization/rspack.ts"
+  )
+}
+
 function resolver(module, options) {
-  // If the path corresponds to a key in the mapping object, returns the fakely resolved path
-  // otherwise it calls the Jest's default resolver
-  return mapping[module] || options.defaultResolver(module, options)
+  if (mapping[module]) {
+    return mapping[module]
+  }
+
+  // Remap only this repository's known rspack JS targets to TS sources.
+  if (options.basedir) {
+    const requestedPath = resolve(options.basedir, module)
+    if (rspackModuleAliasMap[requestedPath]) {
+      return rspackModuleAliasMap[requestedPath]
+    }
+  }
+
+  return options.defaultResolver(module, options)
 }
 
 module.exports = resolver

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shakapacker
 version: !ruby/object:Gem::Version
-  version: 9.6.0.rc.0
+  version: 9.6.0.rc.1
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -390,6 +390,10 @@ files:
 - test/package/index.test.js
 - test/package/plugins/envFiltering.test.js
 - test/package/production.test.js
+- test/package/rspack/index.test.js
+- test/package/rspack/optimization.test.js
+- test/package/rspack/plugins.test.js
+- test/package/rspack/rules.test.js
 - test/package/rules/babel.test.js
 - test/package/rules/esbuild.test.js
 - test/package/rules/file.test.js
@@ -422,7 +426,7 @@ homepage: https://github.com/shakacode/shakapacker
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/shakacode/shakapacker/tree/v9.6.0-rc.0
+  source_code_uri: https://github.com/shakacode/shakapacker/tree/v9.6.0-rc.1
 rdoc_options: []
 require_paths:
 - lib
@@ -461,6 +465,10 @@ test_files:
 - test/package/index.test.js
 - test/package/plugins/envFiltering.test.js
 - test/package/production.test.js
+- test/package/rspack/index.test.js
+- test/package/rspack/optimization.test.js
+- test/package/rspack/plugins.test.js
+- test/package/rspack/rules.test.js
 - test/package/rules/babel.test.js
 - test/package/rules/esbuild.test.js
 - test/package/rules/file.test.js