@fictjs/compiler 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -14384,6 +14384,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";
 }
@@ -14453,7 +14456,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;
@@ -14466,7 +14470,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 });
@@ -14484,9 +14489,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);
@@ -14511,7 +14518,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 });
@@ -14536,13 +14544,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 };
@@ -15050,11 +15060,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);
@@ -15552,14 +15563,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;
   }
@@ -15574,7 +15587,8 @@ function convertExpression(node) {
         object,
         property,
         computed: node.computed,
-        optional: node.optional ?? true
+        optional: node.optional ?? true,
+        loc
       };
       return optionalMember;
     }
@@ -15583,7 +15597,8 @@ function convertExpression(node) {
       object,
       property,
       computed: node.computed,
-      optional: false
+      optional: false,
+      loc
     };
     return member;
   }
@@ -15592,7 +15607,8 @@ function convertExpression(node) {
       kind: "BinaryExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return bin;
   }
@@ -15601,7 +15617,8 @@ function convertExpression(node) {
       kind: "UnaryExpression",
       operator: node.operator,
       argument: convertExpression(node.argument),
-      prefix: node.prefix
+      prefix: node.prefix,
+      loc
     };
     return un;
   }
@@ -15610,7 +15627,8 @@ function convertExpression(node) {
       kind: "LogicalExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return log;
   }
@@ -15619,7 +15637,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;
   }
@@ -15631,12 +15650,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;
   }
@@ -15647,7 +15668,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)) {
@@ -15664,7 +15686,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;
@@ -15674,9 +15697,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;
   }
@@ -15689,38 +15715,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)
             });
           }
         }
@@ -15728,24 +15758,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 {
@@ -15756,7 +15789,8 @@ function convertExpression(node) {
         ).flat(),
         body: convertExpression(node.body),
         isExpression: true,
-        isAsync: node.async
+        isAsync: node.async,
+        loc
       };
       return arrow;
     }
@@ -15764,14 +15798,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;
   }
@@ -15780,7 +15816,8 @@ function convertExpression(node) {
       kind: "AssignmentExpression",
       operator: node.operator,
       left: convertExpression(node.left),
-      right: convertExpression(node.right)
+      right: convertExpression(node.right),
+      loc
     };
     return assign;
   }
@@ -15789,7 +15826,8 @@ function convertExpression(node) {
       kind: "UpdateExpression",
       operator: node.operator,
       argument: convertExpression(node.argument),
-      prefix: node.prefix
+      prefix: node.prefix,
+      loc
     };
     return update;
   }
@@ -15797,34 +15835,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)) {
@@ -15832,7 +15875,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)) {
@@ -15844,8 +15888,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)) {
@@ -15853,17 +15899,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) {
@@ -15874,7 +15921,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;
@@ -15892,20 +15939,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)
       });
     }
   }
@@ -15914,38 +15963,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)
           });
         }
       }
@@ -15956,21 +16009,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)
   };
 }
 
@@ -15991,6 +16050,75 @@ function debugEnabled(flag) {
   return parts.includes(normalized) || parts.includes("all");
 }
 
+// src/utils.ts
+function isStateCall(node, t2) {
+  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$state";
+}
+function isEffectCall(node, t2) {
+  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$effect";
+}
+function getRootIdentifier(expr, t2) {
+  if (t2.isIdentifier(expr)) {
+    return expr;
+  }
+  if (t2.isMemberExpression(expr) && t2.isExpression(expr.object) && !t2.isOptionalMemberExpression(expr)) {
+    return getRootIdentifier(expr.object, t2);
+  }
+  if (t2.isOptionalMemberExpression(expr) && t2.isExpression(expr.object)) {
+    return getRootIdentifier(expr.object, t2);
+  }
+  if (t2.isCallExpression(expr) && t2.isExpression(expr.callee)) {
+    return getRootIdentifier(expr.callee, t2);
+  }
+  if (t2.isOptionalCallExpression(expr) && t2.isExpression(expr.callee)) {
+    return getRootIdentifier(expr.callee, t2);
+  }
+  if (t2.isTSAsExpression(expr) && t2.isExpression(expr.expression)) {
+    return getRootIdentifier(expr.expression, t2);
+  }
+  if (t2.isTSNonNullExpression(expr) && t2.isExpression(expr.expression)) {
+    return getRootIdentifier(expr.expression, t2);
+  }
+  return null;
+}
+
+// src/fine-grained-dom.ts
+function normalizeDependencyKey(name) {
+  return name.split(".").map((part) => part.replace(/_\d+$/, "")).join(".");
+}
+function applyRegionMetadata(state, options) {
+  if (!options.region) return;
+  const region = options.region;
+  state.regionMetadata = region;
+  if (region.dependencies.size > 0) {
+    state.identifierOverrides = state.identifierOverrides ?? {};
+    const dependencyGetter = options.dependencyGetter ?? null;
+    if (!dependencyGetter) {
+      return;
+    }
+    for (const dep of region.dependencies) {
+      const key = normalizeDependencyKey(dep);
+      state.identifierOverrides[key] = () => dependencyGetter(dep);
+      const base = key.split(".")[0];
+      if (base && !state.identifierOverrides[base]) {
+        state.identifierOverrides[base] = () => dependencyGetter(base);
+      }
+    }
+  }
+}
+function shouldMemoizeRegion(region) {
+  if (region.dependencies.size > 0) {
+    return true;
+  }
+  if (region.hasControlFlow) {
+    return true;
+  }
+  if (region.hasReactiveWrites) {
+    return true;
+  }
+  return false;
+}
+
 // src/ir/ssa.ts
 function analyzeCFG(blocks) {
   const predecessors = computePredecessors(blocks);
@@ -16481,7 +16609,7 @@ function collectExprReads(expr, into, paths, bound = /* @__PURE__ */ new Set(),
       }
       return;
     case "CallExpression": {
-      const isMacroCallee = expr.callee.kind === "Identifier" && (expr.callee.name === "$state" || expr.callee.name === "$effect");
+      const isMacroCallee = expr.callee.kind === "Identifier" && (expr.callee.name === "$state" || expr.callee.name === "$effect" || expr.callee.name === "$store");
       if (!isMacroCallee) {
         collectExprReads(expr.callee, into, paths, bound);
       }
@@ -18849,6 +18977,7 @@ function wrapInMemo(region, t2, declaredVars, ctx, bodyStatementsOverride, outpu
   }
   const outputNames = outputNamesOverride ?? Array.from(region.declarations).map((name) => deSSAVarName(name));
   const uniqueOutputNames = [...new Set(outputNames)];
+  const bindableOutputs = uniqueOutputNames.filter((name) => !declaredVars.has(name));
   if (debugEnabled("region")) {
     console.log("Region memo", region.id, {
       instructions: region.instructions.map((instr) => instr.kind),
@@ -18858,11 +18987,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");
@@ -18895,20 +19030,24 @@ 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)])
     );
     const isAccessorOutput = (name) => ctx.signalVars?.has(name) || ctx.memoVars?.has(name) || ctx.aliasVars?.has(name) || ctx.storeVars?.has(name);
-    const getterOutputs = uniqueOutputNames.filter(
+    const getterOutputs = bindableOutputs.filter(
       (name) => ctx.trackedVars.has(name) && !isAccessorOutput(name)
     );
-    const directOutputs = uniqueOutputNames.filter((name) => !getterOutputs.includes(name));
+    const directOutputs = bindableOutputs.filter((name) => !getterOutputs.includes(name));
     if (debugEnabled("region")) {
       console.log("Region debug", {
         id: region.id,
@@ -18956,7 +19095,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");
+            })()
           ])
         )
       );
@@ -19174,11 +19316,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)])
   );
@@ -19200,6 +19346,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;
@@ -19270,7 +19419,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;
@@ -19284,17 +19436,6 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       const needsMutable = ctx.mutatedVars?.has(baseName2) ?? false;
       const isExternalAlias = declKind === "const" && instr.value.kind === "Identifier" && !(ctx.scopes?.byName?.has(deSSAVarName(instr.value.name)) ?? false);
       const fallbackDecl = !treatAsTracked && (!dependsOnTracked2 || isDestructuringTemp) ? declKind === "const" && (needsMutable || isExternalAlias) ? "let" : declKind : normalizedDecl;
-      const isAliasOfTracked = !isShadowDeclaration && instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name)) && !isDestructuringTemp;
-      if (isAliasOfTracked) {
-        declaredVars.add(baseName2);
-        const sourceIdent = instr.value;
-        return t2.variableDeclaration(fallbackDecl, [
-          t2.variableDeclarator(
-            t2.identifier(baseName2),
-            t2.callExpression(t2.identifier(deSSAVarName(sourceIdent.name)), [])
-          )
-        ]);
-      }
       declaredVars.add(baseName2);
       if (treatAsTracked && !isDestructuringTemp) {
         if (isStateCall2) {
@@ -19303,6 +19444,9 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           ]);
         }
         if (dependsOnTracked2) {
+          if (instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name)) && !isDestructuringTemp) {
+            aliasVars.add(baseName2);
+          }
           const derivedExpr = lowerAssignedValue(true);
           if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
             return t2.variableDeclaration(normalizedDecl, [
@@ -19327,6 +19471,9 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
         }
       }
       if (dependsOnTracked2 && !isDestructuringTemp) {
+        if (instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name)) && !isDestructuringTemp) {
+          aliasVars.add(baseName2);
+        }
         const derivedExpr = lowerAssignedValue(true);
         if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
           return t2.variableDeclaration(normalizedDecl, [
@@ -19361,17 +19508,35 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
         t2.callExpression(t2.identifier(baseName2), [lowerAssignedValue(true)])
       );
     }
-    if (instr.value.kind === "Identifier" && !isDestructuringTemp) {
-      const source = deSSAVarName(instr.value.name);
-      if (ctx.trackedVars.has(source) && !declaredVars.has(baseName2)) {
-        return t2.variableDeclaration(declKind ?? "const", [
-          t2.variableDeclarator(t2.identifier(baseName2), t2.callExpression(t2.identifier(source), []))
-        ]);
-      }
-    }
     if (aliasVars.has(baseName2) && !declaredVars.has(baseName2)) {
       throw new Error(`Alias reassignment is not supported for "${baseName2}"`);
     }
+    if (dependsOnTracked2 && !declKind && !isDestructuringTemp && !isTracked && !isSignal && instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name))) {
+      const derivedExpr = lowerAssignedValue(true);
+      aliasVars.add(baseName2);
+      if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
+        return t2.expressionStatement(
+          t2.assignmentExpression("=", t2.identifier(baseName2), derivedExpr)
+        );
+      }
+      if (!isReactiveObjectCall) ctx.memoVars?.add(baseName2);
+      if (ctx.noMemo) {
+        return t2.expressionStatement(
+          t2.assignmentExpression(
+            "=",
+            t2.identifier(baseName2),
+            t2.arrowFunctionExpression([], derivedExpr)
+          )
+        );
+      }
+      return t2.expressionStatement(
+        t2.assignmentExpression(
+          "=",
+          t2.identifier(baseName2),
+          isMemoReturningCall ? derivedExpr : buildMemoCall(derivedExpr)
+        )
+      );
+    }
     if (declaredVars.has(baseName2)) {
       if (aliasVars.has(baseName2)) {
         throw new Error(`Alias reassignment is not supported for "${baseName2}"`);
@@ -19769,78 +19934,20 @@ function deSSAJSXChild(child, t2) {
   return child;
 }
 
-// src/utils.ts
-function isStateCall(node, t2) {
-  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$state";
-}
-function isEffectCall(node, t2) {
-  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$effect";
-}
-function getRootIdentifier(expr, t2) {
-  if (t2.isIdentifier(expr)) {
-    return expr;
-  }
-  if (t2.isMemberExpression(expr) && t2.isExpression(expr.object) && !t2.isOptionalMemberExpression(expr)) {
-    return getRootIdentifier(expr.object, t2);
-  }
-  if (t2.isOptionalMemberExpression(expr) && t2.isExpression(expr.object)) {
-    return getRootIdentifier(expr.object, t2);
-  }
-  if (t2.isCallExpression(expr) && t2.isExpression(expr.callee)) {
-    return getRootIdentifier(expr.callee, t2);
-  }
-  if (t2.isOptionalCallExpression(expr) && t2.isExpression(expr.callee)) {
-    return getRootIdentifier(expr.callee, t2);
-  }
-  if (t2.isTSAsExpression(expr) && t2.isExpression(expr.expression)) {
-    return getRootIdentifier(expr.expression, t2);
-  }
-  if (t2.isTSNonNullExpression(expr) && t2.isExpression(expr.expression)) {
-    return getRootIdentifier(expr.expression, t2);
-  }
-  return null;
-}
-
-// src/fine-grained-dom.ts
-function normalizeDependencyKey(name) {
-  return name.split(".").map((part) => part.replace(/_\d+$/, "")).join(".");
-}
-function applyRegionMetadata(state, options) {
-  if (!options.region) return;
-  const region = options.region;
-  state.regionMetadata = region;
-  if (region.dependencies.size > 0) {
-    state.identifierOverrides = state.identifierOverrides ?? {};
-    const dependencyGetter = options.dependencyGetter ?? null;
-    if (!dependencyGetter) {
-      return;
-    }
-    for (const dep of region.dependencies) {
-      const key = normalizeDependencyKey(dep);
-      state.identifierOverrides[key] = () => dependencyGetter(dep);
-      const base = key.split(".")[0];
-      if (base && !state.identifierOverrides[base]) {
-        state.identifierOverrides[base] = () => dependencyGetter(base);
-      }
-    }
-  }
-}
-function shouldMemoizeRegion(region) {
-  if (region.dependencies.size > 0) {
-    return true;
-  }
-  if (region.hasControlFlow) {
-    return true;
-  }
-  if (region.hasReactiveWrites) {
-    return true;
-  }
-  return false;
-}
-
 // 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);
 }
@@ -19874,13 +19981,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;
@@ -19893,10 +20009,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) {
@@ -20995,18 +21130,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
+          )
         );
       }
     }
@@ -21021,12 +21163,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)) {
@@ -21040,16 +21186,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;
@@ -21058,6 +21212,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;
@@ -21070,14 +21227,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([
@@ -21087,9 +21244,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(
@@ -21098,30 +21255,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;
@@ -21137,20 +21294,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) {
@@ -21289,7 +21446,7 @@ 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;
   }
@@ -21424,14 +21581,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)) {
@@ -21995,6 +22160,8 @@ function getDependencyPathFromNode(node, t2) {
     if (node.computed) {
       if (t2.isStringLiteral(property) || t2.isNumericLiteral(property)) {
         propName = String(property.value);
+      } else {
+        return objectPath;
       }
     } else if (t2.isIdentifier(property)) {
       propName = property.name;
@@ -22111,10 +22278,12 @@ function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parent
     return names;
   };
   if (!skipCurrentNode && (t2.isMemberExpression(node) || t2.isOptionalMemberExpression(node))) {
+    const propertyNode = node.property;
+    const isDynamicComputed = (node.computed ?? false) && !t2.isStringLiteral(propertyNode) && !t2.isNumericLiteral(propertyNode);
     const path = getDependencyPathFromNode(node, t2);
     const normalized = path ? normalizeDependencyKey2(path) : null;
     const override = normalized && overrides[normalized] || (path ? overrides[path] : void 0);
-    if (override && !isCallTarget) {
+    if (override && !isCallTarget && !isDynamicComputed) {
       const replacement = override();
       Object.assign(node, replacement);
       return;
@@ -22284,15 +22453,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) => {
@@ -22321,15 +22481,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);
@@ -22784,7 +22938,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), []);
   }
@@ -23339,12 +23498,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 {
@@ -23591,8 +23754,11 @@ function lowerHIRWithRegions(program, t2, options) {
   for (const stmt of originalBody) {
     if (t2.isVariableDeclaration(stmt)) {
       for (const decl of stmt.declarations) {
-        if (t2.isIdentifier(decl.id) && decl.init && t2.isCallExpression(decl.init) && t2.isIdentifier(decl.init.callee) && decl.init.callee.name === "$state") {
+        if (t2.isIdentifier(decl.id) && decl.init && t2.isCallExpression(decl.init) && t2.isIdentifier(decl.init.callee) && (decl.init.callee.name === "$state" || decl.init.callee.name === "$store")) {
           ctx.trackedVars.add(decl.id.name);
+          if (decl.init.callee.name === "$store") {
+            ctx.storeVars?.add(decl.id.name);
+          }
         }
       }
     }
@@ -24235,10 +24401,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;
@@ -24327,10 +24492,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,
@@ -24418,8 +24617,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));
@@ -24435,7 +24633,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)) {
@@ -24443,7 +24641,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
               path.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
-              options,
+              warn,
               fileName
             );
           }
@@ -24458,7 +24656,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)) {
@@ -24466,7 +24664,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
               path.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
-              options,
+              warn,
               fileName
             );
           }
@@ -24482,7 +24680,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
           path.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
-          options,
+          warn,
           fileName
         );
       }
@@ -24511,7 +24709,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
         );
       }
@@ -24542,7 +24740,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
             );
           }
@@ -24568,7 +24766,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;
@@ -24584,7 +24782,7 @@ function runWarningPass(programPath, stateVars, derivedVars, options, t2) {
           path.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
-          options,
+          warn,
           fileName
         );
       }
@@ -24634,19 +24832,97 @@ 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;
+        };
+        const isComponentDefinition = (fnPath) => {
+          const name = getFunctionName(fnPath);
+          return name && isComponentName(name) || functionHasJSX(fnPath);
+        };
+        const isHookDefinition = (fnPath) => {
+          const name = getFunctionName(fnPath);
+          return isHookName2(name);
+        };
+        const isComponentOrHookDefinition = (fnPath) => isComponentDefinition(fnPath) || isHookDefinition(fnPath);
         const isComponentLike = (fnPath) => {
-          const name = 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;
-          return name && isComponentName(name) || functionHasJSX(fnPath) || functionUsesStateLike(fnPath, t2);
+          const name = getFunctionName(fnPath);
+          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);
@@ -24670,7 +24946,7 @@ function createHIREntrypointVisitor(t2, options) {
               fnPath.node,
               "FICT-C004",
               "Component has no return statement and will render nothing.",
-              options,
+              warn,
               fileName
             );
           },
@@ -24688,7 +24964,7 @@ function createHIREntrypointVisitor(t2, options) {
               init,
               "FICT-C004",
               "Component has no return statement and will render nothing.",
-              options,
+              warn,
               fileName
             );
           }
@@ -24738,7 +25014,7 @@ function createHIREntrypointVisitor(t2, options) {
               }
             }
             if (hasKey || hasUnknownSpread) return;
-            options.onWarn?.({
+            warn({
               code: "FICT-J002",
               message: "Missing key prop in list rendering.",
               fileName,
@@ -24763,6 +25039,12 @@ function createHIREntrypointVisitor(t2, options) {
                   "Destructuring $state is not supported. Use a simple identifier."
                 );
               }
+              const ownerComponent = varPath.getFunctionParent();
+              if (!ownerComponent || !isComponentOrHookDefinition(ownerComponent)) {
+                throw varPath.buildCodeFrameError(
+                  "$state() must be declared inside a component or hook function body"
+                );
+              }
               stateVars.add(varPath.node.id.name);
               if (isInsideLoop(varPath) || isInsideConditional(varPath)) {
                 throw varPath.buildCodeFrameError(
@@ -24803,12 +25085,18 @@ 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
             );
           },
           CallExpression(callPath) {
             if (isStateCall(callPath.node, t2)) {
+              const ownerComponent = callPath.getFunctionParent();
+              if (!ownerComponent || !isComponentOrHookDefinition(ownerComponent)) {
+                throw callPath.buildCodeFrameError(
+                  "$state() must be declared inside a component or hook function body"
+                );
+              }
               if (isInsideLoop(callPath) || isInsideConditional(callPath)) {
                 throw callPath.buildCodeFrameError(
                   "$state() cannot be declared inside loops or conditionals"
@@ -24842,10 +25130,31 @@ 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
               );
             }
+            if (calleeId && isHookName2(calleeId)) {
+              const binding = callPath.scope.getBinding(calleeId);
+              const bindingPath = binding?.path;
+              const bindingIsHook = !bindingPath && isHookName2(calleeId) || bindingPath?.isImportSpecifier() || bindingPath?.isImportDefaultSpecifier() || bindingPath?.isFunctionDeclaration() && isHookDefinition(bindingPath) || bindingPath?.isVariableDeclarator() && (() => {
+                const init = bindingPath.get?.("init");
+                return init ? isHookDefinition(init) : false;
+              })();
+              if (bindingIsHook) {
+                const ownerFunction = callPath.getFunctionParent();
+                if (!ownerFunction || !isComponentOrHookDefinition(ownerFunction)) {
+                  throw callPath.buildCodeFrameError(
+                    `${calleeId}() must be called inside a component or hook (useX)`
+                  );
+                }
+                if (isInsideLoop(callPath) || isInsideConditional(callPath) || isInsideNestedFunction(callPath)) {
+                  throw callPath.buildCodeFrameError(
+                    `${calleeId}() must be called at the top level of a component or hook (no loops/conditions/nested functions)`
+                  );
+                }
+              }
+            }
             const allowedStateCallees = /* @__PURE__ */ new Set([
               "$effect",
               "$memo",
@@ -24856,7 +25165,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,
@@ -24869,7 +25178,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,
@@ -24880,6 +25189,68 @@ function createHIREntrypointVisitor(t2, options) {
             }
           }
         });
+        const aliasStack = [/* @__PURE__ */ new Set()];
+        const currentAliasSet = () => aliasStack[aliasStack.length - 1];
+        const rhsUsesState = (exprPath) => {
+          if (!exprPath) return false;
+          if (exprPath.isIdentifier() && t2.isIdentifier(exprPath.node) && stateVars.has(exprPath.node.name)) {
+            return true;
+          }
+          let usesState = false;
+          exprPath.traverse({
+            Identifier(idPath) {
+              if (stateVars.has(idPath.node.name)) {
+                usesState = true;
+                idPath.stop();
+              }
+            }
+          });
+          return usesState;
+        };
+        if (process.env.FICT_DEBUG_ALIAS) {
+          console.log("[fict] alias check state vars", Array.from(stateVars));
+        }
+        path.traverse({
+          Function: {
+            enter() {
+              aliasStack.push(/* @__PURE__ */ new Set());
+            },
+            exit() {
+              aliasStack.pop();
+            }
+          },
+          VariableDeclarator(varPath) {
+            const aliasSet = currentAliasSet();
+            if (aliasSet && t2.isIdentifier(varPath.node.id) && rhsUsesState(varPath.get("init"))) {
+              if (process.env.FICT_DEBUG_ALIAS) {
+                console.log("[fict] alias add from decl", varPath.node.id.name);
+              }
+              aliasSet.add(varPath.node.id.name);
+            }
+          },
+          AssignmentExpression(assignPath) {
+            const aliasSet = currentAliasSet();
+            if (!aliasSet) return;
+            if (!t2.isIdentifier(assignPath.node.left)) return;
+            const targetName = assignPath.node.left.name;
+            const rightPath = assignPath.get("right");
+            if (rhsUsesState(rightPath)) {
+              if (process.env.FICT_DEBUG_ALIAS) {
+                console.log("[fict] alias add from assign", targetName);
+              }
+              aliasSet.add(targetName);
+              return;
+            }
+            if (aliasSet.has(targetName)) {
+              if (process.env.FICT_DEBUG_ALIAS) {
+                console.log("[fict] alias reassignment detected", targetName);
+              }
+              throw assignPath.buildCodeFrameError(
+                `Alias reassignment is not supported for "${targetName}"`
+              );
+            }
+          }
+        });
         if (derivedVars.size > 0) {
           path.traverse({
             AssignmentExpression(assignPath) {
@@ -24912,13 +25283,15 @@ 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;
-        path.scope.crawl();
+        if (!process.env.FICT_SKIP_SCOPE_CRAWL) {
+          path.scope.crawl();
+        }
         stripMacroImports(path, t2);
       }
     }