@fictjs/compiler 0.0.8 → 0.0.10

package/dist/index.js

@@ -14372,6 +14372,9 @@ function pathToString(path) {
 
 // src/ir/build-hir.ts
 var destructuringTempCounter = 0;
+var getLoc = (node) => {
+  return node?.loc ?? null;
+};
 function normalizeVarKind(kind) {
   return kind === "const" || kind === "let" || kind === "var" ? kind : "let";
 }
@@ -14441,7 +14444,8 @@ function buildHIR(ast) {
       functions.push(
         convertFunction(name, stmt.params, stmt.body.body, {
           noMemo: programNoMemo,
-          directives: stmt.body.directives
+          directives: stmt.body.directives,
+          loc: getLoc(stmt)
         })
       );
       continue;
@@ -14454,7 +14458,8 @@ function buildHIR(ast) {
         functions.push(
           convertFunction(name, decl.params, decl.body.body, {
             noMemo: programNoMemo,
-            directives: decl.body.directives
+            directives: decl.body.directives,
+            loc: getLoc(decl)
           })
         );
         postamble.push({ kind: "ExportFunction", name });
@@ -14472,9 +14477,11 @@ function buildHIR(ast) {
             const hasExpressionBody = isArrow && !t.isBlockStatement(body);
             const fnHIR = t.isBlockStatement(body) ? convertFunction(name, params, body.body, {
               noMemo: programNoMemo,
-              directives: body.directives
+              directives: body.directives,
+              loc: getLoc(v.init ?? v)
             }) : convertFunction(name, params, [t.returnStatement(body)], {
-              noMemo: programNoMemo
+              noMemo: programNoMemo,
+              loc: getLoc(v.init ?? v)
             });
             fnHIR.meta = { ...fnHIR.meta ?? {}, fromExpression: true, isArrow, hasExpressionBody };
             functions.push(fnHIR);
@@ -14499,7 +14506,8 @@ function buildHIR(ast) {
         functions.push(
           convertFunction(name, decl.params, decl.body.body, {
             noMemo: programNoMemo,
-            directives: decl.body.directives
+            directives: decl.body.directives,
+            loc: getLoc(decl)
           })
         );
         postamble.push({ kind: "ExportDefault", name });
@@ -14524,13 +14532,15 @@ function buildHIR(ast) {
           const hasExpressionBody = isArrow && !t.isBlockStatement(body);
           const fnHIR = t.isBlockStatement(body) ? convertFunction(name, params, body.body, {
             noMemo: programNoMemo,
-            directives: body.directives
+            directives: body.directives,
+            loc: getLoc(decl.init ?? decl)
           }) : convertFunction(
             name,
             params,
             [t.returnStatement(body)],
             {
-              noMemo: programNoMemo
+              noMemo: programNoMemo,
+              loc: getLoc(decl.init ?? decl)
             }
           );
           fnHIR.meta = { ...fnHIR.meta ?? {}, fromExpression: true, isArrow, hasExpressionBody };
@@ -15038,11 +15048,12 @@ function convertFunction(name, params, body, options) {
     name,
     params: paramIds,
     blocks,
-    meta: hasNoMemo ? { noMemo: true } : void 0
+    meta: hasNoMemo ? { noMemo: true } : void 0,
+    loc: options?.loc ?? null
   };
 }
 function convertStatementsToHIRFunction(name, statements) {
-  return convertFunction(name, [], statements);
+  return convertFunction(name, [], statements, { loc: getLoc(statements[0]) });
 }
 function convertAssignmentValue(expr) {
   const right = convertExpression(expr.right);
@@ -15540,14 +15551,16 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
   return bb;
 }
 function convertExpression(node) {
-  if (t.isIdentifier(node)) return { kind: "Identifier", name: node.name };
+  const loc = getLoc(node);
+  if (t.isIdentifier(node)) return { kind: "Identifier", name: node.name, loc };
   if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node))
-    return { kind: "Literal", value: node.value ?? null };
+    return { kind: "Literal", value: node.value ?? null, loc };
   if (t.isCallExpression(node)) {
     const call = {
       kind: "CallExpression",
       callee: convertExpression(node.callee),
-      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean)
+      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
+      loc
     };
     return call;
   }
@@ -15562,7 +15575,8 @@ function convertExpression(node) {
         object,
         property,
         computed: node.computed,
-        optional: node.optional ?? true
+        optional: node.optional ?? true,
+        loc
       };
       return optionalMember;
     }
@@ -15571,7 +15585,8 @@ function convertExpression(node) {
       object,
       property,
       computed: node.computed,
-      optional: false
+      optional: false,
+      loc
     };
     return member;
   }
@@ -15580,7 +15595,8 @@ function convertExpression(node) {
       kind: "BinaryExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return bin;
   }
@@ -15589,7 +15605,8 @@ function convertExpression(node) {
       kind: "UnaryExpression",
       operator: node.operator,
       argument: convertExpression(node.argument),
-      prefix: node.prefix
+      prefix: node.prefix,
+      loc
     };
     return un;
   }
@@ -15598,7 +15615,8 @@ function convertExpression(node) {
       kind: "LogicalExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return log;
   }
@@ -15607,7 +15625,8 @@ function convertExpression(node) {
       kind: "ConditionalExpression",
       test: convertExpression(node.test),
       consequent: convertExpression(node.consequent),
-      alternate: convertExpression(node.alternate)
+      alternate: convertExpression(node.alternate),
+      loc
     };
     return cond;
   }
@@ -15619,12 +15638,14 @@ function convertExpression(node) {
         if (t.isSpreadElement(el)) {
           return {
             kind: "SpreadElement",
-            argument: convertExpression(el.argument)
+            argument: convertExpression(el.argument),
+            loc: getLoc(el)
           };
         }
         if (t.isExpression(el)) return convertExpression(el);
         return void 0;
-      }).filter(Boolean)
+      }).filter(Boolean),
+      loc
     };
     return arr;
   }
@@ -15635,7 +15656,8 @@ function convertExpression(node) {
         if (t.isSpreadElement(prop)) {
           return {
             kind: "SpreadElement",
-            argument: convertExpression(prop.argument)
+            argument: convertExpression(prop.argument),
+            loc: getLoc(prop)
           };
         }
         if (t.isObjectMethod(prop)) {
@@ -15652,7 +15674,8 @@ function convertExpression(node) {
           return {
             kind: "Property",
             key: keyExpr2,
-            value: convertExpression(fnExpr)
+            value: convertExpression(fnExpr),
+            loc: getLoc(prop)
           };
         }
         if (!t.isObjectProperty(prop) || prop.computed) return void 0;
@@ -15662,9 +15685,12 @@ function convertExpression(node) {
         return {
           kind: "Property",
           key: keyExpr,
-          value: convertExpression(prop.value)
+          value: convertExpression(prop.value),
+          shorthand: prop.shorthand && t.isIdentifier(prop.value),
+          loc: getLoc(prop)
         };
-      }).filter(Boolean)
+      }).filter(Boolean),
+      loc
     };
     return obj;
   }
@@ -15677,38 +15703,42 @@ function convertExpression(node) {
       if (t.isJSXText(child)) {
         const text = child.value;
         if (text.trim()) {
-          children.push({ kind: "text", value: text });
+          children.push({ kind: "text", value: text, loc: getLoc(child) });
         }
       } else if (t.isJSXExpressionContainer(child)) {
         if (!t.isJSXEmptyExpression(child.expression)) {
           children.push({
             kind: "expression",
-            value: convertExpression(child.expression)
+            value: convertExpression(child.expression),
+            loc: getLoc(child)
           });
         }
       } else if (t.isJSXElement(child)) {
         children.push({
           kind: "element",
-          value: convertJSXElement(child)
+          value: convertJSXElement(child),
+          loc: getLoc(child)
         });
       } else if (t.isJSXFragment(child)) {
         for (const fragChild of child.children) {
           if (t.isJSXText(fragChild)) {
             const text = fragChild.value;
             if (text.trim()) {
-              children.push({ kind: "text", value: text });
+              children.push({ kind: "text", value: text, loc: getLoc(fragChild) });
             }
           } else if (t.isJSXExpressionContainer(fragChild)) {
             if (!t.isJSXEmptyExpression(fragChild.expression)) {
               children.push({
                 kind: "expression",
-                value: convertExpression(fragChild.expression)
+                value: convertExpression(fragChild.expression),
+                loc: getLoc(fragChild)
               });
             }
           } else if (t.isJSXElement(fragChild)) {
             children.push({
               kind: "element",
-              value: convertJSXElement(fragChild)
+              value: convertJSXElement(fragChild),
+              loc: getLoc(fragChild)
             });
           }
         }
@@ -15716,24 +15746,27 @@ function convertExpression(node) {
     }
     return {
       kind: "JSXElement",
-      tagName: { kind: "Identifier", name: "Fragment" },
+      tagName: { kind: "Identifier", name: "Fragment", loc: getLoc(node) },
       isComponent: true,
       attributes: [],
-      children
+      children,
+      loc: getLoc(node)
     };
   }
   if (t.isArrowFunctionExpression(node)) {
     if (t.isBlockStatement(node.body)) {
       const nested = convertFunction(void 0, node.params, node.body.body, {
         noMemo: hasNoMemoDirectiveInStatements(node.body.body),
-        directives: node.body.directives
+        directives: node.body.directives,
+        loc: getLoc(node)
       });
       const arrow = {
         kind: "ArrowFunction",
         params: nested.params,
         body: nested.blocks,
         isExpression: false,
-        isAsync: node.async
+        isAsync: node.async,
+        loc
       };
       return arrow;
     } else {
@@ -15744,7 +15777,8 @@ function convertExpression(node) {
         ).flat(),
         body: convertExpression(node.body),
         isExpression: true,
-        isAsync: node.async
+        isAsync: node.async,
+        loc
       };
       return arrow;
     }
@@ -15752,14 +15786,16 @@ function convertExpression(node) {
   if (t.isFunctionExpression(node)) {
     const nested = convertFunction(void 0, node.params, node.body.body, {
       noMemo: hasNoMemoDirectiveInStatements(node.body.body),
-      directives: node.body.directives
+      directives: node.body.directives,
+      loc: getLoc(node)
     });
     const fn = {
       kind: "FunctionExpression",
       name: node.id?.name ?? "",
       params: nested.params,
       body: nested.blocks,
-      isAsync: node.async
+      isAsync: node.async,
+      loc
     };
     return fn;
   }
@@ -15768,7 +15804,8 @@ function convertExpression(node) {
       kind: "AssignmentExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return assign;
   }
@@ -15777,7 +15814,8 @@ function convertExpression(node) {
       kind: "UpdateExpression",
       operator: node.operator,
       argument: convertExpression(node.argument),
-      prefix: node.prefix
+      prefix: node.prefix,
+      loc
     };
     return update;
   }
@@ -15785,34 +15823,39 @@ function convertExpression(node) {
     const template = {
       kind: "TemplateLiteral",
       quasis: node.quasis.map((q) => q.value.cooked ?? q.value.raw),
-      expressions: node.expressions.map((e) => convertExpression(e))
+      expressions: node.expressions.map((e) => convertExpression(e)),
+      loc
     };
     return template;
   }
   if (t.isAwaitExpression(node)) {
     return {
       kind: "AwaitExpression",
-      argument: convertExpression(node.argument)
+      argument: convertExpression(node.argument),
+      loc
     };
   }
   if (t.isNewExpression(node)) {
     return {
       kind: "NewExpression",
       callee: convertExpression(node.callee),
-      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean)
+      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
+      loc
     };
   }
   if (t.isSequenceExpression(node)) {
     return {
       kind: "SequenceExpression",
-      expressions: node.expressions.map((e) => convertExpression(e))
+      expressions: node.expressions.map((e) => convertExpression(e)),
+      loc
     };
   }
   if (t.isYieldExpression(node)) {
     return {
       kind: "YieldExpression",
       argument: node.argument ? convertExpression(node.argument) : null,
-      delegate: node.delegate
+      delegate: node.delegate,
+      loc
     };
   }
   if (t.isOptionalCallExpression(node)) {
@@ -15820,7 +15863,8 @@ function convertExpression(node) {
       kind: "OptionalCallExpression",
       callee: convertExpression(node.callee),
       arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
-      optional: node.optional
+      optional: node.optional,
+      loc
     };
   }
   if (t.isTaggedTemplateExpression(node)) {
@@ -15832,8 +15876,10 @@ function convertExpression(node) {
         quasis: node.quasi.quasis.map((q) => q.value.cooked ?? q.value.raw),
         expressions: node.quasi.expressions.map(
           (e) => convertExpression(e)
-        )
-      }
+        ),
+        loc: getLoc(node.quasi)
+      },
+      loc
     };
   }
   if (t.isClassExpression(node)) {
@@ -15841,17 +15887,18 @@ function convertExpression(node) {
       kind: "ClassExpression",
       name: node.id?.name,
       superClass: node.superClass ? convertExpression(node.superClass) : void 0,
-      body: node.body.body
+      body: node.body.body,
       // Store as Babel AST for now
+      loc
     };
   }
   if (t.isThisExpression(node)) {
-    return { kind: "ThisExpression" };
+    return { kind: "ThisExpression", loc };
   }
   if (t.isSuper(node)) {
-    return { kind: "SuperExpression" };
+    return { kind: "SuperExpression", loc };
   }
-  const fallback = { kind: "Literal", value: void 0 };
+  const fallback = { kind: "Literal", value: void 0, loc };
   return fallback;
 }
 function convertJSXElement(node) {
@@ -15862,7 +15909,7 @@ function convertJSXElement(node) {
     const name = opening.name.name;
     const firstChar = name[0];
     if (firstChar && firstChar === firstChar.toUpperCase()) {
-      tagName = { kind: "Identifier", name };
+      tagName = { kind: "Identifier", name, loc: getLoc(opening.name) };
       isComponent = true;
     } else {
       tagName = name;
@@ -15880,20 +15927,22 @@ function convertJSXElement(node) {
         name: "",
         value: null,
         isSpread: true,
-        spreadExpr: convertExpression(attr.argument)
+        spreadExpr: convertExpression(attr.argument),
+        loc: getLoc(attr)
       });
     } else if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
       let value = null;
       if (attr.value) {
         if (t.isStringLiteral(attr.value)) {
-          value = { kind: "Literal", value: attr.value.value };
+          value = { kind: "Literal", value: attr.value.value, loc: getLoc(attr.value) };
         } else if (t.isJSXExpressionContainer(attr.value) && !t.isJSXEmptyExpression(attr.value.expression)) {
           value = convertExpression(attr.value.expression);
         }
       }
       attributes.push({
         name: attr.name.name,
-        value
+        value,
+        loc: getLoc(attr)
       });
     }
   }
@@ -15902,38 +15951,42 @@ function convertJSXElement(node) {
     if (t.isJSXText(child)) {
       const text = child.value;
       if (text.trim()) {
-        children.push({ kind: "text", value: text });
+        children.push({ kind: "text", value: text, loc: getLoc(child) });
       }
     } else if (t.isJSXExpressionContainer(child)) {
       if (!t.isJSXEmptyExpression(child.expression)) {
         children.push({
           kind: "expression",
-          value: convertExpression(child.expression)
+          value: convertExpression(child.expression),
+          loc: getLoc(child)
         });
       }
     } else if (t.isJSXElement(child)) {
       children.push({
         kind: "element",
-        value: convertJSXElement(child)
+        value: convertJSXElement(child),
+        loc: getLoc(child)
       });
     } else if (t.isJSXFragment(child)) {
       for (const fragChild of child.children) {
         if (t.isJSXText(fragChild)) {
           const text = fragChild.value;
           if (text.trim()) {
-            children.push({ kind: "text", value: text });
+            children.push({ kind: "text", value: text, loc: getLoc(fragChild) });
           }
         } else if (t.isJSXExpressionContainer(fragChild)) {
           if (!t.isJSXEmptyExpression(fragChild.expression)) {
             children.push({
               kind: "expression",
-              value: convertExpression(fragChild.expression)
+              value: convertExpression(fragChild.expression),
+              loc: getLoc(fragChild)
             });
           }
         } else if (t.isJSXElement(fragChild)) {
           children.push({
             kind: "element",
-            value: convertJSXElement(fragChild)
+            value: convertJSXElement(fragChild),
+            loc: getLoc(fragChild)
           });
         }
       }
@@ -15944,21 +15997,27 @@ function convertJSXElement(node) {
     tagName,
     isComponent,
     attributes,
-    children
+    children,
+    loc: getLoc(node)
   };
 }
 function convertJSXMemberExpr(node) {
   let object;
   if (t.isJSXIdentifier(node.object)) {
-    object = { kind: "Identifier", name: node.object.name };
+    object = { kind: "Identifier", name: node.object.name, loc: getLoc(node.object) };
   } else {
     object = convertJSXMemberExpr(node.object);
   }
   return {
     kind: "MemberExpression",
     object,
-    property: { kind: "Identifier", name: node.property.name },
-    computed: false
+    property: {
+      kind: "Identifier",
+      name: node.property.name,
+      loc: getLoc(node.property)
+    },
+    computed: false,
+    loc: getLoc(node)
   };
 }
 
@@ -18272,7 +18331,8 @@ function lowerNodeWithRegionContext(node, t2, ctx, declaredVars, regionCtx) {
         t2.blockStatement(conseqStmts),
         altStmts ? t2.blockStatement(altStmts) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -18500,31 +18560,53 @@ function lowerStructuredNodeForRegion(node, region, t2, ctx, declaredVars, regio
       return stmt ? [stmt] : [];
     }
     case "if": {
-      const consequent = lowerStructuredNodeForRegion(
-        node.consequent,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      );
-      const alternate = node.alternate ? lowerStructuredNodeForRegion(
-        node.alternate,
-        region,
-        t2,
-        ctx,
-        declaredVars,
-        regionCtx,
-        skipInstructions
-      ) : [];
+      const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+      const baseShouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && !inNonReactiveScope && expressionUsesTracked(node.test, ctx);
+      const lowerChild = (child, forceNonReactive) => {
+        if (!child) return [];
+        if (!forceNonReactive) {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        }
+        const prevDepth = ctx.nonReactiveScopeDepth ?? 0;
+        ctx.nonReactiveScopeDepth = prevDepth + 1;
+        try {
+          return lowerStructuredNodeForRegion(
+            child,
+            region,
+            t2,
+            ctx,
+            declaredVars,
+            regionCtx,
+            skipInstructions
+          );
+        } finally {
+          ctx.nonReactiveScopeDepth = prevDepth;
+        }
+      };
+      let consequent = lowerChild(node.consequent, baseShouldWrapEffect);
+      let alternate = node.alternate ? lowerChild(node.alternate, baseShouldWrapEffect) : [];
       if (consequent.length === 0 && alternate.length === 0) return [];
-      const ifStmt = t2.ifStatement(
+      const buildIfStmt = (cons, alt) => t2.ifStatement(
         lowerExpressionWithDeSSA(node.test, ctx),
-        t2.blockStatement(consequent),
-        alternate.length > 0 ? t2.blockStatement(alternate) : null
+        t2.blockStatement(cons),
+        alt.length > 0 ? t2.blockStatement(alt) : null
       );
-      const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
+      let ifStmt = buildIfStmt(consequent, alternate);
+      const shouldWrapEffect = baseShouldWrapEffect && !statementHasEarlyExit(ifStmt, t2);
+      if (!shouldWrapEffect && baseShouldWrapEffect) {
+        consequent = lowerChild(node.consequent, false);
+        alternate = node.alternate ? lowerChild(node.alternate, false) : [];
+        if (consequent.length === 0 && alternate.length === 0) return [];
+        ifStmt = buildIfStmt(consequent, alternate);
+      }
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
         ctx.needsCtx = true;
@@ -18916,11 +18998,17 @@ function wrapInMemo(region, t2, declaredVars, ctx, bodyStatementsOverride, outpu
   if (uniqueOutputNames.length === 0) {
     ctx.helpersUsed.add("useEffect");
     ctx.needsCtx = true;
-    const effectCall = t2.callExpression(t2.identifier(RUNTIME_ALIASES.useEffect), [
+    const effectCallArgs = [
       t2.identifier("__fictCtx"),
-      t2.arrowFunctionExpression([], t2.blockStatement(bodyStatements)),
-      t2.numericLiteral(reserveHookSlot(ctx))
-    ]);
+      t2.arrowFunctionExpression([], t2.blockStatement(bodyStatements))
+    ];
+    {
+      const slot = reserveHookSlot(ctx);
+      if (slot >= 0) {
+        effectCallArgs.push(t2.numericLiteral(slot));
+      }
+    }
+    const effectCall = t2.callExpression(t2.identifier(RUNTIME_ALIASES.useEffect), effectCallArgs);
     statements.push(t2.expressionStatement(effectCall));
   } else {
     ctx.helpersUsed.add("useMemo");
@@ -18953,11 +19041,15 @@ function wrapInMemo(region, t2, declaredVars, ctx, bodyStatementsOverride, outpu
     };
     const returnObj = t2.objectExpression(uniqueOutputNames.map((name) => buildOutputProperty(name)));
     const memoBody = t2.blockStatement([...bodyStatements, t2.returnStatement(returnObj)]);
-    const memoCall = t2.callExpression(t2.identifier(RUNTIME_ALIASES.useMemo), [
+    const slot = reserveHookSlot(ctx);
+    const memoArgs = [
       t2.identifier("__fictCtx"),
-      t2.arrowFunctionExpression([], memoBody),
-      t2.numericLiteral(reserveHookSlot(ctx))
-    ]);
+      t2.arrowFunctionExpression([], memoBody)
+    ];
+    if (slot >= 0) {
+      memoArgs.push(t2.numericLiteral(slot));
+    }
+    const memoCall = t2.callExpression(t2.identifier(RUNTIME_ALIASES.useMemo), memoArgs);
     const regionVarName = `__region_${region.id}`;
     statements.push(
       t2.variableDeclaration("const", [t2.variableDeclarator(t2.identifier(regionVarName), memoCall)])
@@ -19014,7 +19106,10 @@ function wrapInMemo(region, t2, declaredVars, ctx, bodyStatementsOverride, outpu
           t2.callExpression(t2.identifier(RUNTIME_ALIASES.useEffect), [
             t2.identifier("__fictCtx"),
             t2.arrowFunctionExpression([], effectBody),
-            t2.numericLiteral(reserveHookSlot(ctx))
+            (() => {
+              const slot2 = reserveHookSlot(ctx);
+              return slot2 >= 0 ? t2.numericLiteral(slot2) : t2.identifier("undefined");
+            })()
           ])
         )
       );
@@ -19232,11 +19327,15 @@ function generateLazyConditionalMemo(region, orderedOutputs, bodyStatements, con
   ctx.helpersUsed.add("useMemo");
   ctx.needsCtx = true;
   const regionVarName = `__region_${region.id}`;
-  const memoCall = t2.callExpression(t2.identifier("__fictUseMemo"), [
+  const slotForMemo = reserveHookSlot(ctx);
+  const memoArgs = [
     t2.identifier("__fictCtx"),
-    t2.arrowFunctionExpression([], t2.blockStatement(memoBody)),
-    t2.numericLiteral(reserveHookSlot(ctx))
-  ]);
+    t2.arrowFunctionExpression([], t2.blockStatement(memoBody))
+  ];
+  if (slotForMemo >= 0) {
+    memoArgs.push(t2.numericLiteral(slotForMemo));
+  }
+  const memoCall = t2.callExpression(t2.identifier("__fictUseMemo"), memoArgs);
   statements.push(
     t2.variableDeclaration("const", [t2.variableDeclarator(t2.identifier(regionVarName), memoCall)])
   );
@@ -19258,6 +19357,9 @@ function generateLazyConditionalMemo(region, orderedOutputs, bodyStatements, con
   return statements;
 }
 function reserveHookSlot(ctx) {
+  if (ctx.dynamicHookSlotDepth && ctx.dynamicHookSlotDepth > 0) {
+    return -1;
+  }
   const slot = ctx.nextHookSlot ?? 0;
   ctx.nextHookSlot = slot + 1;
   return slot;
@@ -19328,7 +19430,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
         t2.arrowFunctionExpression([], expr)
       ];
       if (inRegionMemo) {
-        args.push(t2.numericLiteral(reserveHookSlot(ctx)));
+        const slot = reserveHookSlot(ctx);
+        if (slot >= 0) {
+          args.push(t2.numericLiteral(slot));
+        }
       }
       ctx.helpersUsed.add("useMemo");
       ctx.needsCtx = true;
@@ -19528,7 +19633,8 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       (dep) => ctx.trackedVars.has(deSSAVarName(dep))
     );
     const usesTracked = expressionUsesTracked(instr.value, ctx);
-    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && (usesTracked || hasTrackedControlDep);
+    const inNonReactiveScope = !!(ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0);
+    const shouldWrapExpr = ctx.wrapTrackedExpressions !== false && !inNonReactiveScope && (usesTracked || hasTrackedControlDep);
     if (shouldWrapExpr) {
       ctx.helpersUsed.add("useEffect");
       ctx.needsCtx = true;
@@ -19843,6 +19949,17 @@ function deSSAJSXChild(child, t2) {
 // src/ir/codegen.ts
 var HOOK_SLOT_BASE = 1e3;
 var HOOK_NAME_PREFIX = "use";
+var cloneLoc = (loc) => loc === void 0 ? void 0 : loc === null ? null : {
+  start: { ...loc.start },
+  end: { ...loc.end },
+  filename: loc.filename,
+  identifierName: loc.identifierName
+};
+function setNodeLoc(node, loc) {
+  if (loc === void 0) return node;
+  node.loc = cloneLoc(loc) ?? null;
+  return node;
+}
 function isHookName(name) {
   return !!name && name.startsWith(HOOK_NAME_PREFIX);
 }
@@ -19876,13 +19993,22 @@ function applyRegionToContext(ctx, region) {
   return prevRegion;
 }
 function reserveHookSlot2(ctx) {
+  if (ctx.dynamicHookSlotDepth && ctx.dynamicHookSlotDepth > 0) {
+    return -1;
+  }
   const slot = ctx.nextHookSlot ?? HOOK_SLOT_BASE;
   ctx.nextHookSlot = slot + 1;
   return slot;
 }
 function expressionContainsJSX(expr) {
+  if (Array.isArray(expr)) {
+    return expr.some((item) => expressionContainsJSX(item));
+  }
   if (!expr || typeof expr !== "object") return false;
   if (expr.kind === "JSXElement") return true;
+  if (Array.isArray(expr.instructions)) {
+    return expr.instructions.some((i) => expressionContainsJSX(i?.value ?? i));
+  }
   switch (expr.kind) {
     case "CallExpression":
       if (expressionContainsJSX(expr.callee)) return true;
@@ -19895,10 +20021,29 @@ function expressionContainsJSX(expr) {
       return expressionContainsJSX(expr.test) || expressionContainsJSX(expr.consequent) || expressionContainsJSX(expr.alternate);
     case "ArrowFunction":
       return expressionContainsJSX(expr.body);
+    case "FunctionExpression":
+      if (Array.isArray(expr.body)) {
+        return expr.body.some(
+          (block) => block.instructions?.some((i) => expressionContainsJSX(i.value))
+        );
+      }
+      return false;
     default:
       return false;
   }
 }
+function withNoMemoAndDynamicHooks(ctx, fn) {
+  const prevNoMemo = ctx.noMemo;
+  const prevDynamic = ctx.dynamicHookSlotDepth ?? 0;
+  ctx.noMemo = true;
+  ctx.dynamicHookSlotDepth = prevDynamic + 1;
+  try {
+    return fn();
+  } finally {
+    ctx.noMemo = prevNoMemo;
+    ctx.dynamicHookSlotDepth = prevDynamic;
+  }
+}
 function functionContainsJSX(fn) {
   for (const block of fn.blocks) {
     for (const instr of block.instructions) {
@@ -20997,18 +21142,25 @@ function lowerTrackedExpression(expr, ctx) {
 }
 function lowerInstruction(instr, ctx) {
   const { t: t2 } = ctx;
+  const applyLoc = (stmt) => {
+    if (!stmt) return stmt;
+    const baseLoc = instr.loc ?? (instr.kind === "Assign" || instr.kind === "Expression" ? instr.value.loc : void 0);
+    return setNodeLoc(stmt, baseLoc);
+  };
   if (instr.kind === "Assign") {
     const baseName2 = deSSAVarName(instr.target.name);
     const isFunctionDecl = instr.value.kind === "FunctionExpression" && (instr.declarationKind === "function" || !instr.declarationKind && instr.value.name === baseName2);
     if (isFunctionDecl) {
       const loweredFn = lowerExpression(instr.value, ctx);
       if (t2.isFunctionExpression(loweredFn)) {
-        return t2.functionDeclaration(
-          t2.identifier(baseName2),
-          loweredFn.params,
-          loweredFn.body,
-          loweredFn.generator ?? false,
-          loweredFn.async ?? false
+        return applyLoc(
+          t2.functionDeclaration(
+            t2.identifier(baseName2),
+            loweredFn.params,
+            loweredFn.body,
+            loweredFn.generator ?? false,
+            loweredFn.async ?? false
+          )
         );
       }
     }
@@ -21023,12 +21175,16 @@ function lowerInstruction(instr, ctx) {
         ctx.memoVars?.add(baseName2);
       }
       if (declKind) {
-        return t2.variableDeclaration(declKind, [
-          t2.variableDeclarator(t2.identifier(baseName2), hookMember.member)
-        ]);
+        return applyLoc(
+          t2.variableDeclaration(declKind, [
+            t2.variableDeclarator(t2.identifier(baseName2), hookMember.member)
+          ])
+        );
       }
-      return t2.expressionStatement(
-        t2.assignmentExpression("=", t2.identifier(baseName2), hookMember.member)
+      return applyLoc(
+        t2.expressionStatement(
+          t2.assignmentExpression("=", t2.identifier(baseName2), hookMember.member)
+        )
       );
     }
     if (instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && isHookName(instr.value.callee.name)) {
@@ -21042,16 +21198,24 @@ function lowerInstruction(instr, ctx) {
       }
     }
     if (ctx.signalVars?.has(baseName2)) {
-      return t2.expressionStatement(
-        t2.callExpression(t2.identifier(baseName2), [lowerTrackedExpression(instr.value, ctx)])
+      return applyLoc(
+        t2.expressionStatement(
+          t2.callExpression(t2.identifier(baseName2), [lowerTrackedExpression(instr.value, ctx)])
+        )
       );
     }
-    return t2.expressionStatement(
-      t2.assignmentExpression("=", t2.identifier(baseName2), lowerTrackedExpression(instr.value, ctx))
+    return applyLoc(
+      t2.expressionStatement(
+        t2.assignmentExpression(
+          "=",
+          t2.identifier(baseName2),
+          lowerTrackedExpression(instr.value, ctx)
+        )
+      )
     );
   }
   if (instr.kind === "Expression") {
-    return t2.expressionStatement(lowerTrackedExpression(instr.value, ctx));
+    return applyLoc(t2.expressionStatement(lowerTrackedExpression(instr.value, ctx)));
   }
   if (instr.kind === "Phi") {
     return null;
@@ -21060,6 +21224,9 @@ function lowerInstruction(instr, ctx) {
 }
 function lowerTerminator(block, ctx) {
   const { t: t2 } = ctx;
+  const baseLoc = block.terminator.loc ?? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  block.terminator.argument?.loc;
+  const applyLoc = (stmts) => stmts.map((stmt) => setNodeLoc(stmt, baseLoc));
   switch (block.terminator.kind) {
     case "Return": {
       const prevRegion = ctx.currentRegion;
@@ -21072,14 +21239,14 @@ function lowerTerminator(block, ctx) {
       }
       ctx.inReturn = false;
       ctx.currentRegion = prevRegion;
-      return [t2.returnStatement(retExpr)];
+      return applyLoc([t2.returnStatement(retExpr)]);
     }
     case "Throw":
-      return [t2.throwStatement(lowerTrackedExpression(block.terminator.argument, ctx))];
+      return applyLoc([t2.throwStatement(lowerTrackedExpression(block.terminator.argument, ctx))]);
     case "Jump":
-      return [t2.expressionStatement(t2.stringLiteral(`jump ${block.terminator.target}`))];
+      return applyLoc([t2.expressionStatement(t2.stringLiteral(`jump ${block.terminator.target}`))]);
     case "Branch":
-      return [
+      return applyLoc([
         t2.ifStatement(
           lowerTrackedExpression(block.terminator.test, ctx),
           t2.blockStatement([
@@ -21089,9 +21256,9 @@ function lowerTerminator(block, ctx) {
             t2.expressionStatement(t2.stringLiteral(`goto ${block.terminator.alternate}`))
           ])
         )
-      ];
+      ]);
     case "Switch":
-      return [
+      return applyLoc([
         t2.switchStatement(
           lowerTrackedExpression(block.terminator.discriminant, ctx),
           block.terminator.cases.map(
@@ -21100,30 +21267,30 @@ function lowerTerminator(block, ctx) {
             ])
           )
         )
-      ];
+      ]);
     case "ForOf": {
       const term = block.terminator;
       const varKind = term.variableKind ?? "const";
       const leftPattern = term.pattern ? term.pattern : t2.identifier(term.variable);
-      return [
+      return applyLoc([
         t2.forOfStatement(
           t2.variableDeclaration(varKind, [t2.variableDeclarator(leftPattern)]),
           lowerExpression(term.iterable, ctx),
           t2.blockStatement([t2.expressionStatement(t2.stringLiteral(`body ${term.body}`))])
         )
-      ];
+      ]);
     }
     case "ForIn": {
       const term = block.terminator;
       const varKind = term.variableKind ?? "const";
       const leftPattern = term.pattern ? term.pattern : t2.identifier(term.variable);
-      return [
+      return applyLoc([
         t2.forInStatement(
           t2.variableDeclaration(varKind, [t2.variableDeclarator(leftPattern)]),
           lowerExpression(term.object, ctx),
           t2.blockStatement([t2.expressionStatement(t2.stringLiteral(`body ${term.body}`))])
         )
-      ];
+      ]);
     }
     case "Try": {
       const term = block.terminator;
@@ -21139,20 +21306,20 @@ function lowerTerminator(block, ctx) {
       const finallyBlock = term.finallyBlock !== void 0 ? t2.blockStatement([
         t2.expressionStatement(t2.stringLiteral(`finally ${term.finallyBlock}`))
       ]) : null;
-      return [t2.tryStatement(tryBlock, catchClause, finallyBlock)];
+      return applyLoc([t2.tryStatement(tryBlock, catchClause, finallyBlock)]);
     }
     case "Unreachable":
-      return [];
+      return applyLoc([]);
     case "Break":
-      return [
+      return applyLoc([
         t2.breakStatement(block.terminator.label ? t2.identifier(block.terminator.label) : null)
-      ];
+      ]);
     case "Continue":
-      return [
+      return applyLoc([
         t2.continueStatement(block.terminator.label ? t2.identifier(block.terminator.label) : null)
-      ];
+      ]);
     default:
-      return [];
+      return applyLoc([]);
   }
 }
 function attachHelperImports(ctx, body, t2) {
@@ -21291,12 +21458,12 @@ function lowerExpression(expr, ctx, isAssigned = false) {
   }
   ctx.expressionDepth = depth;
   try {
-    return lowerExpressionImpl(expr, ctx, isAssigned);
+    return setNodeLoc(lowerExpressionImpl(expr, ctx, isAssigned), expr.loc);
   } finally {
     ctx.expressionDepth = depth - 1;
   }
 }
-function lowerExpressionImpl(expr, ctx, isAssigned = false) {
+function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
   const { t: t2 } = ctx;
   const mapParams = (params) => params.map((p) => t2.identifier(deSSAVarName(p.name)));
   const withFunctionScope = (paramNames, fn) => {
@@ -21358,11 +21525,7 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
       };
       const declared = new Set(paramIds.map((p) => p.name));
       return lowerStructuredNodeWithoutRegions(structured, t2, ctx, declared);
-    } catch (e) {
-      console.log(
-        "[DEBUG] Structurization failed, falling back to lowerBlocksToStatements via lowerInstruction",
-        e
-      );
+    } catch {
       return lowerBlocksToStatements(blocks);
     }
   };
@@ -21426,14 +21589,22 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
       const calleeIsMemoAccessor = !!calleeName && ctx.memoVars?.has(calleeName);
       const calleeIsSignalLike = !!calleeName && (ctx.signalVars?.has(calleeName) || ctx.storeVars?.has(calleeName));
       if (calleeIsMemoAccessor && !calleeIsSignalLike && expr.arguments.length > 0) {
-        const loweredArgs = expr.arguments.map((a) => lowerExpression(a, ctx));
-        return t2.callExpression(t2.callExpression(t2.identifier(calleeName), []), loweredArgs);
+        const loweredArgs2 = expr.arguments.map((a) => lowerExpression(a, ctx));
+        return t2.callExpression(t2.callExpression(t2.identifier(calleeName), []), loweredArgs2);
       }
       const lowerCallee = () => isIIFE ? withNonReactiveScope(ctx, () => lowerExpression(expr.callee, ctx)) : lowerExpression(expr.callee, ctx);
-      return t2.callExpression(
-        lowerCallee(),
-        expr.arguments.map((a) => lowerExpression(a, ctx))
-      );
+      const isIteratingMethod = expr.callee.kind === "MemberExpression" && (expr.callee.property.kind === "Identifier" && ["map", "reduce", "forEach", "filter", "flatMap", "some", "every", "find"].includes(
+        expr.callee.property.name
+      ) || expr.callee.property.kind === "Literal" && ["map", "reduce", "forEach", "filter", "flatMap", "some", "every", "find"].includes(
+        String(expr.callee.property.value)
+      ));
+      const loweredArgs = expr.arguments.map((a, idx) => {
+        if (idx === 0 && isIteratingMethod && (a.kind === "ArrowFunction" || a.kind === "FunctionExpression")) {
+          return withNoMemoAndDynamicHooks(ctx, () => lowerExpression(a, ctx));
+        }
+        return lowerExpression(a, ctx);
+      });
+      return t2.callExpression(lowerCallee(), loweredArgs);
     }
     case "MemberExpression":
       if (matchesListKeyPattern(expr, ctx)) {
@@ -21533,12 +21704,10 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
     case "ArrowFunction": {
       const paramIds = mapParams(expr.params);
       const shadowed = new Set(expr.params.map((p) => deSSAVarName(p.name)));
-      return withFunctionScope(shadowed, () => {
-        if (isAssigned) {
-          ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) + 1;
-        }
-        let fn;
-        try {
+      return withNonReactiveScope(
+        ctx,
+        () => withFunctionScope(shadowed, () => {
+          let fn;
           if (expr.isExpression && !Array.isArray(expr.body)) {
             const { result: bodyExpr, cacheDeclarations } = withGetterCache(
               ctx,
@@ -21566,12 +21735,8 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
           }
           fn.async = expr.isAsync ?? false;
           return fn;
-        } finally {
-          if (isAssigned) {
-            ctx.nonReactiveScopeDepth = (ctx.nonReactiveScopeDepth ?? 0) - 1;
-          }
-        }
-      });
+        })
+      );
     }
     case "FunctionExpression": {
       const paramIds = mapParams(expr.params);
@@ -22290,15 +22455,6 @@ function isStaticValue(expr) {
   if (!expr) return false;
   return expr.kind === "Literal";
 }
-function isComponentLikeCallee(expr) {
-  if (expr.kind === "Identifier") {
-    return expr.name[0] === expr.name[0]?.toUpperCase();
-  }
-  if (expr.kind === "MemberExpression" || expr.kind === "OptionalMemberExpression") {
-    return isComponentLikeCallee(expr.object);
-  }
-  return false;
-}
 function isLikelyTextExpression(expr, ctx) {
   let ok = true;
   const isReactiveIdentifier = (name) => {
@@ -22327,15 +22483,9 @@ function isLikelyTextExpression(expr, ctx) {
         ok = false;
         return;
       case "CallExpression":
-      case "OptionalCallExpression": {
-        if (isComponentLikeCallee(node.callee)) {
-          ok = false;
-          return;
-        }
-        visit(node.callee, true);
-        node.arguments.forEach((arg) => visit(arg));
+      case "OptionalCallExpression":
+        ok = false;
         return;
-      }
       case "MemberExpression":
       case "OptionalMemberExpression":
         visit(node.object, true);
@@ -22767,16 +22917,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         t2.expressionStatement(lowerDomExpression(binding.expr, ctx, containingRegion))
       );
     } else if (binding.type === "text" && binding.expr) {
-      ctx.helpersUsed.add("bindText");
       const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
-      statements.push(
-        t2.expressionStatement(
-          t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
-            targetId,
-            t2.arrowFunctionExpression([], valueExpr)
-          ])
-        )
-      );
+      if (isExpressionReactive(binding.expr, ctx)) {
+        ctx.helpersUsed.add("bindText");
+        statements.push(
+          t2.expressionStatement(
+            t2.callExpression(t2.identifier(RUNTIME_ALIASES.bindText), [
+              targetId,
+              t2.arrowFunctionExpression([], valueExpr)
+            ])
+          )
+        );
+      } else {
+        statements.push(
+          t2.expressionStatement(
+            t2.assignmentExpression(
+              "=",
+              t2.memberExpression(targetId, t2.identifier("data")),
+              t2.callExpression(t2.identifier("String"), [valueExpr])
+            )
+          )
+        );
+      }
     } else if (binding.type === "child" && binding.expr) {
       emitHIRChildBinding(targetId, binding.expr, statements, ctx, containingRegion);
     }
@@ -22790,7 +22952,12 @@ function lowerIntrinsicElement(jsx, ctx) {
       t2.arrowFunctionExpression([], body)
     ];
     if (ctx.isComponentFn) {
-      memoArgs.push(t2.numericLiteral(reserveHookSlot2(ctx)));
+      {
+        const slot = reserveHookSlot2(ctx);
+        if (slot >= 0) {
+          memoArgs.push(t2.numericLiteral(slot));
+        }
+      }
     }
     return t2.callExpression(t2.callExpression(t2.identifier(RUNTIME_ALIASES.useMemo), memoArgs), []);
   }
@@ -23085,8 +23252,13 @@ function getTrackedCallIdentifier(expr, ctx, itemParamName) {
   }
   return null;
 }
-function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
+function rewriteSelectorExpression(expr, itemParamName, keyParamName, getSelectorId, ctx) {
   const { t: t2 } = ctx;
+  const usesParamIdentifier = (e) => {
+    if (expressionUsesIdentifier(e, itemParamName, t2)) return true;
+    if (keyParamName && expressionUsesIdentifier(e, keyParamName, t2)) return true;
+    return false;
+  };
   if (t2.isBinaryExpression(expr) && (expr.operator === "===" || expr.operator === "==")) {
     const leftTracked = getTrackedCallIdentifier(
       expr.left,
@@ -23098,7 +23270,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
       ctx,
       itemParamName
     );
-    if (leftTracked && expressionUsesIdentifier(expr.right, itemParamName, t2)) {
+    if (leftTracked && usesParamIdentifier(expr.right)) {
       return {
         expr: t2.callExpression(getSelectorId(leftTracked), [
           expr.right
@@ -23106,7 +23278,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
         changed: true
       };
     }
-    if (rightTracked && expressionUsesIdentifier(expr.left, itemParamName, t2)) {
+    if (rightTracked && usesParamIdentifier(expr.left)) {
       return {
         expr: t2.callExpression(getSelectorId(rightTracked), [
           expr.left
@@ -23117,7 +23289,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   let changed = false;
   const rewrite = (node) => {
-    const result = rewriteSelectorExpression(node, itemParamName, getSelectorId, ctx);
+    const result = rewriteSelectorExpression(node, itemParamName, keyParamName, getSelectorId, ctx);
     if (result.changed) changed = true;
     return result.expr;
   };
@@ -23178,7 +23350,7 @@ function rewriteSelectorExpression(expr, itemParamName, getSelectorId, ctx) {
   }
   return { expr, changed };
 }
-function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
+function applySelectorHoist(callbackExpr, itemParamName, keyParamName, statements, ctx) {
   const { t: t2 } = ctx;
   if (!itemParamName) return;
   if (!t2.isArrowFunctionExpression(callbackExpr) && !t2.isFunctionExpression(callbackExpr)) return;
@@ -23194,7 +23366,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
     if (t2.isBlockStatement(fn.body)) {
       for (const stmt of fn.body.body) {
         if (t2.isReturnStatement(stmt) && stmt.argument && t2.isExpression(stmt.argument)) {
-          const result = rewriteSelectorExpression(stmt.argument, itemParamName, getSelectorId, ctx);
+          const result = rewriteSelectorExpression(
+            stmt.argument,
+            itemParamName,
+            keyParamName,
+            getSelectorId,
+            ctx
+          );
           if (result.changed) {
             stmt.argument = result.expr;
           }
@@ -23203,7 +23381,13 @@ function applySelectorHoist(callbackExpr, itemParamName, statements, ctx) {
       return;
     }
     if (t2.isExpression(fn.body)) {
-      const result = rewriteSelectorExpression(fn.body, itemParamName, getSelectorId, ctx);
+      const result = rewriteSelectorExpression(
+        fn.body,
+        itemParamName,
+        keyParamName,
+        getSelectorId,
+        ctx
+      );
       if (result.changed) {
         fn.body = result.expr;
       }
@@ -23345,12 +23529,16 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
   const hoistedStatements = ctx.hoistedTemplateStatements;
   ctx.hoistedTemplates = prevHoistedTemplates;
   ctx.hoistedTemplateStatements = prevHoistedTemplateStatements;
-  if (isKeyed && (t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr))) {
-    const firstParam = callbackExpr.params[0];
+  if (t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr)) {
+    const [firstParam, secondParam] = callbackExpr.params;
+    const overrides = {};
     if (t2.isIdentifier(firstParam)) {
-      const overrides = {
-        [firstParam.name]: () => t2.callExpression(t2.identifier(firstParam.name), [])
-      };
+      overrides[firstParam.name] = () => t2.callExpression(t2.identifier(firstParam.name), []);
+    }
+    if (t2.isIdentifier(secondParam)) {
+      overrides[secondParam.name] = () => t2.callExpression(t2.identifier(secondParam.name), []);
+    }
+    if (Object.keys(overrides).length > 0) {
       if (t2.isBlockStatement(callbackExpr.body)) {
         replaceIdentifiersWithOverrides(callbackExpr.body, overrides, t2, callbackExpr.type, "body");
       } else {
@@ -23363,7 +23551,14 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
   const listId = genTemp(ctx, "list");
   if (isKeyed) {
     const itemParamName = t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr) ? t2.isIdentifier(callbackExpr.params[0]) ? callbackExpr.params[0].name : null : null;
-    applySelectorHoist(callbackExpr, itemParamName, statements, ctx);
+    const keyParamName = ctx.listKeyParamName ?? null;
+    applySelectorHoist(
+      callbackExpr,
+      itemParamName,
+      keyParamName,
+      statements,
+      ctx
+    );
   }
   if (isKeyed && keyExpr) {
     let keyExprAst = lowerExpression(keyExpr, ctx);
@@ -24244,10 +24439,9 @@ function lowerFunctionWithRegions(fn, ctx) {
     }
   }
   const params = finalParams;
-  const funcDecl = t2.functionDeclaration(
-    t2.identifier(fn.name ?? "fn"),
-    params,
-    t2.blockStatement(statements)
+  const funcDecl = setNodeLoc(
+    t2.functionDeclaration(t2.identifier(fn.name ?? "fn"), params, t2.blockStatement(statements)),
+    fn.loc
   );
   ctx.needsCtx = prevNeedsCtx;
   ctx.shadowedNames = prevShadowed;
@@ -24336,10 +24530,44 @@ function isInsideNestedFunction(path) {
 function isInsideJSX(path) {
   return !!path.findParent((p) => p.isJSXElement?.() || p.isJSXFragment?.());
 }
-function emitWarning(node, code, message, options, fileName) {
-  if (!options.onWarn) return;
+function parseSuppressionCodes(raw) {
+  if (!raw) return void 0;
+  const codes = raw.split(/[,\s]+/).map((c) => c.trim()).filter(Boolean);
+  return codes.length > 0 ? new Set(codes) : void 0;
+}
+function parseSuppressions(comments) {
+  if (!comments) return [];
+  const suppressions = [];
+  for (const comment of comments) {
+    const match = comment.value.match(/fict-ignore(-next-line)?(?:\s+(.+))?/i);
+    if (!match || !comment.loc) continue;
+    suppressions.push({
+      line: comment.loc.start.line,
+      nextLine: !!match[1],
+      codes: parseSuppressionCodes(match[2])
+    });
+  }
+  return suppressions;
+}
+function shouldSuppressWarning(suppressions, code, line) {
+  return suppressions.some((entry) => {
+    const targetLine = entry.nextLine ? entry.line + 1 : entry.line;
+    if (targetLine !== line) return false;
+    if (!entry.codes || entry.codes.size === 0) return true;
+    return entry.codes.has(code);
+  });
+}
+function createWarningDispatcher(onWarn, suppressions) {
+  if (!onWarn) return () => {
+  };
+  return (warning) => {
+    if (shouldSuppressWarning(suppressions, warning.code, warning.line)) return;
+    onWarn(warning);
+  };
+}
+function emitWarning(node, code, message, warn, fileName) {
   const loc = node.loc?.start;
-  options.onWarn({
+  warn({
     code,
     message,
     fileName,
@@ -24427,8 +24655,7 @@ function isDynamicPropertyAccess(node, t2) {
   if (!node.computed) return false;
   return !(t2.isStringLiteral(node.property) || t2.isNumericLiteral(node.property));
 }
-function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
-  const fileName = programPath.hub?.file?.opts?.filename || "<unknown>";
+function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t2) {
   const isStateRoot = (expr) => {
     const root = getRootIdentifier(expr, t2);
     return !!(root && stateVars.has(root.name));
@@ -24444,7 +24671,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
             path.node,
             "FICT-M",
             "Direct mutation of nested property detected; use immutable update or $store helpers",
-            options,
+            warn,
             fileName
           );
           if (isDynamicPropertyAccess(left, t2)) {
@@ -24452,7 +24679,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
               path.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
-              options,
+              warn,
               fileName
             );
           }
@@ -24467,7 +24694,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
             path.node,
             "FICT-M",
             "Direct mutation of nested property detected; use immutable update or $store helpers",
-            options,
+            warn,
             fileName
           );
           if (isDynamicPropertyAccess(arg, t2)) {
@@ -24475,7 +24702,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
               path.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
-              options,
+              warn,
               fileName
             );
           }
@@ -24491,7 +24718,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
           path.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
-          options,
+          warn,
           fileName
         );
       }
@@ -24520,7 +24747,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
           path.node,
           "FICT-R005",
           `Function captures reactive variable(s): ${Array.from(captured).join(", ")}. Pass them as parameters or memoize explicitly to avoid hidden dependencies.`,
-          options,
+          warn,
           fileName
         );
       }
@@ -24551,7 +24778,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
               path.node,
               "FICT-E001",
               "Effect has no reactive reads; it will run once. Consider removing $effect or adding dependencies.",
-              options,
+              warn,
               fileName
             );
           }
@@ -24577,7 +24804,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
             arg,
             "FICT-H",
             "State value passed to unknown function (black box); dependency tracking may be imprecise",
-            options,
+            warn,
             fileName
           );
           break;
@@ -24593,7 +24820,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
           path.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
-          options,
+          warn,
           fileName
         );
       }
@@ -24643,6 +24870,10 @@ function createHIREntrypointVisitor(t2, options) {
     Program: {
       exit(path) {
         const fileName = path.hub?.file?.opts?.filename || "<unknown>";
+        const comments = path.hub?.file?.ast?.comments || [];
+        const suppressions = parseSuppressions(comments);
+        const warn = createWarningDispatcher(options.onWarn, suppressions);
+        const optionsWithWarnings = { ...options, onWarn: warn };
         const isHookName2 = (name) => !!name && /^use[A-Z]/.test(name);
         const getFunctionName = (fnPath) => {
           return fnPath.isFunctionDeclaration() && fnPath.node.id ? fnPath.node.id.name : fnPath.isFunctionExpression() && fnPath.node.id ? fnPath.node.id.name : fnPath.parentPath.isVariableDeclarator() && t2.isIdentifier(fnPath.parentPath.node.id) && fnPath.parentPath.node.init === fnPath.node ? fnPath.parentPath.node.id.name : void 0;
@@ -24661,14 +24892,75 @@ function createHIREntrypointVisitor(t2, options) {
           return name && isComponentName(name) || isHookName2(name) || functionHasJSX(fnPath) || functionUsesStateLike(fnPath, t2);
         };
         const memoHasSideEffects = (fn) => {
+          const pureCalls = new Set(
+            Array.from(SAFE_FUNCTIONS).filter(
+              (name) => !name.startsWith("console.") && name !== "Math.random"
+            )
+          );
+          const effectfulCalls = /* @__PURE__ */ new Set([
+            "$effect",
+            "render",
+            "fetch",
+            "setTimeout",
+            "setInterval",
+            "clearTimeout",
+            "clearInterval",
+            "requestAnimationFrame",
+            "cancelAnimationFrame"
+          ]);
+          const getCalleeName = (callee) => {
+            if (t2.isIdentifier(callee)) return callee.name;
+            if (t2.isMemberExpression(callee) && !callee.computed && t2.isIdentifier(callee.property) && t2.isIdentifier(callee.object)) {
+              return `${callee.object.name}.${callee.property.name}`;
+            }
+            return null;
+          };
+          const mutatingMemberProps = /* @__PURE__ */ new Set([
+            "push",
+            "pop",
+            "splice",
+            "shift",
+            "unshift",
+            "sort",
+            "reverse",
+            "set",
+            "add",
+            "delete",
+            "append",
+            "appendChild",
+            "remove",
+            "removeChild",
+            "setAttribute",
+            "dispatchEvent",
+            "replaceChildren",
+            "replaceWith"
+          ]);
+          const isEffectfulCall = (node) => {
+            const name = getCalleeName(node.callee);
+            if (!name) return true;
+            if (pureCalls.has(name)) return false;
+            if (effectfulCalls.has(name)) return true;
+            if (name.startsWith("console.") || name.startsWith("document.") || name.startsWith("window.")) {
+              return true;
+            }
+            if (t2.isMemberExpression(node.callee) && !node.callee.computed && t2.isIdentifier(node.callee.property)) {
+              const prop = node.callee.property.name;
+              if (mutatingMemberProps.has(prop)) return true;
+              if (t2.isIdentifier(node.callee.object) && (node.callee.object.name === "document" || node.callee.object.name === "window")) {
+                return true;
+              }
+            }
+            return false;
+          };
           const checkNode = (node) => {
             if (!node) return false;
             if (t2.isAssignmentExpression(node) || t2.isUpdateExpression(node) || t2.isThrowStatement(node) || t2.isNewExpression(node)) {
               return true;
             }
-            if (t2.isCallExpression(node) && (t2.isIdentifier(node.callee) && node.callee.name === "$effect" || t2.isIdentifier(node.callee) && node.callee.name === "render")) {
+            if (t2.isCallExpression(node) && isEffectfulCall(node)) {
               return true;
             }
+            if (t2.isAwaitExpression(node)) return true;
             if (t2.isExpressionStatement(node)) return checkNode(node.expression);
             if (t2.isBlockStatement(node)) return node.body.some((stmt) => checkNode(stmt));
             if (t2.isReturnStatement(node)) return checkNode(node.argument);
@@ -24692,7 +24984,7 @@ function createHIREntrypointVisitor(t2, options) {
               fnPath.node,
               "FICT-C004",
               "Component has no return statement and will render nothing.",
-              options,
+              warn,
               fileName
             );
           },
@@ -24710,7 +25002,7 @@ function createHIREntrypointVisitor(t2, options) {
               init,
               "FICT-C004",
               "Component has no return statement and will render nothing.",
-              options,
+              warn,
               fileName
             );
           }
@@ -24760,7 +25052,7 @@ function createHIREntrypointVisitor(t2, options) {
               }
             }
             if (hasKey || hasUnknownSpread) return;
-            options.onWarn?.({
+            warn({
               code: "FICT-J002",
               message: "Missing key prop in list rendering.",
               fileName,
@@ -24831,7 +25123,7 @@ function createHIREntrypointVisitor(t2, options) {
               fnPath.node,
               "FICT-C003",
               "Components should not be defined inside other components. Move this definition to module scope to preserve identity and performance.",
-              options,
+              warn,
               fileName
             );
           },
@@ -24876,7 +25168,7 @@ function createHIREntrypointVisitor(t2, options) {
                 callPath.node,
                 "FICT-R004",
                 "Reactive creation inside non-JSX control flow will not auto-dispose; wrap it in createScope/runInScope or move it into JSX-managed regions.",
-                options,
+                warn,
                 fileName
               );
             }
@@ -24911,7 +25203,7 @@ function createHIREntrypointVisitor(t2, options) {
             callPath.node.arguments.forEach((arg) => {
               if (t2.isIdentifier(arg) && stateVars.has(arg.name) && (!calleeId || !allowedStateCallees.has(calleeId))) {
                 const loc = arg.loc?.start ?? callPath.node.loc?.start;
-                options.onWarn?.({
+                warn({
                   code: "FICT-S002",
                   message: "State variable is passed as an argument; this passes a value snapshot and may escape component scope.",
                   fileName,
@@ -24924,7 +25216,7 @@ function createHIREntrypointVisitor(t2, options) {
               const firstArg = callPath.node.arguments[0];
               if (firstArg && (t2.isArrowFunctionExpression(firstArg) || t2.isFunctionExpression(firstArg)) && memoHasSideEffects(firstArg)) {
                 const loc = firstArg.loc?.start ?? callPath.node.loc?.start;
-                options.onWarn?.({
+                warn({
                   code: "FICT-M003",
                   message: "Memo should not contain side effects.",
                   fileName,
@@ -25029,10 +25321,10 @@ function createHIREntrypointVisitor(t2, options) {
             }
           });
         }
-        runWarningPass(path, stateVars, derivedVars, options, t2);
+        runWarningPass(path, stateVars, derivedVars, warn, fileName, t2);
         const fileAst = t2.file(path.node);
         const hir = buildHIR(fileAst);
-        const lowered = lowerHIRWithRegions(hir, t2, options);
+        const lowered = lowerHIRWithRegions(hir, t2, optionsWithWarnings);
         path.node.body = lowered.program.body;
         path.node.directives = lowered.program.directives;
         if (!process.env.FICT_SKIP_SCOPE_CRAWL) {