Feature/map closures #1864

mathpirate · 2025-10-03T16:46:35Z

Not yet ready for merge

This branch implements closure support for map on OpaqueRef and Cell

Currently includes a first draft of a closure transformer with associated fixtures; next, will include a new method map_with_pattern on OpaqueRef and Cell which will support the new signature

Summary by cubic

Adds a ClosureTransformer that rewrites OpaqueRef/Cell array map callbacks with outer-scope captures into recipe callbacks with a params object. This enables safe, explicit data flow in maps, supports nested callbacks and method chains, and adds thorough docs and fixtures.

New Features
- Transforms OpaqueRef<T[]> and Cell<T[]> .map(fn) when fn captures outer variables to: map(recipe(({ elem, index?, params:{...} }) => ...), { ... }).
- Selective capture: skips module-scoped declarations, imports, functions/handlers, and globals; captures from parent callback scope; treats property access as a unit (e.g., state.user.name).
- Handles nested callbacks, array method chains before map (filter/slice/concat/reverse/sort/flat/flatMap), destructured params, index param, JSX, template literals, conditionals, and type assertions. Plain arrays are not transformed.
- Automatically injects the recipe import. Adds closure-design and implementation-roadmap docs plus comprehensive fixtures.
Refactors
- Added ClosureTransformer to the pipeline (runs first).
- Dataflow analyzer: handles synthetic nodes and preserves array-map rewrite hints.
- OpaqueRef call-expression emitter: skips rewriting the map call itself and rewrites the callee chain when needed.
- Test setup: new closures fixture suite; updated a few expectations to reflect the new transformation.

cubic-dev-ai

11 issues found across 46 files

Prompt for AI agents (all 11 issues)


Understand the root cause of the following 11 issues and fix them.


<file name="packages/ts-transformers/test/fixtures/closures/map-import-reference.input.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-import-reference.input.tsx:24">
Add a stable key to the &lt;div&gt; returned from the map so React can reconcile list items correctly.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-index-param-used.expected.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-index-param-used.expected.tsx:44">
Please add a stable key to the mapped &lt;div&gt; so React can reconcile the list correctly when items change.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx:23">
Add a stable key to the element returned inside `state.items.map` so React can correctly reconcile the list.</violation>

<violation number="2" location="packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx:30">
Provide a unique key on the `&lt;li&gt;` rendered inside the `item.tags.map` callback to avoid reconciliation issues.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-template-literal.input.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-template-literal.input.tsx:21">
Elements returned from state.items.map need a stable key so React can reconcile list updates correctly.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-no-captures.expected.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-no-captures.expected.tsx:40">
Each element returned from the map call should have a stable `key` prop to avoid React reconciliation issues and warnings.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-nested-property.input.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-nested-property.input.tsx:22">
Add a stable key to elements rendered inside `state.items.map` so React can reconcile list items correctly.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-import-reference.expected.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-import-reference.expected.tsx:46">
Elements rendered from the map call need a stable key for correct reconciliation; please add a unique key prop (for example, `item.id`) to the `&lt;div&gt;` returned here.</violation>
</file>

<file name="packages/ts-transformers/test/fixtures/closures/map-no-captures.input.tsx">

<violation number="1" location="packages/ts-transformers/test/fixtures/closures/map-no-captures.input.tsx:19">
Each element produced by state.items.map should include a unique key prop so React can reconcile list updates; without it, updates may misapply state and trigger warnings.</violation>
</file>

<file name="packages/ts-transformers/docs/closure-implementation-roadmap.md">

<violation number="1" location="packages/ts-transformers/docs/closure-implementation-roadmap.md:147">
The &quot;Edge Cases&quot; list claims Cell arrays are transformed even though earlier sections explain they are rejected; please align this bullet with the documented behavior so the roadmap is self-consistent.</violation>
</file>

<file name="packages/ts-transformers/src/closures/transformer.ts">

<violation number="1" location="packages/ts-transformers/src/closures/transformer.ts:543">
Rewriting every callback as an arrow function changes the semantics whenever the original was a function expression (e.g., `this`/`arguments` stop working). Please preserve the original function kind when rebuilding the node.</violation>
</file>

Since this is your first cubic review, here's how it works:

cubic automatically reviews your code and comments on bugs and improvements
Teach cubic by replying to its comments. cubic learns from your replies and gets better over time
Ask questions if you need clarification on any suggestion

_{React with 👍 or 👎 to teach cubic. Mention @cubic-dev-ai to give feedback, ask questions, or re-run the review.}

cubic-dev-ai · 2025-10-03T16:53:35Z

packages/ts-transformers/test/fixtures/closures/map-import-reference.input.tsx

+export default recipe<State>("ModuleScopedReference", (state) => {
+  return {
+    [UI]: (
+      <div>


Add a stable key to the
returned from the map so React can reconcile list items correctly.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-import-reference.input.tsx at line 24: <comment>Add a stable key to the <div> returned from the map so React can reconcile list items correctly.</comment> <file context> @@ -0,0 +1,34 @@ +export default recipe<State>("ModuleScopedReference", (state) => { + return { + [UI]: ( + <div> + {/* Should NOT capture module-level constant or function */} + {state.items.map((item) => ( </file context>

Suggested change

<div>

<div key={item.id}>

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-index-param-used.expected.tsx

+    return {
+        [UI]: (<div>
+        {/* Uses both index parameter and captures state.offset */}
+        {state.items.map(recipe(({ elem, index, params: { offset } }) => (<div>


Please add a stable key to the mapped
so React can reconcile the list correctly when items change.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-index-param-used.expected.tsx at line 44: <comment>Please add a stable key to the mapped <div> so React can reconcile the list correctly when items change.</comment> <file context> @@ -0,0 +1,49 @@ + return { + [UI]: (<div> + {/* Uses both index parameter and captures state.offset */} + {state.items.map(recipe(({ elem, index, params: { offset } }) => (<div> + Item #{index + offset}: {elem.name} + </div>)), { offset: state.offset })} </file context>

Suggested change

{state.items.map(recipe(({ elem, index, params: { offset } }) => (<div>

{state.items.map(recipe(({ elem, index, params: { offset } }) => (<div key={elem.id}>

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx

+export default recipe<State>("NestedCallback", (state) => {
+  return {
+    [UI]: (
+      <div>


Add a stable key to the element returned inside state.items.map so React can correctly reconcile the list.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx at line 23: <comment>Add a stable key to the element returned inside `state.items.map` so React can correctly reconcile the list.</comment> <file context> @@ -0,0 +1,38 @@ +export default recipe<State>("NestedCallback", (state) => { + return { + [UI]: ( + <div> + {/* Outer map captures state.prefix, inner map closes over item from outer callback */} + {state.items.map((item) => ( </file context>

Suggested change

<div>

<div key={item.id}>

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx

+            {state.prefix}: {item.name}
+            <ul>
+              {item.tags.map((tag) => (
+                <li>{item.name} - {tag.name}</li>


Provide a unique key on the <li> rendered inside the item.tags.map callback to avoid reconciliation issues.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-nested-callback.input.tsx at line 30: <comment>Provide a unique key on the `<li>` rendered inside the `item.tags.map` callback to avoid reconciliation issues.</comment> <file context> @@ -0,0 +1,38 @@ + {state.prefix}: {item.name} + <ul> + {item.tags.map((tag) => ( + <li>{item.name} - {tag.name}</li> + ))} + </ul> </file context>

Suggested change

<li>{item.name} - {tag.name}</li>

<li key={tag.id}>{item.name} - {tag.name}</li>

✅ Addressed in 9ead191

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-template-literal.input.tsx

+      <div>
+        {/* Template literal with captures */}
+        {state.items.map((item) => (
+          <div>{`${state.prefix} ${item.name} ${state.suffix}`}</div>


Elements returned from state.items.map need a stable key so React can reconcile list updates correctly.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-template-literal.input.tsx at line 21: <comment>Elements returned from state.items.map need a stable key so React can reconcile list updates correctly.</comment> <file context> @@ -0,0 +1,26 @@ + <div> + {/* Template literal with captures */} + {state.items.map((item) => ( + <div>{`${state.prefix} ${item.name} ${state.suffix}`}</div> + ))} + </div> </file context>

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-nested-property.input.tsx

+export default recipe<State>("NestedProperty", (state) => {
+  return {
+    [UI]: (
+      <div>


Add a stable key to elements rendered inside state.items.map so React can reconcile list items correctly.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-nested-property.input.tsx at line 22: <comment>Add a stable key to elements rendered inside `state.items.map` so React can reconcile list items correctly.</comment> <file context> @@ -0,0 +1,31 @@ +export default recipe<State>("NestedProperty", (state) => { + return { + [UI]: ( + <div> + {state.items.map((item) => ( + <div> </file context>

✅ Addressed in 9ead191

cubic-dev-ai · 2025-10-03T16:53:36Z

packages/ts-transformers/test/fixtures/closures/map-import-reference.expected.tsx

+    return {
+        [UI]: (<div>
+        {/* Should NOT capture module-level constant or function */}
+        {state.items.map((item) => (<div>


Elements rendered from the map call need a stable key for correct reconciliation; please add a unique key prop (for example, item.id) to the <div> returned here.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-import-reference.expected.tsx at line 46: <comment>Elements rendered from the map call need a stable key for correct reconciliation; please add a unique key prop (for example, `item.id`) to the `<div>` returned here.</comment> <file context> @@ -0,0 +1,51 @@ + return { + [UI]: (<div> + {/* Should NOT capture module-level constant or function */} + {state.items.map((item) => (<div> + Item: {derive(item.price, _v1 => formatPrice(_v1 * (1 + TAX_RATE)))} + </div>))} </file context>

Suggested change

{state.items.map((item) => (<div>

{state.items.map((item) => (<div key={item.id}>

cubic-dev-ai · 2025-10-03T16:53:37Z

packages/ts-transformers/test/fixtures/closures/map-no-captures.input.tsx

+      <div>
+        {/* No captures - just uses the callback parameter */}
+        {state.items.map((item) => (
+          <div>Item #{item.id}: ${item.price}</div>


Each element produced by state.items.map should include a unique key prop so React can reconcile list updates; without it, updates may misapply state and trigger warnings.

Prompt for AI agents

Address the following comment on packages/ts-transformers/test/fixtures/closures/map-no-captures.input.tsx at line 19: <comment>Each element produced by state.items.map should include a unique key prop so React can reconcile list updates; without it, updates may misapply state and trigger warnings.</comment> <file context> @@ -0,0 +1,24 @@ + <div> + {/* No captures - just uses the callback parameter */} + {state.items.map((item) => ( + <div>Item #{item.id}: ${item.price}</div> + ))} + </div> </file context>

Suggested change

<div>Item #{item.id}: ${item.price}</div>

<div key={item.id}>Item #{item.id}: ${item.price}</div>

cubic-dev-ai · 2025-10-03T16:53:37Z

packages/ts-transformers/docs/closure-implementation-roadmap.md

+✅ Callback parameters (not captured)
+✅ Index parameter preservation
+✅ Plain arrays (not transformed)
+✅ Cell arrays (ARE transformed)


The "Edge Cases" list claims Cell arrays are transformed even though earlier sections explain they are rejected; please align this bullet with the documented behavior so the roadmap is self-consistent.

Prompt for AI agents

Address the following comment on packages/ts-transformers/docs/closure-implementation-roadmap.md at line 147: <comment>The "Edge Cases" list claims Cell arrays are transformed even though earlier sections explain they are rejected; please align this bullet with the documented behavior so the roadmap is self-consistent.</comment> <file context> @@ -0,0 +1,439 @@ +✅ Callback parameters (not captured) +✅ Index parameter preservation +✅ Plain arrays (not transformed) +✅ Cell arrays (ARE transformed) + +#### Test Coverage </file context>

Suggested change

✅ Cell arrays (ARE transformed)

✅ Cell arrays (NOT transformed)

✅ Addressed in 35f40ac

cubic-dev-ai · 2025-10-03T16:53:37Z

packages/ts-transformers/src/closures/transformer.ts

+  }
+
+  // Create the new callback
+  const newCallback = factory.createArrowFunction(


Rewriting every callback as an arrow function changes the semantics whenever the original was a function expression (e.g., this/arguments stop working). Please preserve the original function kind when rebuilding the node.

Prompt for AI agents

Address the following comment on packages/ts-transformers/src/closures/transformer.ts at line 543: <comment>Rewriting every callback as an arrow function changes the semantics whenever the original was a function expression (e.g., `this`/`arguments` stop working). Please preserve the original function kind when rebuilding the node.</comment> <file context> @@ -0,0 +1,617 @@ + } + + // Create the new callback + const newCallback = factory.createArrowFunction( + callback.modifiers, + callback.typeParameters, </file context>

packages/runner/src/builder/opaque-ref.ts

jsantell · 2025-10-06T21:10:49Z

packages/runner/src/builder/opaque-ref.ts

 import { createNodeFactory } from "./module.ts";

 let mapFactory: NodeFactory<any, any>;
+let mapWithPatternFactory: NodeFactory<any, any>;


Shouldn't this be NodeFactory<any, any> | undefined?

Could NodeFactorys generics be unknown? (maybe not, could be too difficult)

yes it should be, i removed the mapWithPatternFactory but i made this change on the mapFactory variable declared separately just above this comment

packages/runner/src/builder/types.ts

packages/runner/src/builtins/map_with_pattern.ts

jsantell · 2025-10-06T21:20:05Z

packages/runner/src/builtins/map_with_pattern.ts

+      throw new Error("map_with_pattern currently only supports arrays");
+    }
+
+    const newArrayValue = resultWithLog.get().slice(0, initializedUpTo);


Can this returned function ((tx: IExtendedStorageTransaction) => { .. }) execute multiple times? If not, initializedUpTo is always 0 here (same with newArrayValue.length), though I'm not too familiar with these mechanisms

ok so it appears that the answer is yes, the returned function executes multiple times, reactively whenever inputs change. (this original comment was on the now-deleted separate map_with_pattern built-in which i have since re-unified with the preexisting map built-in but) it applies to map too so, leaving this conclusion here

jsantell · 2025-10-06T21:22:03Z

packages/ts-transformers/src/closures/transformer.ts

+import { isOpaqueRefType } from "../transformers/opaque-ref/opaque-ref.ts";
+import { getHelperIdentifier } from "../transformers/opaque-ref/import-resolver.ts";
+
+export class ClosureTransformer extends Transformer {


jsantell · 2025-10-06T21:29:52Z

packages/ts-transformers/src/closures/transformer.ts

+
+  // Collect destructured property names if the param is a destructured binding pattern
+  const destructuredProps = new Set<string>();
+  if (elemName && ts.isObjectBindingPattern(elemName)) {


future ideas: Similar to wanting a DSL for rewriting typescript, I wonder if there's some abstraction we could generally apply to the functions we rewrite to handle the transformation of args (optional args, optional destructuring), or handle rewriting functions the same way (regardless if it was an arrow function, function declaration, function expression etc.), since we could reuse them across several transformations, not worrying about all the different forms user authored TS comes in within the transformer business logic

yeah... thanks... i agree, it would be better to have more conceptual unification here. i'm going to try to think about this again from the top soon and to also incorporate berni's nudge to try constructing our transformations in such a way that as much of the original code can survive untransformed as possible. some of the other transformers do a bunch of parameter name rewriting that's legacy from the original transformer whose behavior i wasn't ready to change. soon i'll take a broad pass at this

jsantell · 2025-10-06T21:32:42Z

packages/ts-transformers/src/closures/transformer.ts

+      mapCall.expression.expression, // state.items
+      factory.createIdentifier("map_with_pattern"),
+    )
+    : factory.createIdentifier("map_with_pattern"); // Fallback (shouldn't happen)


Let's throw an error if we don't expect this

good catch, thanks, done

jsantell · 2025-10-06T21:34:38Z

packages/ts-transformers/src/closures/transformer.ts

+      // Check if the callback is an arrow function or function expression
+      if (
+        callback &&
+        (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))


There's another similar helper function defined here isFunctionDeclaration that seems to include various types of function types -- if we don't care what type of function it is, maybe we can reuse that, or just add these utils to the generic ast helpers in ast/ (i think that's the rough idea anyway)

packages/ts-transformers/src/closures/transformer.ts

jsantell · 2025-10-14T21:29:17Z

packages/ts-transformers/test/fixtures/closures/map-import-reference.input.tsx

+
+// Module-level function - should NOT be captured
+function formatPrice(price: number): string {
+  return `$${price.toFixed(2)}`;


What if this function did something like

function formatPrice(price: number): string { // @ts-ignore globalThis.x = (globalThis.x ?? 0) + 1; // @ts-ignore return `${globalThis.x}_$${price.toFixed(2)}`; }

jsantell · 2025-10-14T21:31:39Z

packages/ts-transformers/src/closures/types.ts

+import ts from "typescript";
+import type { TransformationContext } from "../core/context.ts";
+
+export interface ClosureRule {


Is this used?

jsantell · 2025-10-15T21:48:40Z

Probably could exclude the "jsx-key" rule from linting as it's not applicable really in our environment

…ill broken) This commit removes special-case handling for array-map callbacks and treats all callback parameters (builder and array-map) uniformly for fine-grained reactivity. ## What Works Successfully unified parameter handling: - Both builder (state) and map (element) parameters now excluded from derive dependencies - Property accesses (state.count, element.price) correctly included - Manually written mapWithPattern(recipe(...)) works perfectly with JSX expression transformations ## What's Broken Synthetic AST nodes (created by closures transformer) fail to detect computations: - All closure transformation tests failing (9 tests) - Root cause: synthetic AST nodes lack symbol information - element.price * discount in transformed map callbacks not wrapped in derive - Merged analysis from children has requiresRewrite: false ## Changes Made 1. dataflow.ts: Removed array-map special cases at lines 362-373, 411-428 - These forced requiresRewrite: true for array-map parameters - No longer needed in new uniform model 2. helpers.ts: Unified resolvesToParameterOfKind() - Removed allowPropertyTraversal distinction - Both builder and array-map now only match root identifiers - Property accesses excluded from parameter detection 3. Test fixtures: Updated expected outputs for all map callback tests - Now expect derive/ifElse wrappers in JSX expressions - Tests currently fail due to synthetic AST issue 4. New test: manual-map-with-pattern.{input,expected}.tsx - Validates manually written code works correctly - Demonstrates desired behavior ## Next Steps Need to solve synthetic AST analysis to detect computations without symbol information. Options to explore: - Fix synthetic handling in dataflow.ts (lines 173-240) - Modify closures transformer to preserve more information - Alternative approach TBD 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>

…hs for all transformers

…etection - Unified top-level and nested map callback transformation into single visitor - Always transform map callbacks (even with zero captures) to ensure params are opaque - Added detection of recipe/builder parameters as opaque even when symbol resolution fails - Fixed synthetic PropertyAccessExpression handling in dataflow analysis - Updated test expectations to match new behavior This sets foundation for hierarchical params refactor. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>

This reverts commit f9ded59.

cubic-dev-ai bot reviewed Oct 3, 2025

View reviewed changes

mathpirate temporarily deployed to ci October 3, 2025 17:00 — with GitHub Actions Inactive

mathpirate had a problem deploying to ci October 3, 2025 17:00 — with GitHub Actions Failure

mathpirate temporarily deployed to ci October 3, 2025 17:00 — with GitHub Actions Inactive

mathpirate temporarily deployed to ci October 3, 2025 17:48 — with GitHub Actions Inactive

mathpirate had a problem deploying to ci October 3, 2025 17:48 — with GitHub Actions Failure

mathpirate temporarily deployed to ci October 3, 2025 18:45 — with GitHub Actions Inactive

mathpirate requested review from jsantell and seefeldb October 3, 2025 19:55

mathpirate temporarily deployed to ci October 3, 2025 20:05 — with GitHub Actions Inactive

jsantell reviewed Oct 6, 2025

View reviewed changes

mathpirate force-pushed the feature/map-closures branch from 2ddcb2a to f943229 Compare October 9, 2025 19:46

jsantell reviewed Oct 14, 2025

View reviewed changes

mathpirate force-pushed the feature/map-closures branch from 0e330fa to 1db2df5 Compare October 14, 2025 23:51

mathpirate temporarily deployed to ci October 15, 2025 00:38 — with GitHub Actions Inactive

mathpirate force-pushed the feature/map-closures branch from 0fb3261 to f95c973 Compare October 15, 2025 18:59

mathpirate force-pushed the feature/map-closures branch from a679c0d to ba95dea Compare October 16, 2025 19:25

mathpirate and others added 20 commits October 20, 2025 14:09

no-unused-vars yay

c924afc

remove now-unneeded doc

b9fcc94

remove import of h

45070cd

handle synthetic JSX expressions in dataflow

18ec0cd

safe way of getting node text that works with synthetic nodes

2d06e4d

add JSX traversal handling throughout synthetic and non-synthetic pat…

08d4b5c

…hs for all transformers

some fixes for synthetic nodes and some fixture updates

e1214f8

fmt

e3e79be

update another fixture

b3eb79b

fix for ifElse behaviors

d65df9a

Refactor a few things and fix lint

22a504f

fix formatting and update for new behavior of expected fixture

9bb9175

fix final test

a6b4092

implement array destructuring for map elements

639f7db

properly transform index parameter

2c50902

fmt

0f1abc2

explicit undefined type option for mapFactory

57d120a

throw an error instead of trying a final fallback

96f2f72

mathpirate force-pushed the feature/map-closures branch from d682fd0 to 96f2f72 Compare October 20, 2025 21:09

mathpirate temporarily deployed to ci October 20, 2025 21:13 — with GitHub Actions Inactive

mathpirate merged commit f9ded59 into main Oct 21, 2025
8 checks passed

mathpirate deleted the feature/map-closures branch October 21, 2025 16:49

seefeldb added a commit that referenced this pull request Oct 21, 2025

Revert "Feature/map closures (#1864)"

42c4dfc

This reverts commit f9ded59.

seefeldb restored the feature/map-closures branch October 22, 2025 17:43

seefeldb mentioned this pull request Oct 23, 2025

feat(transform): rewrite .map function closures to pass in any closed over cells #1948

Merged

	{state.items.map(recipe(({ elem, index, params: { offset } }) => (<div>
	{state.items.map(recipe(({ elem, index, params: { offset } }) => (<div key={elem.id}>

	<li>{item.name} - {tag.name}</li>
	<li key={tag.id}>{item.name} - {tag.name}</li>

	{state.items.map((item) => (<div>
	{state.items.map((item) => (<div key={item.id}>

	<div>Item #{item.id}: ${item.price}</div>
	<div key={item.id}>Item #{item.id}: ${item.price}</div>

	✅ Cell arrays (ARE transformed)
	✅ Cell arrays (NOT transformed)

Feature/map closures #1864

Feature/map closures #1864

Uh oh!

Conversation

mathpirate commented Oct 3, 2025 • edited by cubic-dev-ai bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary by cubic

Uh oh!

cubic-dev-ai bot left a comment

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cubic-dev-ai bot Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

jsantell Oct 14, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

mathpirate commented Oct 3, 2025 •

edited by cubic-dev-ai bot

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

cubic-dev-ai bot Oct 3, 2025 •

edited

Loading

jsantell Oct 14, 2025 •

edited

Loading