Summary

This PR implements the beforeModuleIds hook for rspack, providing webpack API compatibility for plugins that need to assign custom module IDs before rspack's built-in module ID assignment strategy runs.

This hook is called during the module IDs phase, after modules are collected but before any ID assignment occurs. Plugins can use it to assign custom IDs to specific modules (e.g., for stable chunk hashing, debugging, or custom naming schemes).

Note: This PR was created with assistance using Claude Code

Motivation

Webpack provides compilation.hooks.beforeModuleIds which allows plugins to intercept the module ID assignment process. Some webpack plugins rely on this hook to:

• Assign deterministic/stable module IDs for long-term caching
• Provide human-readable module IDs for debugging
• Implement custom module ID schemes for specific use cases

Without this hook, these plugins cannot be ported to rspack.

Related links

Closes: #10764

Implementation

Key Design Decisions

Proxy-based Module Exposure: To provide full webpack API compatibility, the JS implementation uses a Proxy pattern:

1. Rust collects all module identifiers needing IDs and sends them to JS in a single call
2. JS looks up the real Module objects from compilation.modules by identifier
3. Each module is wrapped in a Proxy that:
   • Exposes all real module properties (libIdent(), userRequest, type, rootModule, etc.)
   • Intercepts id setter to track assignments in a Map
4. Plugins iterate and can access full module API while setting module.id = "custom-id"
5. All assignments are returned to Rust in a single response
6. Rust applies all ID assignments to the artifact

This approach ensures:

• Only one round-trip across the Rust/JS boundary regardless of how many modules are processed
• Full access to module properties needed for sophisticated ID generation (e.g., libIdent() for context-relative paths, userRequest for the original import path, rootModule for concatenated modules)

Artifact Passing: The moduleIds plugins (deterministic, natural) need to see IDs assigned by beforeModuleIds. This required adding a new helper function get_used_module_ids_and_modules_with_artifact that accepts the artifact as a parameter, since the artifact is temporarily moved out of compilation during hook invocation.

Test

Added tests/rspack-test/configCases/hooks/before-module-ids/ with:

• rspack.config.js - Plugin that assigns custom ID to index.js module
• index.js - Test entry point
• a.js - Helper module

The test verifies:

1. The hook is called with modules
2. Custom IDs can be assigned via module.id = "..."
3. The custom ID appears in the final build stats
4. Real module properties are accessible (libIdent(), userRequest, type)

Usage

compiler.hooks.compilation.tap("MyPlugin", compilation => {
  compilation.hooks.beforeModuleIds.tap("MyPlugin", modules => {
    for (const module of modules) {
      if (module.identifier.includes("my-special-module")) {
        module.id = "my-custom-id";
      }
    }
  });
});

API

Hook Signature

beforeModuleIds: SyncHook<[Iterable<Module>]>

Module Object

Each module in the iterable is a proxied Module object with full access to:

Core Properties:

• identifier - The module's unique identifier (string)
• id - The module's ID (read/write, set this to assign a custom ID)
• type - The module type (e.g., "javascript/auto")
• context - The module's context directory
• layer - The module's layer (if any)

Methods:

• libIdent(options: { context: string }) - Returns a context-relative identifier suitable for stable IDs

NormalModule Properties:

• userRequest - The user's original request string
• rawRequest - The raw request before resolution
• resource - The resolved resource path
• resourceResolveData - Full resolution data
• loaders - Array of loaders applied to this module
• matchResource - The match resource (if using !=! syntax)

ConcatenatedModule Properties:

• rootModule - The root module of the concatenated module
• modules - Array of all modules in the concatenation

Testing

All existing tests pass (563 tests in Config.part2.test.js which includes hooks tests).

✓ config > configCases-configCases/hooks/before-module-ids > should pass

Checklist

• Hook definition follows existing patterns (define_hook! macro)
• Hook is registered in CompilationHooks struct
• JS bindings use NAPI object pattern
• TypeScript types are properly defined
• Test case added with property access verification
• cargo fmt applied
• Biome linting passes