@fictjs/compiler 0.0.3 → 0.0.5

package/dist/index.js

@@ -14128,6 +14128,7 @@ var RUNTIME_HELPERS = {
   propsRest: "__fictPropsRest",
   mergeProps: "mergeProps",
   useProp: "useProp",
+  runInScope: "runInScope",
   createElement: "createElement",
   conditional: "createConditional",
   list: "createList",
@@ -14140,6 +14141,7 @@ var RUNTIME_HELPERS = {
   bindClass: "bindClass",
   bindStyle: "bindStyle",
   bindEvent: "bindEvent",
+  callEventHandler: "callEventHandler",
   bindRef: "bindRef",
   toNodeArray: "toNodeArray",
   createKeyedListContainer: "createKeyedListContainer",
@@ -14167,6 +14169,7 @@ var RUNTIME_ALIASES = {
   propsRest: "__fictPropsRest",
   useProp: "useProp",
   mergeProps: "mergeProps",
+  runInScope: "runInScope",
   createElement: "createElement",
   conditional: "createConditional",
   list: "createList",
@@ -14179,6 +14182,7 @@ var RUNTIME_ALIASES = {
   bindClass: "bindClass",
   bindStyle: "bindStyle",
   bindEvent: "bindEvent",
+  callEventHandler: "callEventHandler",
   bindRef: "bindRef",
   toNodeArray: "toNodeArray",
   createKeyedListContainer: "createKeyedListContainer",
@@ -15204,7 +15208,8 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     push({
       kind: "Assign",
       target: { kind: "Identifier", name: stmt.id.name },
-      value: convertExpression(fnExpr)
+      value: convertExpression(fnExpr),
+      declarationKind: "function"
     });
     return bb;
   }
@@ -17693,6 +17698,110 @@ function structurizeTry(ctx, block, term) {
 }
 
 // src/ir/regions.ts
+var REACTIVE_CREATORS = /* @__PURE__ */ new Set(["createEffect", "createMemo", "createSelector"]);
+function expressionCreatesReactive(expr) {
+  if (expr.kind === "CallExpression" && expr.callee.kind === "Identifier") {
+    const base = getSSABaseName(expr.callee.name);
+    return REACTIVE_CREATORS.has(base);
+  }
+  return false;
+}
+function expressionContainsReactiveCreation(expr) {
+  if (expressionCreatesReactive(expr)) return true;
+  switch (expr.kind) {
+    case "CallExpression":
+      return expressionContainsReactiveCreation(expr.callee) || expr.arguments.some((arg) => expressionContainsReactiveCreation(arg));
+    case "MemberExpression":
+      return expressionContainsReactiveCreation(expr.object) || expressionContainsReactiveCreation(expr.property);
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return expressionContainsReactiveCreation(expr.left) || expressionContainsReactiveCreation(expr.right);
+    case "UnaryExpression":
+      return expressionContainsReactiveCreation(expr.argument);
+    case "ConditionalExpression":
+      return expressionContainsReactiveCreation(expr.test) || expressionContainsReactiveCreation(expr.consequent) || expressionContainsReactiveCreation(expr.alternate);
+    case "ArrayExpression":
+      return expr.elements.some((el) => el && expressionContainsReactiveCreation(el));
+    case "ObjectExpression":
+      return expr.properties.some(
+        (prop) => prop.kind === "SpreadElement" ? expressionContainsReactiveCreation(prop.argument) : expressionContainsReactiveCreation(prop.value)
+      );
+    case "ArrowFunction":
+      if (expr.isExpression) {
+        return expressionContainsReactiveCreation(expr.body);
+      }
+      return Array.isArray(expr.body) ? expr.body.some(
+        (block) => block.instructions.some((i) => instructionContainsReactiveCreation(i))
+      ) : false;
+    case "FunctionExpression":
+      return expr.body.some(
+        (block) => block.instructions.some((i) => instructionContainsReactiveCreation(i))
+      );
+    case "AssignmentExpression":
+      return expressionContainsReactiveCreation(expr.left) || expressionContainsReactiveCreation(expr.right);
+    case "UpdateExpression":
+      return expressionContainsReactiveCreation(expr.argument);
+    case "TemplateLiteral":
+      return expr.expressions.some((e) => expressionContainsReactiveCreation(e));
+    case "SpreadElement":
+      return expressionContainsReactiveCreation(expr.argument);
+    case "AwaitExpression":
+      return expressionContainsReactiveCreation(expr.argument);
+    case "YieldExpression":
+      return expr.argument ? expressionContainsReactiveCreation(expr.argument) : false;
+    case "NewExpression":
+      return expressionContainsReactiveCreation(expr.callee) || expr.arguments.some((arg) => expressionContainsReactiveCreation(arg));
+    case "OptionalCallExpression":
+      return expressionContainsReactiveCreation(expr.callee) || expr.arguments.some((arg) => expressionContainsReactiveCreation(arg));
+    case "JSXElement":
+      return typeof expr.tagName !== "string" && expressionContainsReactiveCreation(expr.tagName) || expr.attributes.some(
+        (attr) => attr.isSpread ? !!attr.spreadExpr && expressionContainsReactiveCreation(attr.spreadExpr) : attr.value ? expressionContainsReactiveCreation(attr.value) : false
+      ) || expr.children.some(
+        (child) => child.kind === "expression" ? expressionContainsReactiveCreation(child.value) : false
+      );
+    default:
+      return false;
+  }
+}
+function instructionContainsReactiveCreation(instr) {
+  if (instr.kind === "Assign") {
+    return expressionContainsReactiveCreation(instr.value);
+  }
+  if (instr.kind === "Expression") {
+    return expressionContainsReactiveCreation(instr.value);
+  }
+  return false;
+}
+function instructionIsReactiveSetup(instr) {
+  if (instr.kind === "Assign") {
+    return expressionCreatesReactive(instr.value);
+  }
+  if (instr.kind === "Expression") {
+    return expressionCreatesReactive(instr.value);
+  }
+  return false;
+}
+function nodeIsPureReactiveScope(node) {
+  let found = false;
+  const visit = (n) => {
+    switch (n.kind) {
+      case "instruction": {
+        const ok = instructionIsReactiveSetup(n.instruction);
+        if (ok && instructionContainsReactiveCreation(n.instruction)) found = true;
+        return ok;
+      }
+      case "sequence":
+        if (n.nodes.length === 0) return false;
+        return n.nodes.every((child) => visit(child));
+      case "block":
+        if (n.statements.length === 0) return false;
+        return n.statements.every((child) => visit(child));
+      default:
+        return false;
+    }
+  };
+  return visit(node) && found;
+}
 function generateRegions(fn, scopeResult, shapeResult = analyzeObjectShapes(fn)) {
   const regions = [];
   const regionsByBlock = /* @__PURE__ */ new Map();
@@ -18033,14 +18142,67 @@ function lowerNodeWithRegionContext(node, t2, ctx, declaredVars, regionCtx) {
     case "if": {
       const prevConditional = ctx.inConditional ?? 0;
       ctx.inConditional = prevConditional + 1;
-      const conseq = t2.blockStatement(
-        lowerNodeWithRegionContext(node.consequent, t2, ctx, declaredVars, regionCtx)
+      const conseqStmts = lowerNodeWithRegionContext(
+        node.consequent,
+        t2,
+        ctx,
+        declaredVars,
+        regionCtx
       );
-      const alt = node.alternate ? t2.blockStatement(
-        lowerNodeWithRegionContext(node.alternate, t2, ctx, declaredVars, regionCtx)
-      ) : null;
+      const altStmts = node.alternate ? lowerNodeWithRegionContext(node.alternate, t2, ctx, declaredVars, regionCtx) : null;
       ctx.inConditional = prevConditional;
-      const ifStmt = t2.ifStatement(lowerExpressionWithDeSSA(node.test, ctx), conseq, alt);
+      const conseqReactiveOnly = nodeIsPureReactiveScope(node.consequent);
+      const altReactiveOnly = node.alternate ? nodeIsPureReactiveScope(node.alternate) : false;
+      const testExpr = lowerExpressionWithDeSSA(node.test, ctx);
+      const unwrapTestExpr = () => {
+        if (t2.isArrowFunctionExpression(testExpr) && testExpr.params.length === 0 && !t2.isBlockStatement(testExpr.body)) {
+          return t2.cloneNode(testExpr.body);
+        }
+        return t2.cloneNode(testExpr);
+      };
+      const createFlagExpr = (negate = false) => {
+        const body = unwrapTestExpr();
+        const bodyExpr = negate ? t2.unaryExpression("!", body) : body;
+        return t2.arrowFunctionExpression([], bodyExpr);
+      };
+      if (conseqReactiveOnly || altReactiveOnly) {
+        const stmts = [];
+        const runInScopeId = t2.identifier(RUNTIME_ALIASES.runInScope);
+        const addScoped = (flagExpr, body) => {
+          ctx.helpersUsed.add("runInScope");
+          stmts.push(
+            t2.expressionStatement(
+              t2.callExpression(runInScopeId, [
+                flagExpr,
+                t2.arrowFunctionExpression([], t2.blockStatement(body))
+              ])
+            )
+          );
+        };
+        if (conseqReactiveOnly) {
+          addScoped(createFlagExpr(false), conseqStmts);
+        }
+        if (altReactiveOnly && altStmts) {
+          addScoped(createFlagExpr(true), altStmts);
+        }
+        const needsFallbackConseq = !conseqReactiveOnly && conseqStmts.length > 0;
+        const needsFallbackAlt = !altReactiveOnly && altStmts && altStmts.length > 0;
+        if (needsFallbackConseq || needsFallbackAlt) {
+          stmts.push(
+            t2.ifStatement(
+              unwrapTestExpr(),
+              needsFallbackConseq ? t2.blockStatement(conseqStmts) : t2.blockStatement([]),
+              needsFallbackAlt && altStmts ? t2.blockStatement(altStmts) : null
+            )
+          );
+        }
+        return stmts;
+      }
+      const ifStmt = t2.ifStatement(
+        testExpr,
+        t2.blockStatement(conseqStmts),
+        altStmts ? t2.blockStatement(altStmts) : null
+      );
       const shouldWrapEffect = ctx.wrapTrackedExpressions !== false && !ctx.inRegionMemo && expressionUsesTracked(node.test, ctx) && !statementHasEarlyExit(ifStmt, t2);
       if (shouldWrapEffect) {
         ctx.helpersUsed.add("useEffect");
@@ -19034,6 +19196,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
   if (instr.kind === "Assign") {
     const ssaName = instr.target.name;
     const baseName2 = deSSAVarName(ssaName);
+    const declKindRaw = instr.declarationKind;
     propagateHookResultAlias(baseName2, instr.value, ctx);
     const hookMember = resolveHookMemberValue(instr.value, ctx);
     if (hookMember) {
@@ -19043,9 +19206,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       } else if (hookMember.kind === "memo") {
         ctx.memoVars?.add(baseName2);
       }
-      if (instr.declarationKind) {
+      const declKind2 = declKindRaw && declKindRaw !== "function" ? declKindRaw : null;
+      if (declKind2) {
         declaredVars.add(baseName2);
-        return t2.variableDeclaration(instr.declarationKind, [
+        return t2.variableDeclaration(declKind2, [
           t2.variableDeclarator(t2.identifier(baseName2), hookMember.member)
         ]);
       }
@@ -19058,11 +19222,25 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
         t2.assignmentExpression("=", t2.identifier(baseName2), hookMember.member)
       );
     }
-    const declKind = instr.declarationKind;
+    const declKind = declKindRaw && declKindRaw !== "function" ? declKindRaw : void 0;
+    const isFunctionDecl = instr.value.kind === "FunctionExpression" && (declKindRaw === "function" || !declKindRaw && instr.value.name === baseName2);
+    if (isFunctionDecl) {
+      const loweredFn = lowerExpressionWithDeSSA(instr.value, ctx);
+      if (t2.isFunctionExpression(loweredFn)) {
+        declaredVars.add(baseName2);
+        return t2.functionDeclaration(
+          t2.identifier(baseName2),
+          loweredFn.params,
+          loweredFn.body,
+          loweredFn.generator ?? false,
+          loweredFn.async ?? false
+        );
+      }
+    }
     const isTracked = ctx.trackedVars.has(baseName2);
     const isSignal = ctx.signalVars?.has(baseName2) ?? false;
     const aliasVars = ctx.aliasVars ?? (ctx.aliasVars = /* @__PURE__ */ new Set());
-    const dependsOnTracked2 = expressionUsesTracked(instr.value, ctx);
+    const dependsOnTracked2 = expressionUsesTracked(instr.value, ctx) || (ctx.memoVars?.has(baseName2) ?? false);
     const capturedTracked = ctx.externalTracked && ctx.externalTracked.has(baseName2) && !declaredVars.has(baseName2);
     const isShadowDeclaration = !!declKind && declaredVars.has(baseName2);
     const treatAsTracked = !isShadowDeclaration && isTracked;
@@ -19070,6 +19248,9 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
     const isStateCall2 = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && instr.value.callee.name === "$state";
     const inRegionMemo = ctx.inRegionMemo ?? false;
     const isFunctionValue = instr.value.kind === "ArrowFunction" || instr.value.kind === "FunctionExpression";
+    const isAccessorReturningCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["$memo", "createMemo", "useProp"].includes(instr.value.callee.name);
+    const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps", "prop"].includes(instr.value.callee.name);
+    const isMemoReturningCall = isAccessorReturningCall || isReactiveObjectCall;
     const lowerAssignedValue = (forceAssigned = false) => lowerExpressionWithDeSSA(instr.value, ctx, forceAssigned || isFunctionValue);
     const buildMemoCall = (expr) => {
       const args = [
@@ -19116,7 +19297,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
               t2.variableDeclarator(t2.identifier(baseName2), derivedExpr)
             ]);
           }
-          ctx.memoVars?.add(baseName2);
+          if (!isReactiveObjectCall) ctx.memoVars?.add(baseName2);
           if (ctx.noMemo) {
             return t2.variableDeclaration(normalizedDecl, [
               t2.variableDeclarator(
@@ -19126,7 +19307,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
             ]);
           }
           return t2.variableDeclaration(normalizedDecl, [
-            t2.variableDeclarator(t2.identifier(baseName2), buildMemoCall(derivedExpr))
+            t2.variableDeclarator(
+              t2.identifier(baseName2),
+              isMemoReturningCall ? derivedExpr : buildMemoCall(derivedExpr)
+            )
           ]);
         }
       }
@@ -19137,7 +19321,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
             t2.variableDeclarator(t2.identifier(baseName2), derivedExpr)
           ]);
         }
-        ctx.memoVars?.add(baseName2);
+        if (!isReactiveObjectCall) ctx.memoVars?.add(baseName2);
         if (ctx.noMemo) {
           return t2.variableDeclaration(normalizedDecl, [
             t2.variableDeclarator(
@@ -19147,7 +19331,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           ]);
         }
         return t2.variableDeclaration(normalizedDecl, [
-          t2.variableDeclarator(t2.identifier(baseName2), buildMemoCall(derivedExpr))
+          t2.variableDeclarator(
+            t2.identifier(baseName2),
+            isMemoReturningCall ? derivedExpr : buildMemoCall(derivedExpr)
+          )
         ]);
       }
       return t2.variableDeclaration(fallbackDecl, [
@@ -19205,7 +19392,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
             t2.variableDeclarator(t2.identifier(baseName2), derivedExpr)
           ]);
         }
-        ctx.memoVars?.add(baseName2);
+        if (!isReactiveObjectCall) ctx.memoVars?.add(baseName2);
         if (ctx.noMemo) {
           return t2.variableDeclaration("const", [
             t2.variableDeclarator(
@@ -19215,7 +19402,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           ]);
         }
         return t2.variableDeclaration("const", [
-          t2.variableDeclarator(t2.identifier(baseName2), buildMemoCall(derivedExpr))
+          t2.variableDeclarator(
+            t2.identifier(baseName2),
+            isMemoReturningCall ? derivedExpr : buildMemoCall(derivedExpr)
+          )
         ]);
       }
       return t2.variableDeclaration("let", [
@@ -19229,22 +19419,17 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           t2.variableDeclarator(t2.identifier(baseName2), derivedExpr)
         ]);
       }
-      if (ctx.memoVars?.has(baseName2)) {
-        if (buildMemoCall) {
-          console.log("Declaring memo var:", baseName2);
-          return t2.variableDeclaration("const", [
-            t2.variableDeclarator(t2.identifier(baseName2), buildMemoCall(derivedExpr))
-          ]);
-        }
-      }
-      ctx.memoVars?.add(baseName2);
+      if (!isReactiveObjectCall) ctx.memoVars?.add(baseName2);
       if (ctx.noMemo) {
         return t2.variableDeclaration("const", [
           t2.variableDeclarator(t2.identifier(baseName2), t2.arrowFunctionExpression([], derivedExpr))
         ]);
       }
       return t2.variableDeclaration("const", [
-        t2.variableDeclarator(t2.identifier(baseName2), buildMemoCall(derivedExpr))
+        t2.variableDeclarator(
+          t2.identifier(baseName2),
+          isMemoReturningCall ? derivedExpr : buildMemoCall(derivedExpr)
+        )
       ]);
     }
     return t2.variableDeclaration("let", [
@@ -20322,7 +20507,8 @@ function collectExpressionIdentifiersDeep(expr, into, bound = /* @__PURE__ */ ne
     case "CallExpression":
     case "OptionalCallExpression": {
       const isMacroCallee = expr.callee.kind === "Identifier" && (expr.callee.name === "$state" || expr.callee.name === "$effect" || expr.callee.name === "$store");
-      if (!isMacroCallee) {
+      const isIIFE = expr.callee.kind === "ArrowFunction" || expr.callee.kind === "FunctionExpression";
+      if (!isMacroCallee && !isIIFE) {
         collectExpressionIdentifiersDeep(expr.callee, into, bound);
       }
       expr.arguments.forEach(
@@ -20363,73 +20549,81 @@ function collectExpressionIdentifiersDeep(expr, into, bound = /* @__PURE__ */ ne
       );
       return;
     case "ArrowFunction": {
-      const nextBound = new Set(bound);
-      expr.params.forEach((p) => nextBound.add(deSSAVarName(p.name)));
+      const tempSet = /* @__PURE__ */ new Set();
       if (expr.isExpression && expr.body && !Array.isArray(expr.body)) {
-        collectExpressionIdentifiersDeep(expr.body, into, nextBound);
+        collectExpressionIdentifiers(expr.body, tempSet);
       } else if (Array.isArray(expr.body)) {
         for (const block of expr.body) {
           for (const instr of block.instructions) {
             if (instr.kind === "Assign") {
-              collectExpressionIdentifiersDeep(instr.value, into, nextBound);
+              collectExpressionIdentifiers(instr.value, tempSet);
             } else if (instr.kind === "Expression") {
-              collectExpressionIdentifiersDeep(instr.value, into, nextBound);
+              collectExpressionIdentifiers(instr.value, tempSet);
             } else if (instr.kind === "Phi") {
-              instr.sources.forEach((src) => addIdentifier(src.id.name));
+              instr.sources.forEach((src) => tempSet.add(deSSAVarName(src.id.name)));
             }
           }
           const term = block.terminator;
           if (term.kind === "Branch") {
-            collectExpressionIdentifiersDeep(term.test, into, nextBound);
+            collectExpressionIdentifiers(term.test, tempSet);
           } else if (term.kind === "Switch") {
-            collectExpressionIdentifiersDeep(term.discriminant, into, nextBound);
+            collectExpressionIdentifiers(term.discriminant, tempSet);
             term.cases.forEach((c) => {
-              if (c.test) collectExpressionIdentifiersDeep(c.test, into, nextBound);
+              if (c.test) collectExpressionIdentifiers(c.test, tempSet);
             });
           } else if (term.kind === "ForOf") {
-            collectExpressionIdentifiersDeep(term.iterable, into, nextBound);
+            collectExpressionIdentifiers(term.iterable, tempSet);
           } else if (term.kind === "ForIn") {
-            collectExpressionIdentifiersDeep(term.object, into, nextBound);
+            collectExpressionIdentifiers(term.object, tempSet);
           } else if (term.kind === "Return" && term.argument) {
-            collectExpressionIdentifiersDeep(term.argument, into, nextBound);
+            collectExpressionIdentifiers(term.argument, tempSet);
           } else if (term.kind === "Throw") {
-            collectExpressionIdentifiersDeep(term.argument, into, nextBound);
+            collectExpressionIdentifiers(term.argument, tempSet);
           }
         }
       }
+      const paramNames = new Set(expr.params.map((p) => deSSAVarName(p.name)));
+      for (const name of bound) paramNames.add(name);
+      for (const dep of tempSet) {
+        if (!paramNames.has(dep)) into.add(dep);
+      }
       return;
     }
     case "FunctionExpression": {
-      const nextBound = new Set(bound);
-      expr.params.forEach((p) => nextBound.add(deSSAVarName(p.name)));
+      const tempSet = /* @__PURE__ */ new Set();
       for (const block of expr.body) {
         for (const instr of block.instructions) {
           if (instr.kind === "Assign") {
-            collectExpressionIdentifiersDeep(instr.value, into, nextBound);
+            collectExpressionIdentifiers(instr.value, tempSet);
           } else if (instr.kind === "Expression") {
-            collectExpressionIdentifiersDeep(instr.value, into, nextBound);
+            collectExpressionIdentifiers(instr.value, tempSet);
           } else if (instr.kind === "Phi") {
-            instr.sources.forEach((src) => addIdentifier(src.id.name));
+            instr.sources.forEach((src) => tempSet.add(deSSAVarName(src.id.name)));
           }
         }
         const term = block.terminator;
         if (term.kind === "Branch") {
-          collectExpressionIdentifiersDeep(term.test, into, nextBound);
+          collectExpressionIdentifiers(term.test, tempSet);
         } else if (term.kind === "Switch") {
-          collectExpressionIdentifiersDeep(term.discriminant, into, nextBound);
+          collectExpressionIdentifiers(term.discriminant, tempSet);
           term.cases.forEach((c) => {
-            if (c.test) collectExpressionIdentifiersDeep(c.test, into, nextBound);
+            if (c.test) collectExpressionIdentifiers(c.test, tempSet);
           });
         } else if (term.kind === "ForOf") {
-          collectExpressionIdentifiersDeep(term.iterable, into, nextBound);
+          collectExpressionIdentifiers(term.iterable, tempSet);
         } else if (term.kind === "ForIn") {
-          collectExpressionIdentifiersDeep(term.object, into, nextBound);
+          collectExpressionIdentifiers(term.object, tempSet);
         } else if (term.kind === "Return" && term.argument) {
-          collectExpressionIdentifiersDeep(term.argument, into, nextBound);
+          collectExpressionIdentifiers(term.argument, tempSet);
         } else if (term.kind === "Throw") {
-          collectExpressionIdentifiersDeep(term.argument, into, nextBound);
+          collectExpressionIdentifiers(term.argument, tempSet);
         }
       }
+      const paramNames = new Set(expr.params.map((p) => deSSAVarName(p.name)));
+      for (const name of bound) paramNames.add(name);
+      for (const dep of tempSet) {
+        if (!paramNames.has(dep)) into.add(dep);
+      }
       return;
     }
     case "AssignmentExpression":
@@ -20498,6 +20692,13 @@ function getExpressionIdentifiers(expr) {
   }
   return deps;
 }
+function getExpressionIdentifiersDeep(expr) {
+  const deps = /* @__PURE__ */ new Set();
+  if (expr) {
+    collectExpressionIdentifiersDeep(expr, deps);
+  }
+  return deps;
+}
 function buildControlDependencyMap(fn) {
   const depsByInstruction = /* @__PURE__ */ new Map();
   let structured;
@@ -20624,7 +20825,7 @@ function computeReactiveAccessors(fn, ctx) {
     for (const instr of block.instructions) {
       if (instr.kind === "Assign") {
         const target = deSSAVarName(instr.target.name);
-        const dataDeps = getExpressionIdentifiers(instr.value);
+        const dataDeps = getExpressionIdentifiersDeep(instr.value);
         addDepsToTarget(target, dataDeps, dataDepsByTarget);
         const controlDeps = controlDepsByInstr.get(instr) ?? /* @__PURE__ */ new Set();
         addDepsToTarget(target, controlDeps, controlDepsByTarget);
@@ -20685,7 +20886,7 @@ function computeReactiveAccessors(fn, ctx) {
         if (instr.kind === "Assign") {
           const target = deSSAVarName(instr.target.name);
           if (isFunctionVar(target)) continue;
-          const dataDeps = getExpressionIdentifiers(instr.value);
+          const dataDeps = getExpressionIdentifiersDeep(instr.value);
           const controlDepsForInstr = controlDepsByInstr.get(instr) ?? /* @__PURE__ */ new Set();
           const hasDataDep = Array.from(dataDeps).some((dep) => tracked.has(dep));
           const hasControlDep = Array.from(controlDepsForInstr).some((dep) => tracked.has(dep));
@@ -20695,7 +20896,8 @@ function computeReactiveAccessors(fn, ctx) {
             tracked.add(target);
             changed = true;
           }
-          if (hasDataDep && !isSignal(target) && !isStore(target)) {
+          const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps", "prop"].includes(instr.value.callee.name);
+          if (hasDataDep && !isSignal(target) && !isStore(target) && !isReactiveObjectCall) {
             memo.add(target);
           }
         } else if (instr.kind === "Phi") {
@@ -20783,6 +20985,20 @@ function lowerInstruction(instr, ctx) {
   const { t: t2 } = ctx;
   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
+        );
+      }
+    }
+    const declKind = instr.declarationKind === "function" ? void 0 : instr.declarationKind;
     propagateHookResultAlias(baseName2, instr.value, ctx);
     const hookMember = resolveHookMemberValue(instr.value, ctx);
     if (hookMember) {
@@ -20792,8 +21008,8 @@ function lowerInstruction(instr, ctx) {
       } else if (hookMember.kind === "memo") {
         ctx.memoVars?.add(baseName2);
       }
-      if (instr.declarationKind) {
-        return t2.variableDeclaration(instr.declarationKind, [
+      if (declKind) {
+        return t2.variableDeclaration(declKind, [
           t2.variableDeclarator(t2.identifier(baseName2), hookMember.member)
         ]);
       }
@@ -21192,6 +21408,13 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
         return t2.callExpression(t2.identifier(RUNTIME_ALIASES.mergeProps), args);
       }
       const isIIFE = (expr.callee.kind === "ArrowFunction" || expr.callee.kind === "FunctionExpression") && expr.arguments.length === 0 && expr.callee.params.length === 0;
+      const calleeName = expr.callee.kind === "Identifier" ? deSSAVarName(expr.callee.name) : null;
+      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 lowerCallee = () => isIIFE ? withNonReactiveScope(ctx, () => lowerExpression(expr.callee, ctx)) : lowerExpression(expr.callee, ctx);
       return t2.callExpression(
         lowerCallee(),
@@ -21544,11 +21767,12 @@ function lowerExpressionImpl(expr, ctx, isAssigned = false) {
       return t2.identifier("undefined");
   }
 }
-function lowerDomExpression(expr, ctx, region) {
+function lowerDomExpression(expr, ctx, region, options) {
   let lowered = lowerExpression(expr, ctx);
-  if (ctx.t.isMemberExpression(lowered) && ctx.t.isIdentifier(lowered.object) && ctx.hookResultVarMap?.has(deSSAVarName(lowered.object.name))) {
+  const skipHookAccessors = options?.skipHookAccessors ?? false;
+  if (!skipHookAccessors && ctx.t.isMemberExpression(lowered) && ctx.t.isIdentifier(lowered.object) && ctx.hookResultVarMap?.has(deSSAVarName(lowered.object.name))) {
     lowered = ctx.t.callExpression(lowered, []);
-  } else if (ctx.t.isIdentifier(lowered)) {
+  } else if (!skipHookAccessors && ctx.t.isIdentifier(lowered)) {
     const hookName = ctx.hookResultVarMap?.get(deSSAVarName(lowered.name));
     if (hookName) {
       const info = getHookReturnInfo(hookName, ctx);
@@ -21557,7 +21781,9 @@ function lowerDomExpression(expr, ctx, region) {
       }
     }
   }
-  return applyRegionMetadataToExpression(lowered, ctx, region);
+  return applyRegionMetadataToExpression(lowered, ctx, region, {
+    skipRootOverride: options?.skipRegionRootOverride
+  });
 }
 function lowerJSXChildNonFineGrained(child, ctx) {
   const { t: t2 } = ctx;
@@ -21766,12 +21992,13 @@ function getDependencyPathFromNode(node, t2) {
   }
   return null;
 }
-function applyRegionMetadataToExpression(expr, ctx, regionOverride) {
+function applyRegionMetadataToExpression(expr, ctx, regionOverride, options) {
   if (ctx.inReturn && ctx.currentFnIsHook) {
     return expr;
   }
   const region = regionOverride ?? ctx.currentRegion;
   if (!region) return expr;
+  const skipRootOverride = options?.skipRootOverride ?? false;
   const metadata = regionInfoToMetadata(region);
   const state = {};
   applyRegionMetadata(state, {
@@ -21824,7 +22051,7 @@ function applyRegionMetadataToExpression(expr, ctx, regionOverride) {
   if (Object.keys(overrides).length === 0) {
     return expr;
   }
-  if (ctx.t.isIdentifier(expr)) {
+  if (!skipRootOverride && ctx.t.isIdentifier(expr)) {
     const key = normalizeDependencyKey2(expr.name);
     const direct = overrides[key] ?? overrides[expr.name];
     if (direct) {
@@ -21832,10 +22059,10 @@ function applyRegionMetadataToExpression(expr, ctx, regionOverride) {
     }
   }
   const cloned = ctx.t.cloneNode(expr, true);
-  replaceIdentifiersWithOverrides(cloned, overrides, ctx.t);
+  replaceIdentifiersWithOverrides(cloned, overrides, ctx.t, void 0, void 0, skipRootOverride);
   return cloned;
 }
-function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parentKey) {
+function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parentKey, skipCurrentNode = false) {
   const isCallTarget = parentKey === "callee" && (parentKind === "CallExpression" || parentKind === "OptionalCallExpression");
   const collectParamNames = (params) => {
     const names = /* @__PURE__ */ new Set();
@@ -21871,7 +22098,7 @@ function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parent
     params.forEach((p) => visitPattern(p));
     return names;
   };
-  if (t2.isMemberExpression(node) || t2.isOptionalMemberExpression(node)) {
+  if (!skipCurrentNode && (t2.isMemberExpression(node) || t2.isOptionalMemberExpression(node))) {
     const path = getDependencyPathFromNode(node, t2);
     const normalized = path ? normalizeDependencyKey2(path) : null;
     const override = normalized && overrides[normalized] || (path ? overrides[path] : void 0);
@@ -21881,7 +22108,7 @@ function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parent
       return;
     }
   }
-  if (t2.isIdentifier(node)) {
+  if (!skipCurrentNode && t2.isIdentifier(node)) {
     const key = normalizeDependencyKey2(node.name);
     const override = overrides[key] ?? overrides[node.name];
     if (override && !isCallTarget) {
@@ -21926,7 +22153,8 @@ function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parent
             overrides,
             t2,
             node.type,
-            key
+            key,
+            false
           );
         }
       }
@@ -22355,7 +22583,10 @@ function lowerIntrinsicElement(jsx, ctx) {
       const shouldWrapHandler = isExpressionReactive(binding.expr, ctx);
       const prevWrapTracked = ctx.wrapTrackedExpressions;
       ctx.wrapTrackedExpressions = false;
-      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
+      const valueExpr = lowerDomExpression(binding.expr, ctx, containingRegion, {
+        skipHookAccessors: true,
+        skipRegionRootOverride: true
+      });
       ctx.wrapTrackedExpressions = prevWrapTracked;
       const eventParam = t2.identifier("_e");
       const isFn = t2.isArrowFunctionExpression(valueExpr) || t2.isFunctionExpression(valueExpr);
@@ -24081,6 +24312,9 @@ function isInsideNestedFunction(path) {
   }
   return false;
 }
+function isInsideJSX(path) {
+  return !!path.findParent((p) => p.isJSXElement?.() || p.isJSXFragment?.());
+}
 function emitWarning(node, code, message, options, fileName) {
   if (!options.onWarn) return;
   const loc = node.loc?.start;
@@ -24178,6 +24412,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
     const root = getRootIdentifier(expr, t2);
     return !!(root && stateVars.has(root.name));
   };
+  const reactiveNames = /* @__PURE__ */ new Set([...stateVars, ...derivedVars]);
   programPath.traverse({
     AssignmentExpression(path) {
       const { left } = path.node;
@@ -24240,6 +24475,35 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
         );
       }
     },
+    Function(path) {
+      const captured = /* @__PURE__ */ new Set();
+      path.traverse(
+        {
+          Function(inner) {
+            if (inner === path) return;
+            inner.skip();
+          },
+          Identifier(idPath) {
+            const name = idPath.node.name;
+            if (!reactiveNames.has(name)) return;
+            const binding = idPath.scope.getBinding(name);
+            if (!binding) return;
+            if (binding.scope === idPath.scope || binding.scope === path.scope) return;
+            captured.add(name);
+          }
+        },
+        {}
+      );
+      if (captured.size > 0) {
+        emitWarning(
+          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,
+          fileName
+        );
+      }
+    },
     CallExpression(path) {
       if (t2.isIdentifier(path.node.callee, { name: "$effect" })) {
         const argPath = path.get("arguments.0");
@@ -24561,6 +24825,15 @@ function createHIREntrypointVisitor(t2, options) {
             }
             const callee = callPath.node.callee;
             const calleeId = t2.isIdentifier(callee) ? callee.name : null;
+            if (calleeId && (calleeId === "createEffect" || calleeId === "createMemo" || calleeId === "createSelector") && fictImports.has(calleeId) && (isInsideLoop(callPath) || isInsideConditional(callPath)) && !isInsideJSX(callPath)) {
+              emitWarning(
+                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,
+                fileName
+              );
+            }
             const allowedStateCallees = /* @__PURE__ */ new Set([
               "$effect",
               "$memo",