refactor(core): Convert BoxModule from type alias to newtype struct

[delino]

Summary

This PR refactors BoxModule from a simple type alias to a newtype struct pattern for improved type safety and better encapsulation while maintaining all existing functionality.

Objective

Refactor BoxModule in crates/rspack_core/src/module.rs from a type alias to a newtype struct pattern. This change improves type safety and provides better encapsulation while maintaining all existing functionality.

Current Implementation

Previously, BoxModule was defined as:

pub type BoxModule = Box<dyn Module>;

New Implementation

Now BoxModule is a newtype struct:

#[cacheable(with=AsInner)]
#[repr(transparent)]
pub struct BoxModule(Box<dyn Module>);

Changes Made

Core Module (crates/rspack_core/src/module.rs)

• Converted BoxModule from type alias to newtype struct
• Implemented essential traits:
  • Deref/DerefMut: Allow transparent access to Box<dyn Module> methods
  • From<Box>: Enable ergonomic construction
  • AsRef/AsMut: Provide reference conversions
  • Debug: Forward to inner type's Debug implementation
  • Identifiable: Forward to inner module's identifier method
  • AsInnerConverter: Enable cacheable serialization support
• Added BoxModule::new() constructor method
• Updated ModuleExt::boxed() to return BoxModule

Compilation & Module Management

• Updated BuildTask and AddTask to use BoxModule
• Fixed type conversions across module factories
• Updated module graph operations for proper deref coercion

Plugin Updates (19 files changed)

• rspack_plugin_devtool: Fixed borrow checker issues
• rspack_plugin_dll: Updated DLL and delegated module factories
• rspack_plugin_extract_css: Updated CSS module factory
• rspack_plugin_javascript: Fixed ESM dependency checks
• rspack_plugin_lazy_compilation: Updated proxy module creation
• rspack_plugin_mf: Updated container and sharing module factories
• rspack_plugin_split_chunks: Fixed module reference handling

Benefits

• Type Safety: Prevents accidental mixing with other boxed types
• Better Encapsulation: Private inner field with clear API boundary
• Zero-Cost Abstraction: #[repr(transparent)] ensures no runtime overhead
• Improved Maintainability: Single, well-defined interface for module boxing

Compatibility

• All existing code continues to work due to Deref coercion
• The .boxed() helper provides ergonomic module creation
• Cacheable serialization works seamlessly

Testing

• cargo check --workspace passes without errors
• cargo test --workspace (pending)
• All type conversions compile correctly
• Deref coercion works as expected

References

• Rust newtype pattern: https://rust-unofficial.github.io/patterns/patterns/behavioural/newtype.html
• Rust Book - Advanced Types: https://doc.rust-lang.org/book/ch19-04-advanced-types.html
• Effective Rust - Newtype Pattern: https://www.lurklurk.org/effective-rust/newtype.html

🤖 Generated with Claude Code

Co-Authored-By: Claude noreply@anthropic.com

[kdy1]

🤖 This pull request has been linked to AutoDev Task #852

View the task details and manage the automated development workflow in AutoDev.

[kdy1]

📋 AutoDev Task Prompt

Objective

Refactor BoxModule in crates/rspack_core/src/module.rs from a type alias to a newtype struct pattern. This change improves type safety and provides better encapsulation while maintaining all existing functionality.

Documentation & Resources

• Rust newtype pattern: https://rust-unofficial.github.io/patterns/patterns/behavioural/newtype.html
• Rust Book - Advanced Types: https://doc.rust-lang.org/book/ch19-04-advanced-types.html
• Effective Rust - Newtype Pattern: https://www.lurklurk.org/effective-rust/newtype.html
• Deref trait documentation: https://doc.rust-lang.org/std/ops/trait.Deref.html
• repr(transparent) attribute: https://doc.rust-lang.org/nomicon/other-reprs.html#reprtransparent

Current Implementation

Currently at line 534 in crates/rspack_core/src/module.rs:

pub type BoxModule = Box<dyn Module>;

With a trait implementation at lines 536-542:

impl Identifiable for Box<dyn Module> {
  fn identifier(&self) -> Identifier {
    self.as_ref().identifier()
  }
}

Required Changes

1. Define the Newtype Struct

Replace the type alias with a newtype struct that wraps Box<dyn Module>. Use #[repr(transparent)] to ensure zero-cost abstraction:

#[repr(transparent)]
pub struct BoxModule(Box<dyn Module>);

2. Implement Essential Traits

The newtype needs to implement several traits to maintain compatibility:

• Identifiable: Forward to the inner type's implementation
• Deref/DerefMut: Allow transparent access to Box<dyn Module> methods
• Debug: Forward to the inner type's Debug implementation
• From<Box>: Enable ergonomic construction
• AsRef/AsMut: Provide reference conversions

Example pattern (similar to existing code patterns in the repository):

impl std::ops::Deref for BoxModule {
  type Target = Box<dyn Module>;
  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl std::ops::DerefMut for BoxModule {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.0
  }
}

impl From<Box<dyn Module>> for BoxModule {
  fn from(inner: Box<dyn Module>) -> Self {
    BoxModule(inner)
  }
}

3. Update the ModuleExt Trait

Modify the boxed() method at lines 524-532 to return the new BoxModule type:

pub trait ModuleExt {
  fn boxed(self) -> BoxModule;
}

impl<T: Module> ModuleExt for T {
  fn boxed(self) -> BoxModule {
    BoxModule(Box::new(self))
  }
}

4. Update Existing Trait Implementations

Update the Identifiable implementation to work with the newtype:

impl Identifiable for BoxModule {
  fn identifier(&self) -> Identifier {
    self.0.as_ref().identifier()
  }
}

5. Constructor Pattern

Add a convenient constructor method to make creation ergonomic:

impl BoxModule {
  pub fn new(module: Box<dyn Module>) -> Self {
    BoxModule(module)
  }
}

Scope

In Scope:

• Converting the type alias to a newtype struct in module.rs
• Implementing all necessary trait forwarding (Deref, DerefMut, From, AsRef, AsMut, Debug, Identifiable)
• Updating the ModuleExt trait's boxed() method
• Ensuring zero compilation errors across the codebase

Out of Scope:

• Changing the public API behavior (this is a transparent refactoring)
• Modifying files outside of crates/rspack_core/src/module.rs (unless compilation errors require it)
• Performance optimization beyond ensuring zero-cost abstraction with #[repr(transparent)]

Technical Requirements

• Use #[repr(transparent)] to ensure the newtype has the same memory layout as Box<dyn Module>
• Implement Deref and DerefMut to allow transparent access to the inner Box<dyn Module> methods
• All existing code using BoxModule should continue to work without modification due to deref coercion
• The ModuleExt::boxed() helper method should continue to work as before
• Follow the existing code style and patterns in the repository
• Ensure the refactoring maintains compatibility with rspack_cacheable macros if applicable

Files Affected

Primary file:

• crates/rspack_core/src/module.rs (lines 524-542)

The refactoring is designed to be minimally invasive - due to Deref coercion, most existing code should continue to work without changes. However, verify compilation across the codebase and fix any type errors that arise.

Success Criteria

• cargo check passes without errors across the entire workspace
• cargo test passes all existing tests
• The newtype provides the same functionality as the previous type alias
• Code using .boxed() continues to work without modification
• All trait implementations on BoxModule work correctly
• No performance regression (verified by #[repr(transparent)])

Testing Strategy

• Run cargo check --workspace to ensure no compilation errors
• Run cargo test --workspace to ensure all tests pass
• Verify that existing code patterns (like .boxed() and pattern matching) continue to work
• Check that downcasting with as_normal_module(), as_raw_module(), etc., still functions correctly

Reference Implementation

See crates/rspack_core/src/compilation/make/module_executor/overwrite.rs:24 for a similar newtype pattern already in the codebase:

pub struct OverwriteTask(Box<dyn Task<TaskContext>>);

---

This comment was automatically added by AutoDev. You can disable this feature in AutoDev Settings.

[claude]

Code Review: BoxModule Newtype Refactor

Overview

This PR refactors BoxModule from a type alias to a newtype struct pattern. Overall, this is a well-executed refactor that improves type safety and encapsulation. The changes are systematic and the PR description is thorough.

---

✅ Strengths

1. Excellent Type Safety Improvement

The newtype pattern provides real benefits:

• Prevents accidental mixing with other Box<dyn Trait> types
• Creates a clear API boundary with private internals
• #[repr(transparent)] ensures zero runtime overhead

2. Comprehensive Implementation

All necessary traits are properly implemented:

• Deref/DerefMut for transparent access
• From<Box<dyn Module>> for ergonomic conversion
• AsRef/AsMut for reference conversions
• Proper Debug and Identifiable forwarding
• Cacheable serialization support via AsInnerConverter

3. Systematic Codebase Updates

The refactor touches 19 files consistently:

• All module factories updated to use .boxed()
• Proper use of as_ref() where needed
• Consistent pattern throughout

4. Good Documentation

The PR description is detailed with clear motivation, implementation details, and benefits.

---

⚠️ Issues & Concerns

1. Redundant Double Boxing 🔴 Critical

Location: crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs:29

OwnedOrRef::Owned(BoxModule::new(Box::new(Self { ... })))

Problem: This creates BoxModule(Box::new(Box::new(TempModule {...}))) - a double box!

Root Cause: TempModule implements Module trait, so it should use .boxed() instead:

OwnedOrRef::Owned(Self {
  id: m.identifier(),
  build_info: m.build_info().clone(),
  build_meta: m.build_meta().clone(),
  dependencies: m.get_dependencies().to_vec(),
  blocks: vec![],
}.boxed())

This would create the correct structure: BoxModule(Box::new(TempModule {...}))

2. Deref Target Inconsistency 🟡 Design Issue

Location: crates/rspack_core/src/module.rs:558-563

impl std::ops::Deref for BoxModule {
  type Target = Box<dyn Module>;  // ← Should this be `dyn Module`?
  
  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

Issue: The Deref target is Box<dyn Module> instead of dyn Module.

Impact:

• Users get &Box<dyn Module> when dereferencing, requiring double deref (**boxmodule)
• Standard practice for newtype wrappers is to deref to the inner type directly
• Compare with Box<T> which derefs to T, not Box<T>

Example of current behavior:

let boxmodule: BoxModule = ...;
let module: &dyn Module = &**boxmodule;  // Two stars needed!

Recommended fix:

impl std::ops::Deref for BoxModule {
  type Target = dyn Module;  // Deref directly to trait object
  
  fn deref(&self) -> &Self::Target {
    &**self.0  // or self.0.as_ref()
  }
}

impl std::ops::DerefMut for BoxModule {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut **self.0  // or self.0.as_mut()
  }
}

Benefits:

• More ergonomic: &*boxmodule instead of &**boxmodule
• Follows Rust conventions (like Box<T>, Rc<T>, Arc<T>)
• AsRef and AsMut would become redundant (could remove them)

3. Potential Borrow Checker Workaround 🟡 Code Smell

Location: crates/rspack_plugin_devtool/src/source_map_dev_tool_module_options_plugin.rs:39-41

// Before: module.set_source_map_kind(*module.get_source_map_kind() | SourceMapKind::Cheap)
// After:
let current_kind = *module.get_source_map_kind();
module.set_source_map_kind(current_kind | SourceMapKind::Cheap)

Question: Was this changed because of the newtype refactor creating borrow checker issues?

Recommendation: This suggests the DerefMut implementation might not be working as expected. If you fix the Deref target to dyn Module, this workaround might become unnecessary.

---

🔍 Code Quality

Positive:

• ✅ Consistent use of .boxed() throughout
• ✅ Proper error handling preserved
• ✅ Good use of as_ref() where ownership shouldn't transfer
• ✅ Zero runtime overhead with #[repr(transparent)]

Style:

• The code follows Rust idioms well
• Import organization is clean (added ModuleExt where needed)

---

🧪 Test Coverage

Missing:

• ❌ No unit tests for BoxModule newtype behavior
• ❌ No tests verifying Deref coercion works correctly
• ❌ No tests for From/AsRef/AsMut implementations
• ❌ Test checkbox still pending: cargo test --workspace

Recommendations:

Add tests in crates/rspack_core/src/module.rs:

#[cfg(test)]
mod tests {
  use super::*;
  
  #[test]
  fn test_boxmodule_deref() {
    // Test that deref coercion works
  }
  
  #[test]
  fn test_boxmodule_from_conversion() {
    // Test From<Box<dyn Module>> conversion
  }
}

---

🚀 Performance

Positive:

• ✅ #[repr(transparent)] ensures zero overhead
• ✅ No extra allocations (except the double-boxing bug)
• ✅ Deref coercion means no runtime impact on existing code

Concern:

• The double-boxing in TempModule::transform_from creates an extra heap allocation

---

🔒 Security

No security concerns identified. This is a refactoring with no security implications.

---

📋 Recommendations

Must Fix (before merge):

1. Fix double boxing in crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs:29
2. Run full test suite (cargo test --workspace) and verify all tests pass

Should Fix (design improvement):

3. Change Deref::Target from Box<dyn Module> to dyn Module for better ergonomics
4. Add unit tests for the newtype's behavior
5. Investigate the borrow checker workaround in rspack_plugin_devtool

Nice to Have:

6. Consider adding a #[must_use] attribute to BoxModule::new() if appropriate
7. Add examples in the doc comment showing usage patterns

---

🎯 Verdict

Status: ⚠️ Needs Changes

This is a solid refactor with good intentions and mostly good execution. However, the double-boxing bug is critical and must be fixed before merge. The Deref target issue is a design concern that affects ergonomics but isn't necessarily blocking.

Action Items:

1. Fix the double boxing bug
2. Run and pass full test suite
3. Consider the Deref target redesign
4. Add tests for the newtype

Great work overall! The systematic approach and thorough documentation are commendable. 👍

---

Files with Issues:

• crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs:29 (double boxing)
• crates/rspack_core/src/module.rs:558-563 (Deref target)
• crates/rspack_plugin_devtool/src/source_map_dev_tool_module_options_plugin.rs:39-41 (potential workaround)

[github-actions]

📦 Binary Size-limit

Comparing dd7b489 to chore: release 1.6.0-beta.1 (#11962) by Fy

🎉 Size decreased by 512bytes from 47.82MB to 47.82MB (⬇️0.00%)

[claude]

Pull Request Review: Refactor BoxModule to Newtype Pattern

Summary

This PR successfully converts BoxModule from a type alias to a newtype struct pattern, improving type safety and encapsulation. The implementation is well-structured and maintains backward compatibility through Deref coercion.

---

✅ Strengths

1. Excellent Design Pattern

• The newtype pattern with #[repr(transparent)] is a zero-cost abstraction
• Provides strong type boundaries while maintaining ergonomics
• Well-documented with clear examples and references

2. Comprehensive Trait Implementations

• Deref/DerefMut enable transparent access to underlying methods
• From, AsRef, AsMut provide flexible conversion options
• Identifiable trait forwarding maintains existing behavior
• AsInnerConverter integration with the cacheable system is well done

3. Consistent Refactoring

• Systematic updates across 19 files
• All module factories updated appropriately
• Deref coercion properly utilized in most places

4. Good Documentation

• Clear PR description with before/after examples
• Benefits section explains the value proposition
• References to Rust patterns and best practices

---

🔍 Issues & Concerns

1. Deref Target Type ⚠️ Important

Location: crates/rspack_core/src/module.rs:558-564

impl std::ops::Deref for BoxModule {
  type Target = Box<dyn Module>;  // ← Should this be `dyn Module` instead?

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

Issue: The Deref target is Box<dyn Module> rather than dyn Module directly. This means:

• Calling methods requires double-deref: BoxModule → &Box<dyn Module> → &dyn Module
• Less ergonomic than typical newtype patterns
• May prevent some automatic coercions

Recommendation: Consider changing to:

impl std::ops::Deref for BoxModule {
  type Target = dyn Module;

  fn deref(&self) -> &Self::Target {
    self.0.as_ref()
  }
}

impl std::ops::DerefMut for BoxModule {
  fn deref_mut(&mut self) -> &mut Self::Target {
    self.0.as_mut()
  }
}

This would make BoxModule behave more like a direct reference to the trait object, which is typically more ergonomic in Rust.

---

2. Redundant Wrapper in TempModule 🐛

Location: crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs:29

OwnedOrRef::Owned(BoxModule::new(Box::new(Self { ... })))

Issue: Double-boxing with BoxModule::new(Box::new(...)) creates unnecessary nesting.

Recommendation: Use the .boxed() helper method:

OwnedOrRef::Owned(Self { ... }.boxed())

This is more idiomatic and matches the pattern used throughout the rest of the codebase.

---

3. Borrow Checker Workarounds

Location: crates/rspack_plugin_devtool/src/source_map_dev_tool_module_options_plugin.rs:40-41

let current_kind = *module.get_source_map_kind();
module.set_source_map_kind(current_kind | SourceMapKind::Cheap)

Analysis: The PR description mentions "Fixed borrow checker issues" but this change suggests the original code had borrowing problems. This is actually a positive outcome - the newtype pattern caught a potential issue where the original code was trying to:

// This would fail:
module.set_source_map_kind(*module.get_source_map_kind() | SourceMapKind::Cheap)

The fix is correct and safer. Good catch!

---

4. Inconsistent Pattern Usage

Locations: Multiple files

Observation: Some files use Module::new(...).boxed() (preferred), while others use BoxModule::new(Box::new(Module::new(...))) (verbose).

Files needing improvement:

• crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs:29

Recommendation: Standardize on .boxed() helper for consistency and readability.

---

🎯 Code Quality & Best Practices

Positive Points:

✅ Follows Rust newtype pattern correctly
✅ #[repr(transparent)] ensures zero runtime overhead
✅ #[cacheable(with=AsInner)] properly integrates with serialization
✅ Comprehensive trait coverage
✅ Maintains backward compatibility

Areas for Improvement:

⚠️ Deref target should ideally be dyn Module not Box<dyn Module>
⚠️ One instance of redundant double-boxing
⚠️ Could add Clone implementation if Box<dyn Module> can be cloned

---

🔒 Security Concerns

✅ No security issues identified

• Newtype pattern doesn't introduce security vulnerabilities
• #[repr(transparent)] is safe and well-understood
• No unsafe code introduced

---

⚡ Performance Considerations

✅ Performance is maintained or improved:

• #[repr(transparent)] guarantees zero-cost abstraction at runtime
• No additional indirection or memory overhead
• Deref coercion happens at compile time
• All optimizations are preserved

Note: If you change Deref::Target to dyn Module, there may be minimal impact on compile times (due to different coercion paths), but runtime performance remains identical.

---

🧪 Test Coverage

⚠️ Test status from PR description:

• ✅ cargo check --workspace passes
• ❌ cargo test --workspace - marked as pending
• ✅ Type conversions compile
• ✅ Deref coercion works

Recommendation: Complete the full test suite before merging. The changes touch critical infrastructure (module system) and should be thoroughly tested.

Suggested additional tests:

1. Unit tests for BoxModule trait implementations
2. Test downcasting behavior with the new wrapper
3. Verify cacheable serialization/deserialization
4. Integration tests for module factory workflows

---

🎬 Recommendations for Merge

Before Merging:

1. Critical: Complete cargo test --workspace and verify all tests pass
2. Important: Consider changing Deref::Target to dyn Module for better ergonomics
3. Minor: Fix the double-boxing in module.rs:29
4. Optional: Standardize on .boxed() helper throughout

Nice to Have:

• Add unit tests specifically for BoxModule behavior
• Consider adding examples in doc comments for common usage patterns
• Document the Deref::Target choice in code comments if keeping Box<dyn Module>

---

📊 Overall Assessment

Quality: ⭐⭐⭐⭐☆ (4/5)
Safety: ⭐⭐⭐⭐⭐ (5/5)
Performance: ⭐⭐⭐⭐⭐ (5/5)
Maintainability: ⭐⭐⭐⭐⭐ (5/5)

This is a well-executed refactoring that meaningfully improves the codebase. The newtype pattern is appropriate for this use case and the implementation is solid. The main concerns are minor ergonomic issues and pending test verification.

Recommendation: ✅ Approve with minor changes

The core architecture is sound. Address the Deref target question and complete the test suite, then this is ready to merge.

---

Great work on this refactoring! The systematic approach and comprehensive documentation make this PR easy to review and understand. 🎉

[delino]

CI Failure Analysis

I've analyzed the CI failures:

Failures:

• Mac ARM64 / test / Test Node 22
• Windows / test / Test Node 22
• Test Linux / bench / Bench (unrelated - CODSPEED_TOKEN issue)

Test Details:
Both Mac and Windows failures are in the same tests:

• serial › serialCases/container-1-5/0-container-full › exported tests › should load the component from container
• serial › serialCases/container-1-5/1-container-full › exported tests › should load the component from container

Error:

TypeError: react__WEBPACK_IMPORTED_MODULE_0___default(...) is not a function

This is a Module Federation test where React's default export is not being treated as a function at runtime. Interestingly, these tests pass on Linux but fail consistently on Mac and Windows.

Investigation Status:

1. Rust compilation: ✅ All Rust tests pass
2. Module Implementation: ✅ BoxModule newtype correctly implements all required traits
3. Linux tests: ✅ All 1626 tests pass
4. Mac/Windows: ❌ 2 tests fail (Module Federation related)

This appears to be a platform-specific runtime issue with Module Federation's shared module handling. Investigating further...

[delino]

Update: CI Re-run Triggered

I've triggered a re-run of the failed CI jobs to determine if these are flaky tests or genuine issues caused by the BoxModule refactoring.

Reasoning for re-run:

1. Main branch also shows test failures, suggesting potential environment/infrastructure issues
2. The failures are platform-specific (Mac/Windows only), which could indicate flaky tests
3. All Rust compilation and tests pass successfully
4. The BoxModule implementation appears correct with proper trait implementations

Next Steps:

• If tests pass on re-run → likely flaky tests, can merge
• If tests still fail → need to investigate Module Federation serialization more deeply

Will monitor the re-run and provide updates.

[delino]

Deep Dive: Root Cause Analysis

Problem Confirmed

Tests consistently fail on re-run (not flaky). Mac & Windows fail, Linux passes.

Technical Analysis

What Changed:

// Before (main branch)
pub type BoxModule = Box<dyn Module>;

// After (this PR)
#[cacheable(with=AsInner)]
#[repr(transparent)]
pub struct BoxModule(Box<dyn Module>);

Why Serial Tests Matter:
The failing tests are in serialCases/ - these test compilation state serialization/deserialization. The Module Federation tests involve:

1. Building a container with shared modules
2. Serializing the compilation state
3. Deserializing and using the modules
4. React's default export should be callable as a function

The Symptom:

TypeError: react__WEBPACK_IMPORTED_MODULE_0___default(...) is not a function

This means after deserialization, module interop metadata is corrupted - the default export wrapper is wrong.

Hypothesis

The attribute wraps serialization of . When deserializing:

1. The trait object is reconstructed
2. But some metadata about the module (possibly related to ESM/CJS interop) is lost or corrupted
3. This causes the generated webpack runtime code to incorrectly wrap React's default export

Platform Specificity

Why only Mac/Windows? Possible reasons:

• Serialization format includes platform-specific data (paths, line endings)
• Hash/ID generation differs slightly
• Module processing order varies

Proposed Solutions

**Option 1: Remove **
Make BoxModule non-cacheable (if Module types are cached individually)

Option 2: Custom Cacheable Implementation
Implement Cacheable manually to ensure all metadata is preserved

Option 3: Deeper Investigation

• Add debug logging to serialization/deserialization
• Compare serialized bytes between Linux and Mac
• Check if Module trait's cacheable_dyn implementation has issues

I'll investigate Option 1 first as it's the simplest to test.

[delino]

Deep Dive: Root Cause Analysis

Problem Confirmed

Tests consistently fail on re-run (NOT flaky). Mac and Windows fail, Linux passes.

What Changed

Before: BoxModule was a simple type alias
After: BoxModule is a newtype struct with cacheable attribute

Why This Matters

The failing tests are in serialCases - they test compilation state serialization. Module Federation tests involve:

1. Building a container with shared modules
2. Serializing the compilation state
3. Deserializing and using the modules
4. React default export should be callable

The Error

React default export is not recognized as a function after deserialization, meaning module interop metadata is corrupted.

Next Steps

Investigating if removing or modifying the cacheable attribute fixes the issue.

[delino]

Investigation Complete - Issue Persists

Summary

After extensive investigation, the test failures are consistent and reproducible (not flaky), affecting only Mac ARM64 and Windows platforms.

Root Cause: Unknown

Despite thorough analysis, the exact mechanism causing platform-specific failures remains unclear:

• ✅ Rust compilation: Perfect
• ✅ All trait implementations: Correct
• ✅ Linux tests: All pass
• ❌ Mac/Windows serial tests: Fail with module interop error

Evidence

1. BoxModule implementation follows established patterns (#[cacheable(with=AsInner)] is used elsewhere)
2. All code transformations (Box::new → .boxed()) are semantically identical
3. The AsInnerConverter implementation correctly forwards serialization
4. No obvious platform-specific code

Recommendation

This requires debugging on Mac/Windows with:

• Serialization byte-level comparison between platforms
• Module metadata inspection before/after deserialization
• Stepping through Module Federation container loading

Options

1. Revert PR - Go back to type alias (safest, loses type safety benefits)
2. Skip tests - Mark serial container tests as platform-specific skips (risky)
3. Deep Debug - Requires Mac/Windows environment access

Given time constraints and risk, I recommend reverting for now and investigating separately with proper debugging tools.