Fix: Prevent map transformation when inside derive and exclude untransformed map parameters

[seefeldb]

Summary

This PR fixes two related issues with map transformations in JSX expressions:

1. Prevents .mapWithPattern() errors when map is inside derive: Stops transforming .map() to .mapWithPattern() when the map will be wrapped in a derive(), since the array gets unwrapped inside the derive and plain .map() is needed.

2. Fixes incorrect parameter capture in outer derives: Prevents untransformed map callback parameters from being incorrectly captured in outer derive calls.

Problem

When a map is nested in an expression with opaque refs (e.g., list.length > 0 && list.map(...)), the OpaqueRefJSXTransformer wraps the entire expression in derive(list, list => ...). This causes two issues:

1. If ClosureTransformer had already converted .map() to .mapWithPattern(), this causes runtime errors because unwrapped arrays don't have mapWithPattern()
2. Map callback parameters were incorrectly captured in the outer derive as dependencies (e.g., item.name from inside the map callback)

Solution

Fix 1: Skip map transformation when inside derive

• Added shouldTransformMap() function in closures/transformer.ts that uses dataflow analysis
• Detects when a map's containing JSX expression will be wrapped in derive
• Checks for analysis.requiresRewrite && !skip-call-rewrite hint to distinguish derive wrapping from other transformations
• Skips transformation in these cases, keeping plain .map() which works on unwrapped arrays

Fix 2: Exclude untransformed map parameters from outer scope

• Modified getOpaqueCallKindForParameter() in transformers/opaque-ref/helpers.ts
• Now checks context.isMapCallback() to determine if a callback was actually transformed
• Only treats parameters as opaque if the callback was transformed to mapWithPattern
• Untransformed callbacks (plain .map() inside derives) have regular parameters that shouldn't be captured

Example

Input:

{list.length > 0 && list.map((item) => <div>{item.name}</div>)}

Before (broken):

{derive({ list, item_name: item.name }, ...) => ...}  // ❌ item doesn't exist yet!
{list.mapWithPattern(...)}  // ❌ mapWithPattern doesn't exist on unwrapped arrays!

After (fixed):

{derive({ list }, ({ list }) => list.length > 0 && (
  <div>{list.map((item) => <div>{item.name}</div>)}</div>
))}  // ✅ Plain .map() works on unwrapped array, no incorrect captures

Test Plan

• Added new test fixture map-array-length-conditional for the specific use case
• Updated existing test fixtures to reflect correct behavior
• All 96 test steps pass

🤖 Generated with Claude Code

---

Summary by cubic

Prevents transforming .map() to .mapWithPattern() when the map is inside a derive-wrapped JSX expression, avoiding runtime errors on plain arrays. Also stops untransformed map callback parameters from being captured by outer derive dependencies.

• Bug Fixes
  • Use dataflow analysis to detect derive wrapping and skip the mapWithPattern rewrite when needed.
  • Treat map callback parameters as opaque only if the callback was transformed; plain .map() callbacks are not captured.

[cubic-dev-ai]

No issues found across 7 files