@fictjs/compiler 0.5.1 → 0.6.0

package/dist/index.cjs

@@ -107,7 +107,7 @@ var require_generated = __commonJS({
     });
     exports2.isAccessor = isAccessor;
     exports2.isAnyTypeAnnotation = isAnyTypeAnnotation;
-    exports2.isArgumentPlaceholder = isArgumentPlaceholder;
+    exports2.isArgumentPlaceholder = isArgumentPlaceholder2;
     exports2.isArrayExpression = isArrayExpression2;
     exports2.isArrayPattern = isArrayPattern4;
     exports2.isArrayTypeAnnotation = isArrayTypeAnnotation;
@@ -131,7 +131,7 @@ var require_generated = __commonJS({
     exports2.isClass = isClass;
     exports2.isClassAccessorProperty = isClassAccessorProperty;
     exports2.isClassBody = isClassBody;
-    exports2.isClassDeclaration = isClassDeclaration2;
+    exports2.isClassDeclaration = isClassDeclaration3;
     exports2.isClassExpression = isClassExpression2;
     exports2.isClassImplements = isClassImplements;
     exports2.isClassMethod = isClassMethod;
@@ -161,7 +161,7 @@ var require_generated = __commonJS({
     exports2.isDirectiveLiteral = isDirectiveLiteral;
     exports2.isDoExpression = isDoExpression;
     exports2.isDoWhileStatement = isDoWhileStatement2;
-    exports2.isEmptyStatement = isEmptyStatement;
+    exports2.isEmptyStatement = isEmptyStatement2;
     exports2.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
     exports2.isEnumBody = isEnumBody;
     exports2.isEnumBooleanBody = isEnumBooleanBody;
@@ -232,14 +232,14 @@ var require_generated = __commonJS({
     exports2.isJSXFragment = isJSXFragment2;
     exports2.isJSXIdentifier = isJSXIdentifier2;
     exports2.isJSXMemberExpression = isJSXMemberExpression2;
-    exports2.isJSXNamespacedName = isJSXNamespacedName;
+    exports2.isJSXNamespacedName = isJSXNamespacedName2;
     exports2.isJSXOpeningElement = isJSXOpeningElement;
     exports2.isJSXOpeningFragment = isJSXOpeningFragment;
     exports2.isJSXSpreadAttribute = isJSXSpreadAttribute2;
-    exports2.isJSXSpreadChild = isJSXSpreadChild;
+    exports2.isJSXSpreadChild = isJSXSpreadChild2;
     exports2.isJSXText = isJSXText2;
     exports2.isLVal = isLVal;
-    exports2.isLabeledStatement = isLabeledStatement;
+    exports2.isLabeledStatement = isLabeledStatement2;
     exports2.isLiteral = isLiteral;
     exports2.isLogicalExpression = isLogicalExpression2;
     exports2.isLoop = isLoop;
@@ -277,7 +277,7 @@ var require_generated = __commonJS({
     exports2.isOptionalMemberExpression = isOptionalMemberExpression2;
     exports2.isParenthesizedExpression = isParenthesizedExpression2;
     exports2.isPattern = isPattern2;
-    exports2.isPatternLike = isPatternLike2;
+    exports2.isPatternLike = isPatternLike3;
     exports2.isPipelineBareFunction = isPipelineBareFunction;
     exports2.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
     exports2.isPipelineTopicExpression = isPipelineTopicExpression;
@@ -485,7 +485,7 @@ var require_generated = __commonJS({
       if (node.type !== "DoWhileStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isEmptyStatement(node, opts) {
+    function isEmptyStatement2(node, opts) {
       if (!node) return false;
       if (node.type !== "EmptyStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -530,7 +530,7 @@ var require_generated = __commonJS({
       if (node.type !== "IfStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isLabeledStatement(node, opts) {
+    function isLabeledStatement2(node, opts) {
       if (!node) return false;
       if (node.type !== "LabeledStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -695,7 +695,7 @@ var require_generated = __commonJS({
       if (node.type !== "ClassExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isClassDeclaration2(node, opts) {
+    function isClassDeclaration3(node, opts) {
       if (!node) return false;
       if (node.type !== "ClassDeclaration") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -1210,7 +1210,7 @@ var require_generated = __commonJS({
       if (node.type !== "JSXExpressionContainer") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isJSXSpreadChild(node, opts) {
+    function isJSXSpreadChild2(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXSpreadChild") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -1225,7 +1225,7 @@ var require_generated = __commonJS({
       if (node.type !== "JSXMemberExpression") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isJSXNamespacedName(node, opts) {
+    function isJSXNamespacedName2(node, opts) {
       if (!node) return false;
       if (node.type !== "JSXNamespacedName") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -1275,7 +1275,7 @@ var require_generated = __commonJS({
       if (node.type !== "V8IntrinsicIdentifier") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isArgumentPlaceholder(node, opts) {
+    function isArgumentPlaceholder2(node, opts) {
       if (!node) return false;
       if (node.type !== "ArgumentPlaceholder") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -2216,7 +2216,7 @@ var require_generated = __commonJS({
       }
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isPatternLike2(node, opts) {
+    function isPatternLike3(node, opts) {
       if (!node) return false;
       switch (node.type) {
         case "Identifier":
@@ -7191,7 +7191,7 @@ var require_lowercase = __commonJS({
     exports2.classAccessorProperty = classAccessorProperty;
     exports2.classBody = classBody;
     exports2.classDeclaration = classDeclaration;
-    exports2.classExpression = classExpression;
+    exports2.classExpression = classExpression2;
     exports2.classImplements = classImplements;
     exports2.classMethod = classMethod;
     exports2.classPrivateMethod = classPrivateMethod;
@@ -8053,7 +8053,7 @@ var require_lowercase = __commonJS({
       validate(defs.body, node, "body", body, 1);
       return node;
     }
-    function classExpression(id = null, superClass = null, body, decorators = null) {
+    function classExpression2(id = null, superClass = null, body, decorators = null) {
       const node = {
         type: "ClassExpression",
         id,
@@ -14611,6 +14611,14 @@ function parseFictReturnAnnotation(node) {
 }
 function extractIdentifiersFromPattern(pattern) {
   const ids = [];
+  if (t.isRestElement(pattern)) {
+    if (t.isIdentifier(pattern.argument)) {
+      ids.push({ kind: "Identifier", name: pattern.argument.name });
+    } else if (t.isPatternLike(pattern.argument)) {
+      ids.push(...extractIdentifiersFromPattern(pattern.argument));
+    }
+    return ids;
+  }
   if (t.isObjectPattern(pattern)) {
     for (const prop of pattern.properties) {
       if (t.isObjectProperty(prop)) {
@@ -14619,14 +14627,18 @@ function extractIdentifiersFromPattern(pattern) {
         } else if (t.isAssignmentPattern(prop.value)) {
           if (t.isIdentifier(prop.value.left)) {
             ids.push({ kind: "Identifier", name: prop.value.left.name });
-          } else if (t.isPattern(prop.value.left)) {
+          } else if (t.isPatternLike(prop.value.left)) {
             ids.push(...extractIdentifiersFromPattern(prop.value.left));
           }
-        } else if (t.isObjectPattern(prop.value) || t.isArrayPattern(prop.value)) {
+        } else if (t.isPatternLike(prop.value)) {
           ids.push(...extractIdentifiersFromPattern(prop.value));
         }
-      } else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-        ids.push({ kind: "Identifier", name: prop.argument.name });
+      } else if (t.isRestElement(prop)) {
+        if (t.isIdentifier(prop.argument)) {
+          ids.push({ kind: "Identifier", name: prop.argument.name });
+        } else if (t.isPatternLike(prop.argument)) {
+          ids.push(...extractIdentifiersFromPattern(prop.argument));
+        }
       }
     }
   } else if (t.isArrayPattern(pattern)) {
@@ -14634,16 +14646,20 @@ function extractIdentifiersFromPattern(pattern) {
       if (!elem) continue;
       if (t.isIdentifier(elem)) {
         ids.push({ kind: "Identifier", name: elem.name });
-      } else if (t.isPattern(elem)) {
+      } else if (t.isRestElement(elem)) {
+        if (t.isIdentifier(elem.argument)) {
+          ids.push({ kind: "Identifier", name: elem.argument.name });
+        } else if (t.isPatternLike(elem.argument)) {
+          ids.push(...extractIdentifiersFromPattern(elem.argument));
+        }
+      } else if (t.isPatternLike(elem)) {
         ids.push(...extractIdentifiersFromPattern(elem));
-      } else if (t.isRestElement(elem) && t.isIdentifier(elem.argument)) {
-        ids.push({ kind: "Identifier", name: elem.argument.name });
       }
     }
   } else if (t.isAssignmentPattern(pattern)) {
     if (t.isIdentifier(pattern.left)) {
       ids.push({ kind: "Identifier", name: pattern.left.name });
-    } else if (t.isPattern(pattern.left)) {
+    } else if (t.isPatternLike(pattern.left)) {
       ids.push(...extractIdentifiersFromPattern(pattern.left));
     }
   }
@@ -14829,8 +14845,12 @@ function convertFunction(name, params, body, options) {
       } else if (t.isObjectPattern(p.left) || t.isArrayPattern(p.left)) {
         paramIds.push(...extractIdentifiersFromPattern(p.left));
       }
-    } else if (t.isRestElement(p) && t.isIdentifier(p.argument)) {
-      paramIds.push({ kind: "Identifier", name: p.argument.name });
+    } else if (t.isRestElement(p)) {
+      if (t.isIdentifier(p.argument)) {
+        paramIds.push({ kind: "Identifier", name: p.argument.name });
+      } else if (t.isPattern(p.argument)) {
+        paramIds.push(...extractIdentifiersFromPattern(p.argument));
+      }
     }
   }
   const bodyStatements = [...body];
@@ -14915,8 +14935,21 @@ function convertFunction(name, params, body, options) {
           const excludeKeys = [];
           decl.id.properties.forEach((prop) => {
             if (t.isObjectProperty(prop)) {
+              if (prop.computed) {
+                reportUnsupportedExpression(
+                  prop.key,
+                  "Computed keys in object destructuring are not supported in HIR conversion."
+                );
+                return;
+              }
               const keyName = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : t.isNumericLiteral(prop.key) ? String(prop.key.value) : null;
-              if (!keyName) return;
+              if (!keyName) {
+                reportUnsupportedExpression(
+                  prop.key,
+                  "Unsupported object destructuring key in HIR conversion."
+                );
+                return;
+              }
               excludeKeys.push(t.stringLiteral(keyName));
               if (t.isIdentifier(prop.value)) {
                 const memberExpr = t.memberExpression(
@@ -14930,8 +14963,21 @@ function convertFunction(name, params, body, options) {
                   value: convertExpression(memberExpr),
                   declarationKind: declKind
                 });
+              } else {
+                reportUnsupportedExpression(
+                  prop.value,
+                  "Unsupported object destructuring pattern in HIR conversion."
+                );
+                return;
+              }
+            } else if (t.isRestElement(prop)) {
+              if (!t.isIdentifier(prop.argument)) {
+                reportUnsupportedExpression(
+                  prop.argument,
+                  "Rest destructuring patterns must be identifiers in HIR conversion."
+                );
+                return;
               }
-            } else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
               const restExpr = t.callExpression(t.identifier("__fictPropsRest"), [
                 useTemp ? t.identifier(tempName) : babelSourceExpr,
                 t.arrayExpression(excludeKeys)
@@ -14942,6 +14988,12 @@ function convertFunction(name, params, body, options) {
                 value: convertExpression(restExpr),
                 declarationKind: declKind
               });
+            } else {
+              reportUnsupportedExpression(
+                prop,
+                "Unsupported object destructuring property in HIR conversion."
+              );
+              return;
             }
           });
         }
@@ -14967,7 +15019,14 @@ function convertFunction(name, params, body, options) {
                 value: convertExpression(memberExpr),
                 declarationKind: declKind
               });
-            } else if (t.isRestElement(elem) && t.isIdentifier(elem.argument)) {
+            } else if (t.isRestElement(elem)) {
+              if (!t.isIdentifier(elem.argument)) {
+                reportUnsupportedExpression(
+                  elem.argument,
+                  "Rest destructuring patterns must be identifiers in HIR conversion."
+                );
+                return;
+              }
               const sliceCall = t.callExpression(
                 t.memberExpression(t.identifier(tempName), t.identifier("slice")),
                 [t.numericLiteral(index)]
@@ -14978,6 +15037,12 @@ function convertFunction(name, params, body, options) {
                 value: convertExpression(sliceCall),
                 declarationKind: declKind
               });
+            } else {
+              reportUnsupportedExpression(
+                elem,
+                "Unsupported array destructuring pattern in HIR conversion."
+              );
+              return;
             }
           });
         }
@@ -15140,11 +15205,15 @@ function convertFunction(name, params, body, options) {
     if (t.isSwitchStatement(stmt)) {
       const exitBlock = createBlock();
       blocks.push(exitBlock.block);
+      const caseBlocks = stmt.cases.map(() => createBlock());
+      for (const caseBlock of caseBlocks) {
+        blocks.push(caseBlock.block);
+      }
       const cases = [];
       let defaultTarget;
-      for (const switchCase of stmt.cases) {
-        const caseBlock = createBlock();
-        blocks.push(caseBlock.block);
+      for (let index = 0; index < stmt.cases.length; index++) {
+        const switchCase = stmt.cases[index];
+        const caseBlock = caseBlocks[index];
         if (switchCase.test) {
           cases.push({
             test: convertExpression(switchCase.test),
@@ -15153,20 +15222,26 @@ function convertFunction(name, params, body, options) {
         } else {
           defaultTarget = caseBlock.block.id;
         }
+      }
+      cfgContext.loopStack.push({
+        breakTarget: exitBlock.block.id
+      });
+      for (let index = 0; index < stmt.cases.length; index++) {
+        const switchCase = stmt.cases[index];
+        const caseBlock = caseBlocks[index];
+        const nextCaseBlock = caseBlocks[index + 1];
+        const fallthroughTarget = nextCaseBlock ? nextCaseBlock.block.id : exitBlock.block.id;
         let caseBuilder = caseBlock;
         for (const s of switchCase.consequent) {
-          if (t.isBreakStatement(s)) {
-            caseBuilder.block.terminator = { kind: "Jump", target: exitBlock.block.id };
-            caseBuilder.sealed = true;
-            break;
-          }
+          if (caseBuilder.sealed) break;
           caseBuilder = processStatement(s, caseBuilder, exitBlock.block.id, cfgContext);
         }
         if (!caseBuilder.sealed) {
-          caseBuilder.block.terminator = { kind: "Jump", target: exitBlock.block.id };
+          caseBuilder.block.terminator = { kind: "Jump", target: fallthroughTarget };
           caseBuilder.sealed = true;
         }
       }
+      cfgContext.loopStack.pop();
       if (defaultTarget === void 0) {
         cases.push({ target: exitBlock.block.id });
       } else {
@@ -15299,6 +15374,10 @@ function convertFunction(name, params, body, options) {
       current = exitBlock;
       continue;
     }
+    current = processStatement(stmt, current, current.block.id, cfgContext);
+    if (current.sealed) {
+      current = startNewBlock();
+    }
   }
   if (!current.sealed) {
     current.block.terminator = { kind: "Unreachable" };
@@ -15385,6 +15464,30 @@ function handleExpressionStatement(expr, push) {
   }
   return false;
 }
+function findBreakContext(ctx, label) {
+  if (label) {
+    for (let i = ctx.loopStack.length - 1; i >= 0; i--) {
+      const entry = ctx.loopStack[i];
+      if (entry?.label === label) return entry;
+    }
+    return void 0;
+  }
+  return ctx.loopStack[ctx.loopStack.length - 1];
+}
+function findContinueContext(ctx, label) {
+  if (label) {
+    for (let i = ctx.loopStack.length - 1; i >= 0; i--) {
+      const entry = ctx.loopStack[i];
+      if (entry?.label === label && entry.continueTarget !== void 0) return entry;
+    }
+    return void 0;
+  }
+  for (let i = ctx.loopStack.length - 1; i >= 0; i--) {
+    const entry = ctx.loopStack[i];
+    if (entry?.continueTarget !== void 0) return entry;
+  }
+  return void 0;
+}
 function fillStatements(stmt, bb, jumpTarget, ctx) {
   if (t.isBlockStatement(stmt)) {
     let current = bb;
@@ -15410,8 +15513,50 @@ function fillStatements(stmt, bb, jumpTarget, ctx) {
   }
   return result;
 }
-function processStatement(stmt, bb, jumpTarget, ctx) {
+function processStatement(stmt, bb, jumpTarget, ctx, labelOverride) {
   const push = (instr) => bb.block.instructions.push(instr);
+  if (t.isLabeledStatement(stmt) && ctx) {
+    const label = stmt.label.name;
+    const body = stmt.body;
+    if (t.isWhileStatement(body) || t.isForStatement(body) || t.isDoWhileStatement(body) || t.isForInStatement(body) || t.isForOfStatement(body) || t.isSwitchStatement(body)) {
+      return processStatement(body, bb, jumpTarget, ctx, label);
+    }
+    ctx.loopStack.push({
+      breakTarget: jumpTarget,
+      label
+    });
+    try {
+      return processStatement(body, bb, jumpTarget, ctx);
+    } finally {
+      ctx.loopStack.pop();
+    }
+  }
+  if (t.isEmptyStatement(stmt)) {
+    return bb;
+  }
+  if (t.isBlockStatement(stmt)) {
+    const shouldScopeLabel = !!labelOverride && !!ctx;
+    if (shouldScopeLabel) {
+      ctx.loopStack.push({
+        breakTarget: jumpTarget,
+        label: labelOverride
+      });
+    }
+    let current = bb;
+    try {
+      for (const inner of stmt.body) {
+        current = processStatement(inner, current, jumpTarget, ctx);
+        if (current.sealed) {
+          return current;
+        }
+      }
+      return current;
+    } finally {
+      if (shouldScopeLabel) {
+        ctx.loopStack.pop();
+      }
+    }
+  }
   if (t.isExpressionStatement(stmt)) {
     if (!handleExpressionStatement(stmt.expression, push)) {
       push({ kind: "Expression", value: convertExpression(stmt.expression) });
@@ -15526,6 +15671,21 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     });
     return bb;
   }
+  if (t.isClassDeclaration(stmt) && stmt.id) {
+    const classExpr = t.classExpression(
+      stmt.id,
+      stmt.superClass,
+      stmt.body,
+      stmt.decorators ?? null
+    );
+    push({
+      kind: "Assign",
+      target: { kind: "Identifier", name: stmt.id.name },
+      value: convertExpression(classExpr),
+      declarationKind: "let"
+    });
+    return bb;
+  }
   if (t.isReturnStatement(stmt)) {
     bb.block.terminator = {
       kind: "Return",
@@ -15544,7 +15704,7 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
   }
   if (t.isBreakStatement(stmt) && ctx) {
     const label = stmt.label?.name;
-    const loopCtx = label ? ctx.loopStack.find((l) => l.label === label) : ctx.loopStack[ctx.loopStack.length - 1];
+    const loopCtx = findBreakContext(ctx, label);
     if (loopCtx) {
       bb.block.terminator = { kind: "Break", target: loopCtx.breakTarget, label };
       bb.sealed = true;
@@ -15556,7 +15716,7 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
   }
   if (t.isContinueStatement(stmt) && ctx) {
     const label = stmt.label?.name;
-    const loopCtx = label ? ctx.loopStack.find((l) => l.label === label) : ctx.loopStack[ctx.loopStack.length - 1];
+    const loopCtx = findContinueContext(ctx, label);
     if (loopCtx) {
       bb.block.terminator = { kind: "Continue", target: loopCtx.continueTarget, label };
       bb.sealed = true;
@@ -15605,7 +15765,8 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     condBlock.sealed = true;
     ctx.loopStack.push({
       breakTarget: exitBlock.block.id,
-      continueTarget: condBlock.block.id
+      continueTarget: condBlock.block.id,
+      label: labelOverride
     });
     fillStatements(stmt.body, bodyBlock, condBlock.block.id, ctx);
     ctx.loopStack.pop();
@@ -15650,8 +15811,9 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     condBlock.sealed = true;
     ctx.loopStack.push({
       breakTarget: exitBlock.block.id,
-      continueTarget: updateBlock.block.id
+      continueTarget: updateBlock.block.id,
       // continue goes to update in for loop
+      label: labelOverride
     });
     fillStatements(stmt.body, bodyBlock, updateBlock.block.id, ctx);
     ctx.loopStack.pop();
@@ -15674,7 +15836,8 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     bb.sealed = true;
     ctx.loopStack.push({
       breakTarget: exitBlock.block.id,
-      continueTarget: condBlock.block.id
+      continueTarget: condBlock.block.id,
+      label: labelOverride
     });
     fillStatements(stmt.body, bodyBlock, condBlock.block.id, ctx);
     ctx.loopStack.pop();
@@ -15722,7 +15885,8 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     bb.sealed = true;
     ctx.loopStack.push({
       breakTarget: exitBlock.block.id,
-      continueTarget: bodyBlock.block.id
+      continueTarget: bodyBlock.block.id,
+      label: labelOverride
     });
     fillStatements(stmt.body, bodyBlock, exitBlock.block.id, ctx);
     ctx.loopStack.pop();
@@ -15762,7 +15926,8 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     bb.sealed = true;
     ctx.loopStack.push({
       breakTarget: exitBlock.block.id,
-      continueTarget: bodyBlock.block.id
+      continueTarget: bodyBlock.block.id,
+      label: labelOverride
     });
     fillStatements(stmt.body, bodyBlock, exitBlock.block.id, ctx);
     ctx.loopStack.pop();
@@ -15771,11 +15936,15 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
   if (t.isSwitchStatement(stmt) && ctx) {
     const exitBlock = ctx.createBlock();
     ctx.blocks.push(exitBlock.block);
+    const caseBlocks = stmt.cases.map(() => ctx.createBlock());
+    for (const caseBlock of caseBlocks) {
+      ctx.blocks.push(caseBlock.block);
+    }
     const cases = [];
     let defaultTarget;
-    for (const switchCase of stmt.cases) {
-      const caseBlock = ctx.createBlock();
-      ctx.blocks.push(caseBlock.block);
+    for (let index = 0; index < stmt.cases.length; index++) {
+      const switchCase = stmt.cases[index];
+      const caseBlock = caseBlocks[index];
       if (switchCase.test) {
         cases.push({
           test: convertExpression(switchCase.test),
@@ -15784,20 +15953,27 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
       } else {
         defaultTarget = caseBlock.block.id;
       }
+    }
+    ctx.loopStack.push({
+      breakTarget: exitBlock.block.id,
+      label: labelOverride
+    });
+    for (let index = 0; index < stmt.cases.length; index++) {
+      const switchCase = stmt.cases[index];
+      const caseBlock = caseBlocks[index];
+      const nextCaseBlock = caseBlocks[index + 1];
+      const fallthroughTarget = nextCaseBlock ? nextCaseBlock.block.id : exitBlock.block.id;
       let current = caseBlock;
       for (const s of switchCase.consequent) {
-        if (t.isBreakStatement(s)) {
-          current.block.terminator = { kind: "Jump", target: exitBlock.block.id };
-          current.sealed = true;
-          break;
-        }
+        if (current.sealed) break;
         current = processStatement(s, current, exitBlock.block.id, ctx);
       }
       if (!current.sealed) {
-        current.block.terminator = { kind: "Jump", target: exitBlock.block.id };
+        current.block.terminator = { kind: "Jump", target: fallthroughTarget };
         current.sealed = true;
       }
     }
+    ctx.loopStack.pop();
     if (defaultTarget === void 0) {
       cases.push({ target: exitBlock.block.id });
     } else {
@@ -15846,30 +16022,41 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
     }
     return exitBlock;
   }
-  if (!bb.sealed) {
-    bb.block.terminator = { kind: "Jump", target: jumpTarget };
-    bb.sealed = true;
-  }
-  return bb;
+  throw new HIRError(`Unsupported statement in HIR lowering: ${stmt.type}`, "BUILD_ERROR", {
+    blockId: bb.block.id
+  });
 }
 function convertExpression(node, options) {
   const loc = getLoc(node);
-  const convertCallArguments = (args, reactiveScope) => args.map((arg) => {
-    if (t.isSpreadElement(arg)) {
-      return {
-        kind: "SpreadElement",
-        argument: convertExpression(arg.argument),
-        loc: getLoc(arg)
-      };
-    }
-    if (t.isExpression(arg)) {
-      if (reactiveScope && arg === args[0] && (t.isArrowFunctionExpression(arg) || t.isFunctionExpression(arg))) {
-        return convertExpression(arg, { reactiveScope });
+  const convertCallArguments = (args, reactiveScope) => {
+    const converted = [];
+    for (const arg of args) {
+      if (t.isSpreadElement(arg)) {
+        converted.push({
+          kind: "SpreadElement",
+          argument: convertExpression(arg.argument),
+          loc: getLoc(arg)
+        });
+        continue;
+      }
+      if (t.isExpression(arg)) {
+        if (reactiveScope && arg === args[0] && (t.isArrowFunctionExpression(arg) || t.isFunctionExpression(arg))) {
+          converted.push(convertExpression(arg, { reactiveScope }));
+          continue;
+        }
+        converted.push(convertExpression(arg));
+        continue;
+      }
+      if (t.isArgumentPlaceholder?.(arg)) {
+        return reportUnsupportedExpression(
+          arg,
+          "Argument placeholders are not supported in HIR conversion."
+        );
       }
-      return convertExpression(arg);
+      return reportUnsupportedExpression(arg, "Unsupported call argument in HIR conversion.");
     }
-    return void 0;
-  }).filter(Boolean);
+    return converted;
+  };
   const resolveReactiveScope = (callee) => {
     const reactiveScopes = activeBuildOptions?.reactiveScopes;
     if (!reactiveScopes || reactiveScopes.size === 0) return void 0;
@@ -15881,6 +16068,9 @@ function convertExpression(node, options) {
     }
     return void 0;
   };
+  if (t.isChainExpression?.(node) || node.type === "ChainExpression") {
+    return convertExpression(node.expression, options);
+  }
   if (t.isParenthesizedExpression(node) && t.isExpression(node.expression)) {
     return convertExpression(node.expression);
   }
@@ -15938,7 +16128,13 @@ function convertExpression(node, options) {
     return call;
   }
   if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-    const propertyNode = t.isPrivateName(node.property) ? t.identifier(node.property.id.name) : node.property;
+    if (t.isPrivateName(node.property)) {
+      return reportUnsupportedExpression(
+        node.property,
+        "Private field access is not supported in HIR conversion."
+      );
+    }
+    const propertyNode = node.property;
     const isOptional = t.isOptionalMemberExpression(node);
     const object = convertExpression(node.object);
     const property = t.isExpression(propertyNode) ? convertExpression(propertyNode) : { kind: "Literal", value: void 0 };
@@ -16004,67 +16200,106 @@ function convertExpression(node, options) {
     return cond;
   }
   if (t.isArrayExpression(node)) {
+    if ((node.elements ?? []).some((el) => el == null)) {
+      return reportUnsupportedExpression(
+        node,
+        "Array literal holes are not supported in HIR conversion. Use explicit undefined values instead."
+      );
+    }
+    const elements = [];
+    for (const el of node.elements ?? []) {
+      if (!el) continue;
+      if (t.isSpreadElement(el)) {
+        elements.push({
+          kind: "SpreadElement",
+          argument: convertExpression(el.argument),
+          loc: getLoc(el)
+        });
+        continue;
+      }
+      if (t.isExpression(el)) {
+        elements.push(convertExpression(el));
+        continue;
+      }
+      return reportUnsupportedExpression(el, "Unsupported array literal element in HIR conversion.");
+    }
     const arr = {
       kind: "ArrayExpression",
-      elements: (node.elements ?? []).map((el) => {
-        if (!el) return void 0;
-        if (t.isSpreadElement(el)) {
-          return {
-            kind: "SpreadElement",
-            argument: convertExpression(el.argument),
-            loc: getLoc(el)
-          };
-        }
-        if (t.isExpression(el)) return convertExpression(el);
-        return void 0;
-      }).filter(Boolean),
+      elements,
       loc
     };
     return arr;
   }
   if (t.isObjectExpression(node)) {
+    const properties = [];
     const obj = {
       kind: "ObjectExpression",
-      properties: node.properties.map((prop) => {
-        if (t.isSpreadElement(prop)) {
-          return {
-            kind: "SpreadElement",
-            argument: convertExpression(prop.argument),
-            loc: getLoc(prop)
-          };
+      properties,
+      loc
+    };
+    for (const prop of node.properties) {
+      if (t.isSpreadElement(prop)) {
+        properties.push({
+          kind: "SpreadElement",
+          argument: convertExpression(prop.argument),
+          loc: getLoc(prop)
+        });
+        continue;
+      }
+      if (t.isObjectMethod(prop)) {
+        const keyExpr = prop.computed ? t.isExpression(prop.key) ? convertExpression(prop.key) : void 0 : t.isIdentifier(prop.key) ? { kind: "Identifier", name: prop.key.name } : t.isStringLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isNumericLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isBigIntLiteral(prop.key) ? { kind: "Literal", value: BigInt(prop.key.value) } : void 0;
+        if (!keyExpr) {
+          return reportUnsupportedExpression(
+            prop.key,
+            "Unsupported object literal key in HIR conversion."
+          );
         }
-        if (t.isObjectMethod(prop)) {
-          if (prop.computed) return void 0;
-          const keyExpr2 = t.isIdentifier(prop.key) ? { kind: "Identifier", name: prop.key.name } : t.isStringLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isNumericLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : void 0;
-          if (!keyExpr2) return void 0;
-          const fnExpr = t.functionExpression(
-            null,
-            prop.params,
-            prop.body,
-            prop.generator,
-            prop.async
+        const fnExpr = t.functionExpression(
+          null,
+          prop.params,
+          prop.body,
+          prop.generator,
+          prop.async
+        );
+        properties.push({
+          kind: "Property",
+          key: keyExpr,
+          value: convertExpression(fnExpr),
+          computed: prop.computed,
+          propertyKind: prop.kind ?? "method",
+          loc: getLoc(prop)
+        });
+        continue;
+      }
+      if (t.isObjectProperty(prop)) {
+        const keyExpr = prop.computed ? t.isExpression(prop.key) ? convertExpression(prop.key) : void 0 : t.isIdentifier(prop.key) ? { kind: "Identifier", name: prop.key.name } : t.isStringLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isNumericLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isBigIntLiteral(prop.key) ? { kind: "Literal", value: BigInt(prop.key.value) } : void 0;
+        if (!keyExpr) {
+          return reportUnsupportedExpression(
+            prop.key,
+            "Unsupported object literal key in HIR conversion."
           );
-          return {
-            kind: "Property",
-            key: keyExpr2,
-            value: convertExpression(fnExpr),
-            loc: getLoc(prop)
-          };
         }
-        if (!t.isObjectProperty(prop) || prop.computed) return void 0;
-        const keyExpr = t.isIdentifier(prop.key) ? { kind: "Identifier", name: prop.key.name } : t.isStringLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : t.isNumericLiteral(prop.key) ? { kind: "Literal", value: prop.key.value } : void 0;
-        if (!keyExpr) return void 0;
-        if (!t.isExpression(prop.value)) return void 0;
-        return {
+        if (!t.isExpression(prop.value)) {
+          return reportUnsupportedExpression(
+            prop.value,
+            "Unsupported object literal value in HIR conversion."
+          );
+        }
+        properties.push({
           kind: "Property",
           key: keyExpr,
           value: convertExpression(prop.value),
+          computed: prop.computed,
           shorthand: prop.shorthand && t.isIdentifier(prop.value),
           loc: getLoc(prop)
-        };
-      }).filter(Boolean),
-      loc
-    };
+        });
+        continue;
+      }
+      return reportUnsupportedExpression(
+        prop,
+        "Unsupported object literal property in HIR conversion."
+      );
+    }
     return obj;
   }
   if (t.isJSXElement(node)) {
@@ -16092,6 +16327,11 @@ function convertExpression(node, options) {
           value: convertJSXElement(child),
           loc: getLoc(child)
         });
+      } else if (t.isJSXSpreadChild(child)) {
+        return reportUnsupportedExpression(
+          child,
+          "JSX spread children are not supported in HIR conversion."
+        );
       } else if (t.isJSXFragment(child)) {
         for (const fragChild of child.children) {
           if (t.isJSXText(fragChild)) {
@@ -16113,6 +16353,11 @@ function convertExpression(node, options) {
               value: convertJSXElement(fragChild),
               loc: getLoc(fragChild)
             });
+          } else if (t.isJSXSpreadChild(fragChild)) {
+            return reportUnsupportedExpression(
+              fragChild,
+              "JSX spread children are not supported in HIR conversion."
+            );
           }
         }
       }
@@ -16308,7 +16553,10 @@ function convertJSXElement(node) {
     tagName = convertJSXMemberExpr(opening.name);
     isComponent = true;
   } else {
-    tagName = "div";
+    return reportUnsupportedExpression(
+      opening.name,
+      `Unsupported JSX tag syntax '${opening.name.type}' in HIR conversion`
+    );
   }
   const attributes = [];
   for (const attr of opening.attributes) {
@@ -16320,17 +16568,33 @@ function convertJSXElement(node) {
         spreadExpr: convertExpression(attr.argument),
         loc: getLoc(attr)
       });
-    } else if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
+    } else if (t.isJSXAttribute(attr)) {
+      const nameNode = attr.name;
+      let attrName = null;
+      if (t.isJSXIdentifier(attr.name)) {
+        attrName = attr.name.name;
+      } else if (t.isJSXNamespacedName(attr.name)) {
+        attrName = `${attr.name.namespace.name}:${attr.name.name.name}`;
+      } else {
+        return reportUnsupportedExpression(
+          nameNode,
+          "Unsupported JSX attribute name in HIR conversion"
+        );
+      }
       let value = null;
       if (attr.value) {
         if (t.isStringLiteral(attr.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);
+        } else if (t.isJSXElement(attr.value)) {
+          value = convertJSXElement(attr.value);
+        } else if (t.isJSXFragment(attr.value)) {
+          value = convertExpression(attr.value);
         }
       }
       attributes.push({
-        name: attr.name.name,
+        name: attrName,
         value,
         loc: getLoc(attr)
       });
@@ -16357,6 +16621,11 @@ function convertJSXElement(node) {
         value: convertJSXElement(child),
         loc: getLoc(child)
       });
+    } else if (t.isJSXSpreadChild(child)) {
+      return reportUnsupportedExpression(
+        child,
+        "JSX spread children are not supported in HIR conversion."
+      );
     } else if (t.isJSXFragment(child)) {
       for (const fragChild of child.children) {
         if (t.isJSXText(fragChild)) {
@@ -16378,6 +16647,11 @@ function convertJSXElement(node) {
             value: convertJSXElement(fragChild),
             loc: getLoc(fragChild)
           });
+        } else if (t.isJSXSpreadChild(fragChild)) {
+          return reportUnsupportedExpression(
+            fragChild,
+            "JSX spread children are not supported in HIR conversion."
+          );
         }
       }
     }
@@ -16613,7 +16887,7 @@ var DiagnosticMessages = {
   ["FICT-R001" /* FICT_R001 */]: "Expression crosses reactive region boundary.",
   ["FICT-R002" /* FICT_R002 */]: "Scope escape detected, value may not be tracked.",
   ["FICT-R003" /* FICT_R003 */]: "Expression cannot be memoized automatically.",
-  ["FICT-R004" /* 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.",
+  ["FICT-R004" /* FICT_R004 */]: "Reactive creation inside non-JSX control flow may not auto-dispose in complex paths. Prefer createScope/runInScope (or JSX-managed regions) for explicit lifecycle control.",
   ["FICT-R005" /* FICT_R005 */]: "Function captures reactive variables from outer scope; pass them as parameters or memoize explicitly to avoid hidden dependencies.",
   ["FICT-X001" /* FICT_X001 */]: "Object is recreated on each render, consider memoizing.",
   ["FICT-X002" /* FICT_X002 */]: "Array is recreated on each render, consider memoizing.",
@@ -16643,7 +16917,7 @@ var DiagnosticSeverities = {
   ["FICT-R001" /* FICT_R001 */]: "info" /* Info */,
   ["FICT-R002" /* FICT_R002 */]: "warning" /* Warning */,
   ["FICT-R003" /* FICT_R003 */]: "info" /* Info */,
-  ["FICT-R004" /* FICT_R004 */]: "warning" /* Warning */,
+  ["FICT-R004" /* FICT_R004 */]: "error" /* Error */,
   ["FICT-R005" /* FICT_R005 */]: "warning" /* Warning */,
   ["FICT-X001" /* FICT_X001 */]: "hint" /* Hint */,
   ["FICT-X002" /* FICT_X002 */]: "hint" /* Hint */,
@@ -17123,7 +17397,11 @@ function rewriteExprWithMap(expr, rewrites) {
           if (p.kind === "SpreadElement") {
             return { ...p, argument: rewriteExprWithMap(p.argument, rewrites) };
           }
-          return { ...p, value: rewriteExprWithMap(p.value, rewrites) };
+          return {
+            ...p,
+            key: p.computed ? rewriteExprWithMap(p.key, rewrites) : p.key,
+            value: rewriteExprWithMap(p.value, rewrites)
+          };
         })
       };
     case "ImportExpression":
@@ -17270,7 +17548,11 @@ function toSSA(fn) {
             if (p.kind === "SpreadElement") {
               return { ...p, argument: renameExpr(p.argument) };
             }
-            return { ...p, value: renameExpr(p.value) };
+            return {
+              ...p,
+              key: p.computed ? renameExpr(p.key) : p.key,
+              value: renameExpr(p.value)
+            };
           })
         };
       default:
@@ -18700,16 +18982,104 @@ function structurizeBranchUntilJoin(ctx, block, term, outerJoin) {
   return ifNode;
 }
 function structurizeSwitch(ctx, block, term) {
+  const uniqueTargets = Array.from(new Set(term.cases.map((c) => c.target)));
+  const joinBlock = findSwitchJoinBlock(ctx, uniqueTargets);
   const cases = [];
+  const emittedBeforeSwitch = new Set(ctx.emitted);
+  const emittedBySwitchCases = /* @__PURE__ */ new Set();
   for (const c of term.cases) {
-    const body = structurizeBlock(ctx, c.target);
-    cases.push({ test: c.test ?? null, body });
+    const caseCtx = {
+      ...ctx,
+      emitted: new Set(emittedBeforeSwitch),
+      processing: new Set(ctx.processing)
+    };
+    const body = joinBlock !== void 0 ? structurizeBlockUntilJoin(caseCtx, c.target, joinBlock) : structurizeBlock(caseCtx, c.target);
+    for (const emittedBlock of caseCtx.emitted) {
+      if (!emittedBeforeSwitch.has(emittedBlock)) {
+        emittedBySwitchCases.add(emittedBlock);
+      }
+    }
+    const normalizedBody = appendSwitchCaseBreak(body);
+    cases.push({ test: c.test ?? null, body: normalizedBody });
   }
-  return {
+  for (const emittedBlock of emittedBySwitchCases) {
+    ctx.emitted.add(emittedBlock);
+  }
+  const switchNode = {
     kind: "switch",
     discriminant: term.discriminant,
     cases
   };
+  if (joinBlock !== void 0 && !ctx.emitted.has(joinBlock)) {
+    const joinNode = structurizeBlock(ctx, joinBlock);
+    return { kind: "sequence", nodes: [switchNode, joinNode] };
+  }
+  return switchNode;
+}
+function findSwitchJoinBlock(ctx, caseTargets) {
+  const uniqueTargets = Array.from(new Set(caseTargets));
+  if (uniqueTargets.length === 0) return void 0;
+  const reachableByCase = uniqueTargets.map(
+    (target) => collectReachableBlocks(ctx, target, /* @__PURE__ */ new Set())
+  );
+  const reachableUnion = /* @__PURE__ */ new Set();
+  for (const set of reachableByCase) {
+    for (const id of set) reachableUnion.add(id);
+  }
+  const minCaseCoverage = uniqueTargets.length > 1 ? 2 : 1;
+  const candidates = [];
+  for (const id of reachableUnion) {
+    if (uniqueTargets.includes(id)) continue;
+    let reachableCases = 0;
+    for (const set of reachableByCase) {
+      if (set.has(id)) reachableCases++;
+    }
+    if (reachableCases < minCaseCoverage) continue;
+    const predecessors = ctx.predecessors.get(id) ?? [];
+    const predecessorCount = predecessors.filter((pred) => reachableUnion.has(pred)).length;
+    candidates.push({
+      id,
+      reachableCases,
+      predecessorCount,
+      isJoinPoint: predecessors.length > 1
+    });
+  }
+  if (candidates.length === 0) return void 0;
+  candidates.sort((a, b) => {
+    if (a.reachableCases !== b.reachableCases) return b.reachableCases - a.reachableCases;
+    if (a.predecessorCount !== b.predecessorCount) return b.predecessorCount - a.predecessorCount;
+    if (a.isJoinPoint !== b.isJoinPoint) return Number(b.isJoinPoint) - Number(a.isJoinPoint);
+    return a.id - b.id;
+  });
+  return candidates[0]?.id;
+}
+function appendSwitchCaseBreak(body) {
+  if (isSwitchCaseTerminated(body)) return body;
+  if (body.kind === "sequence") {
+    return { kind: "sequence", nodes: [...body.nodes, { kind: "break" }] };
+  }
+  return { kind: "sequence", nodes: [body, { kind: "break" }] };
+}
+function isSwitchCaseTerminated(node) {
+  if (!node) return false;
+  switch (node.kind) {
+    case "return":
+    case "throw":
+    case "break":
+    case "continue":
+      return true;
+    case "sequence":
+      return node.nodes.length > 0 && isSwitchCaseTerminated(node.nodes[node.nodes.length - 1]);
+    case "block":
+      return node.statements.length > 0 && isSwitchCaseTerminated(node.statements[node.statements.length - 1]);
+    case "if":
+      return isSwitchCaseTerminated(node.consequent) && isSwitchCaseTerminated(node.alternate ?? void 0);
+    case "try":
+      if (node.finalizer && isSwitchCaseTerminated(node.finalizer)) return true;
+      return isSwitchCaseTerminated(node.block) && isSwitchCaseTerminated(node.handler?.body ?? void 0);
+    default:
+      return false;
+  }
 }
 function structurizeForOf(ctx, block, term) {
   const body = structurizeBlock(ctx, term.body);
@@ -18911,6 +19281,7 @@ function resolveKeySet(expr, ctx, shapes) {
           const values = [];
           for (const prop of arg.properties) {
             if (prop.kind !== "Property") return null;
+            if (prop.computed) return null;
             if (prop.key.kind === "Identifier") {
               values.push(prop.key.name);
             } else if (prop.key.kind === "Literal") {
@@ -19310,7 +19681,10 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
           }
           analyzeExpression(prop.argument, shapes, propertyReads, ctx);
         } else if (prop.kind === "Property") {
-          if (prop.key.kind === "Identifier") {
+          if (prop.computed) {
+            shape.dynamicAccess = true;
+            analyzeExpression(prop.key, shapes, propertyReads, ctx);
+          } else if (prop.key.kind === "Identifier") {
             shape.knownKeys.add(prop.key.name);
           } else if (prop.key.kind === "Literal" && typeof prop.key.value === "string") {
             shape.knownKeys.add(prop.key.value);
@@ -19550,6 +19924,7 @@ function markEscaping(expr, shapes) {
         if (prop.kind === "SpreadElement") {
           markEscaping(prop.argument, shapes);
         } else if (prop.kind === "Property") {
+          if (prop.computed) markEscaping(prop.key, shapes);
           markEscaping(prop.value, shapes);
         }
       }
@@ -19654,7 +20029,7 @@ function expressionContainsReactiveCreation(expr, memoMacroNames) {
       return expr.elements.some((el) => el && expressionContainsReactiveCreation(el, memoMacroNames));
     case "ObjectExpression":
       return expr.properties.some(
-        (prop) => prop.kind === "SpreadElement" ? expressionContainsReactiveCreation(prop.argument, memoMacroNames) : expressionContainsReactiveCreation(prop.value, memoMacroNames)
+        (prop) => prop.kind === "SpreadElement" ? expressionContainsReactiveCreation(prop.argument, memoMacroNames) : prop.computed && expressionContainsReactiveCreation(prop.key, memoMacroNames) || expressionContainsReactiveCreation(prop.value, memoMacroNames)
       );
     case "ArrowFunction":
       if (expr.isExpression) {
@@ -19940,7 +20315,7 @@ function expressionUsesTracked(expr, ctx) {
     case "ObjectExpression":
       return expr.properties.some((p) => {
         if (p.kind === "SpreadElement") return expressionUsesTracked(p.argument, ctx);
-        return expressionUsesTracked(p.value, ctx);
+        return p.computed && expressionUsesTracked(p.key, ctx) || expressionUsesTracked(p.value, ctx);
       });
     case "TemplateLiteral":
       return expr.expressions.some((e) => expressionUsesTracked(e, ctx));
@@ -20033,6 +20408,16 @@ function lowerStructuredNodeInternal(node, t4, ctx, declaredVars, regionResult)
   } : void 0;
   return lowerNodeWithRegionContext(node, t4, ctx, declaredVars, regionCtx);
 }
+function ensureSwitchCaseBreak(stmts, t4) {
+  if (stmts.length === 0) {
+    return stmts;
+  }
+  const tail = stmts[stmts.length - 1];
+  if (tail && (t4.isBreakStatement(tail) || t4.isReturnStatement(tail) || t4.isThrowStatement(tail) || t4.isContinueStatement(tail))) {
+    return stmts;
+  }
+  return [...stmts, t4.breakStatement()];
+}
 function lowerNodeWithRegionContext(node, t4, ctx, declaredVars, regionCtx) {
   switch (node.kind) {
     case "sequence": {
@@ -20222,10 +20607,20 @@ function lowerNodeWithRegionContext(node, t4, ctx, declaredVars, regionCtx) {
       return [t4.forInStatement(left, right, body)];
     }
     case "switch": {
-      const cases = node.cases.map((c) => {
-        const stmts = lowerNodeWithRegionContext(c.body, t4, ctx, declaredVars, regionCtx);
-        return t4.switchCase(c.test ? lowerExpressionWithDeSSA(c.test, ctx) : null, stmts);
-      });
+      const prevConditional = ctx.inConditional ?? 0;
+      ctx.inConditional = prevConditional + 1;
+      let cases;
+      try {
+        cases = node.cases.map((c) => {
+          const stmts = ensureSwitchCaseBreak(
+            lowerNodeWithRegionContext(c.body, t4, ctx, declaredVars, regionCtx),
+            t4
+          );
+          return t4.switchCase(c.test ? lowerExpressionWithDeSSA(c.test, ctx) : null, stmts);
+        });
+      } finally {
+        ctx.inConditional = prevConditional;
+      }
       return [t4.switchStatement(lowerExpressionWithDeSSA(node.discriminant, ctx), cases)];
     }
     case "try": {
@@ -20514,19 +20909,29 @@ function lowerStructuredNodeForRegion(node, region, t4, ctx, declaredVars, regio
       return [t4.forInStatement(left, right, t4.blockStatement(body))];
     }
     case "switch": {
-      const cases = node.cases.map((c) => {
-        const stmts = lowerStructuredNodeForRegion(
-          c.body,
-          region,
-          t4,
-          ctx,
-          declaredVars,
-          regionCtx,
-          skipInstructions
-        );
-        if (stmts.length === 0) return null;
-        return t4.switchCase(c.test ? lowerExpressionWithDeSSA(c.test, ctx) : null, stmts);
-      }).filter((c) => !!c);
+      const prevConditional = ctx.inConditional ?? 0;
+      ctx.inConditional = prevConditional + 1;
+      let cases;
+      try {
+        cases = node.cases.map((c) => {
+          const stmts = ensureSwitchCaseBreak(
+            lowerStructuredNodeForRegion(
+              c.body,
+              region,
+              t4,
+              ctx,
+              declaredVars,
+              regionCtx,
+              skipInstructions
+            ),
+            t4
+          );
+          if (stmts.length === 0) return null;
+          return t4.switchCase(c.test ? lowerExpressionWithDeSSA(c.test, ctx) : null, stmts);
+        }).filter((c) => !!c);
+      } finally {
+        ctx.inConditional = prevConditional;
+      }
       if (cases.length === 0) return [];
       return [t4.switchStatement(lowerExpressionWithDeSSA(node.discriminant, ctx), cases)];
     }
@@ -20979,6 +21384,7 @@ function collectExprDependencies(expr) {
           if (p.kind === "SpreadElement") {
             visit(p.argument);
           } else {
+            if (p.computed) visit(p.key);
             visit(p.value);
           }
         });
@@ -21842,7 +22248,10 @@ function expressionContainsJSX(expr) {
     case "ArrayExpression":
       return expr.elements?.some((el) => expressionContainsJSX(el)) ?? false;
     case "ObjectExpression":
-      return expr.properties?.some((p) => expressionContainsJSX(p.value)) ?? false;
+      return expr.properties?.some((p) => {
+        if (p.kind === "SpreadElement") return expressionContainsJSX(p.argument);
+        return (p.computed ?? false) && expressionContainsJSX(p.key) || expressionContainsJSX(p.value);
+      }) ?? false;
     case "ConditionalExpression":
       return expressionContainsJSX(expr.test) || expressionContainsJSX(expr.consequent) || expressionContainsJSX(expr.alternate);
     case "ArrowFunction":
@@ -21956,7 +22365,7 @@ function expressionHasAwait(expr) {
       return expr.elements.some((el) => el && expressionHasAwait(el));
     case "ObjectExpression":
       return expr.properties.some(
-        (prop) => prop.kind === "Property" && expressionHasAwait(prop.value) || prop.kind === "SpreadElement" && expressionHasAwait(prop.argument)
+        (prop) => prop.kind === "Property" && ((prop.computed ?? false) && expressionHasAwait(prop.key) || expressionHasAwait(prop.value)) || prop.kind === "SpreadElement" && expressionHasAwait(prop.argument)
       );
     case "TemplateLiteral":
       return expr.expressions.some((ex) => expressionHasAwait(ex));
@@ -22027,6 +22436,7 @@ function collectCalledIdentifiers(fn) {
           if (p.kind === "SpreadElement") {
             visitExpr(p.argument);
           } else {
+            if (p.computed) visitExpr(p.key);
             visitExpr(p.value);
           }
         });
@@ -22253,6 +22663,7 @@ function analyzeHookReturnInfo(fn, ctx) {
     if (expr.kind === "ObjectExpression") {
       expr.properties.forEach((prop) => {
         if (prop.kind !== "Property") return;
+        if (prop.computed) return;
         const keyName = prop.key.kind === "Identifier" ? prop.key.name : prop.key.kind === "Literal" ? String(prop.key.value) : void 0;
         if (!keyName) return;
         if (prop.value.kind === "Identifier") {
@@ -22561,6 +22972,7 @@ function collectExpressionIdentifiers(expr, into) {
           collectExpressionIdentifiers(prop.argument, into);
           return;
         }
+        if (prop.computed) collectExpressionIdentifiers(prop.key, into);
         collectExpressionIdentifiers(prop.value, into);
       });
       return;
@@ -22678,6 +23090,7 @@ function collectExpressionIdentifiersDeep(expr, into, bound = /* @__PURE__ */ ne
           collectExpressionIdentifiersDeep(prop.argument, into, bound);
           return;
         }
+        if (prop.computed) collectExpressionIdentifiersDeep(prop.key, into, bound);
         collectExpressionIdentifiersDeep(prop.value, into, bound);
       });
       return;
@@ -24184,6 +24597,28 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
           if (p.kind === "SpreadElement") {
             return t4.spreadElement(lowerExpression(p.argument, ctx));
           }
+          const keyIsIdentifier = !p.computed && p.key.kind === "Identifier";
+          const keyIdent = keyIsIdentifier ? p.key.name : "";
+          const keyNode = p.computed ? lowerExpression(p.key, ctx) : keyIsIdentifier ? t4.identifier(keyIdent) : lowerExpression(p.key, ctx);
+          if (p.propertyKind && p.propertyKind !== "init") {
+            const valueExpr2 = lowerExpression(p.value, ctx);
+            if (!t4.isFunctionExpression(valueExpr2)) {
+              throw new HIRError(
+                `Object method property did not lower to function expression.`,
+                "CODEGEN_ERROR"
+              );
+            }
+            const method = t4.objectMethod(
+              p.propertyKind === "method" ? "method" : p.propertyKind,
+              keyNode,
+              valueExpr2.params,
+              valueExpr2.body,
+              !!p.computed
+            );
+            method.async = valueExpr2.async;
+            method.generator = valueExpr2.generator;
+            return method;
+          }
           const usesTracked = !!ctx.inPropsContext && (!ctx.nonReactiveScopeDepth || ctx.nonReactiveScopeDepth === 0) && p.value.kind !== "ArrowFunction" && p.value.kind !== "FunctionExpression" && expressionUsesTracked(p.value, ctx);
           const valueExprRaw = usesTracked ? lowerTrackedExpression(p.value, ctx) : lowerExpression(p.value, ctx);
           const shouldMemoProp = usesTracked && !t4.isIdentifier(valueExprRaw) && !t4.isMemberExpression(valueExprRaw) && !t4.isLiteral(valueExprRaw);
@@ -24199,13 +24634,11 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
               t4.arrowFunctionExpression([], valueExprRaw)
             ]);
           })() : valueExprRaw;
-          const keyName = p.key.kind === "Identifier" ? p.key.name : String(p.key.value ?? "");
-          const keyNode = p.key.kind === "Identifier" ? t4.identifier(keyName) : t4.stringLiteral(keyName);
-          const useShorthand = p.shorthand && t4.isIdentifier(valueExpr) && p.key.kind === "Identifier" && deSSAVarName(keyName) === valueExpr.name;
+          const useShorthand = p.shorthand && t4.isIdentifier(valueExpr) && keyIsIdentifier && deSSAVarName(keyIdent) === valueExpr.name;
           return t4.objectProperty(
             useShorthand ? t4.identifier(valueExpr.name) : keyNode,
             valueExpr,
-            false,
+            !!p.computed,
             useShorthand
           );
         })
@@ -24675,6 +25108,7 @@ function collectExpressionDependencies(expr, deps) {
       if (p.kind === "SpreadElement") {
         collectExpressionDependencies(p.argument, deps);
       } else {
+        if (p.computed) collectExpressionDependencies(p.key, deps);
         collectExpressionDependencies(p.value, deps);
       }
     });
@@ -25199,6 +25633,7 @@ function countExpressionNodes(expr) {
     case "ObjectExpression":
       for (const prop of expr.properties) {
         if (prop.kind === "Property") {
+          if (prop.computed) count += countExpressionNodes(prop.key);
           count += countExpressionNodes(prop.value);
         } else if (prop.kind === "SpreadElement") {
           count += countExpressionNodes(prop.argument);
@@ -26560,7 +26995,7 @@ function hirExpressionUsesIdentifiers(expr, names) {
         if (prop.kind === "SpreadElement") {
           return hirExpressionUsesIdentifiers(prop.argument, names);
         }
-        return hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
+        return (prop.computed ?? false) && hirExpressionUsesIdentifiers(prop.key, names) || hirExpressionUsesIdentifiers(prop.value, names);
       });
     case "TemplateLiteral":
       return expr.expressions.some((e) => hirExpressionUsesIdentifiers(e, names));
@@ -27370,18 +27805,82 @@ function lowerTopLevelStatementBlock(statements, ctx, t4, name = "__module_segme
 }
 function transformControlFlowReturns(statements, ctx) {
   const { t: t4 } = ctx;
+  const reactiveAccessorNames = /* @__PURE__ */ new Set([
+    ...ctx.trackedVars,
+    ...ctx.signalVars ?? [],
+    ...ctx.memoVars ?? [],
+    ...ctx.aliasVars ?? [],
+    ...ctx.storeVars ?? []
+  ]);
   const toStatements = (node) => t4.isBlockStatement(node) ? node.body : [node];
   const endsWithReturn = (stmts) => {
     if (stmts.length === 0) return false;
     const tail = stmts[stmts.length - 1];
     if (t4.isReturnStatement(tail)) return true;
+    if (t4.isBlockStatement(tail)) {
+      return endsWithReturn(tail.body);
+    }
     if (t4.isIfStatement(tail) && tail.consequent && tail.alternate) {
       const conseqStmts = toStatements(tail.consequent);
       const altStmts = toStatements(tail.alternate);
       return endsWithReturn(conseqStmts) && endsWithReturn(altStmts);
     }
+    if (t4.isTryStatement(tail)) {
+      if (tail.finalizer && endsWithReturn(tail.finalizer.body)) return true;
+      if (!tail.handler) return false;
+      return endsWithReturn(tail.block.body) && endsWithReturn(tail.handler.body.body);
+    }
     return false;
   };
+  function hasNodeMatch(nodes, predicate) {
+    let found = false;
+    const visit = (node) => {
+      if (!node || found) return;
+      if (predicate(node)) {
+        found = true;
+        return;
+      }
+      const keys = t4.VISITOR_KEYS;
+      const visitorKeys = keys?.[node.type] ?? [];
+      for (const key of visitorKeys) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === "object" && "type" in child) {
+              visit(child);
+            }
+            if (found) return;
+          }
+        } else if (value && typeof value === "object" && "type" in value) {
+          visit(value);
+        }
+        if (found) return;
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+      if (found) return true;
+    }
+    return found;
+  }
+  const containsReturnStatement = (nodes) => hasNodeMatch(nodes, (node) => t4.isReturnStatement(node));
+  const containsReactiveAccessorRead = (nodes) => hasNodeMatch(nodes, (node) => {
+    if (!t4.isCallExpression(node) && !t4.isOptionalCallExpression(node)) return false;
+    const callee = node.callee;
+    return t4.isIdentifier(callee) && reactiveAccessorNames.has(callee.name);
+  });
+  const emitControlFlowFallbackWarning = (node, kind) => {
+    const onWarn = ctx.options?.onWarn;
+    if (!onWarn) return;
+    const loc = node.loc?.start;
+    onWarn({
+      code: "FICT-R003" /* FICT_R003 */,
+      message: `Reactive ${kind}-return lowering was skipped for this branch. The branch structure will not update reactively; refactor to a supported ${kind} form or use explicit runtime conditionals.`,
+      fileName: ctx.options?.filename ?? "<unknown>",
+      line: loc?.line ?? 0,
+      column: loc ? loc.column + 1 : 0
+    });
+  };
   function buildReturnBlock(stmts) {
     if (stmts.length === 0) return null;
     for (let i = 0; i < stmts.length; i++) {
@@ -27396,33 +27895,55 @@ function transformControlFlowReturns(statements, ctx) {
     if (!endsWithReturn(stmts)) return null;
     return stmts;
   }
-  function buildBranchFunction(stmts) {
+  function buildBranchFunction(stmts, options) {
     const block = buildReturnBlock(stmts);
     if (!block) return null;
+    if (options?.disallowRenderHooks && containsRenderOnlyHooks(block)) return null;
     return t4.arrowFunctionExpression([], t4.blockStatement(block));
   }
-  function buildConditionalExpr(ifStmt, rest) {
-    const consequentStmts = toStatements(ifStmt.consequent);
-    if (!endsWithReturn(consequentStmts)) return null;
-    let alternateStmts = null;
-    if (ifStmt.alternate) {
-      if (rest.length > 0) return null;
-      alternateStmts = toStatements(ifStmt.alternate);
-      if (!endsWithReturn(alternateStmts)) return null;
-    } else {
-      if (rest.length === 0) return null;
-      alternateStmts = rest;
-      if (!buildReturnBlock(alternateStmts)) return null;
+  function containsRenderOnlyHooks(nodes) {
+    let found = false;
+    const visit = (node) => {
+      if (!node || found) return;
+      if (t4.isCallExpression(node) || t4.isOptionalCallExpression(node)) {
+        const callee = node.callee;
+        if (t4.isIdentifier(callee) && callee.name.startsWith("__fictUse")) {
+          if (callee.name !== "__fictUseEffect") {
+            found = true;
+            return;
+          }
+        }
+      }
+      const keys = t4.VISITOR_KEYS;
+      const visitorKeys = keys?.[node.type] ?? [];
+      for (const key of visitorKeys) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === "object" && "type" in child) {
+              visit(child);
+            }
+            if (found) return;
+          }
+        } else if (value && typeof value === "object" && "type" in value) {
+          visit(value);
+        }
+        if (found) return;
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+      if (found) break;
     }
-    const trueFn = buildBranchFunction(consequentStmts);
-    const falseFn = alternateStmts ? buildBranchFunction(alternateStmts) : null;
-    if (!trueFn || !falseFn) return null;
+    return found;
+  }
+  function buildConditionalBindingExpr(testExpr, trueFn, falseFn) {
     ctx.helpersUsed.add("conditional");
     ctx.helpersUsed.add("createElement");
     ctx.helpersUsed.add("onDestroy");
     const bindingId = genTemp(ctx, "cond");
     const args = [
-      t4.arrowFunctionExpression([], ifStmt.test),
+      t4.arrowFunctionExpression([], testExpr),
       trueFn,
       t4.identifier(RUNTIME_ALIASES.createElement),
       falseFn
@@ -27444,15 +27965,210 @@ function transformControlFlowReturns(statements, ctx) {
       []
     );
   }
-  for (let i = 0; i < statements.length; i++) {
-    const stmt = statements[i];
+  function buildConditionalExpr(ifStmt, rest) {
+    const consequentStmts = toStatements(ifStmt.consequent);
+    if (!endsWithReturn(consequentStmts)) return null;
+    let alternateStmts = null;
+    if (ifStmt.alternate) {
+      if (rest.length > 0) return null;
+      alternateStmts = toStatements(ifStmt.alternate);
+      if (!endsWithReturn(alternateStmts)) return null;
+    } else {
+      if (rest.length === 0) return null;
+      alternateStmts = rest;
+      if (!buildReturnBlock(alternateStmts)) return null;
+    }
+    const trueFn = buildBranchFunction(consequentStmts);
+    const falseFn = alternateStmts ? buildBranchFunction(alternateStmts) : null;
+    if (!trueFn || !falseFn) return null;
+    return buildConditionalBindingExpr(ifStmt.test, trueFn, falseFn);
+  }
+  function isSupportedSwitchDiscriminant(_expr) {
+    return true;
+  }
+  function buildSwitchConditionalExpr(switchStmt, rest) {
+    const discriminant = switchStmt.discriminant;
+    if (!isSupportedSwitchDiscriminant(discriminant)) return null;
+    const trailingStatements = rest.length > 0 ? buildReturnBlock([...rest]) : [];
+    if (rest.length > 0 && !trailingStatements) return null;
+    const caseEntryCache = /* @__PURE__ */ new Map();
+    const resolveCaseEntry = (startIndex) => {
+      if (caseEntryCache.has(startIndex)) {
+        return caseEntryCache.get(startIndex) ?? null;
+      }
+      const entry = [];
+      for (let i = startIndex; i < switchStmt.cases.length; i++) {
+        const currentCase = switchStmt.cases[i];
+        const consequent = currentCase.consequent;
+        for (let stmtIndex = 0; stmtIndex < consequent.length; stmtIndex++) {
+          const stmt = consequent[stmtIndex];
+          if (t4.isBreakStatement(stmt)) {
+            if (stmt.label || stmtIndex !== consequent.length - 1) {
+              caseEntryCache.set(startIndex, null);
+              return null;
+            }
+            if (!trailingStatements || trailingStatements.length === 0) {
+              caseEntryCache.set(startIndex, null);
+              return null;
+            }
+            const withTrailing2 = [...entry, ...trailingStatements];
+            caseEntryCache.set(startIndex, withTrailing2);
+            return withTrailing2;
+          }
+          if (t4.isContinueStatement(stmt)) {
+            caseEntryCache.set(startIndex, null);
+            return null;
+          }
+          entry.push(stmt);
+        }
+        if (endsWithReturn(entry)) {
+          caseEntryCache.set(startIndex, entry);
+          return entry;
+        }
+      }
+      if (!trailingStatements || trailingStatements.length === 0) {
+        caseEntryCache.set(startIndex, null);
+        return null;
+      }
+      const withTrailing = [...entry, ...trailingStatements];
+      caseEntryCache.set(startIndex, withTrailing);
+      return withTrailing;
+    };
+    const branches = [];
+    let defaultStatements = null;
+    for (let i = 0; i < switchStmt.cases.length; i++) {
+      const caseNode = switchStmt.cases[i];
+      const statements2 = resolveCaseEntry(i);
+      if (!statements2) return null;
+      if (caseNode.test) {
+        branches.push({
+          tests: [caseNode.test],
+          statements: statements2
+        });
+      } else {
+        defaultStatements = statements2;
+      }
+    }
+    if (branches.length === 0 && !defaultStatements) return null;
+    const fallbackStatements = defaultStatements ?? trailingStatements;
+    if (!fallbackStatements || fallbackStatements.length === 0) return null;
+    const fallbackFn = buildBranchFunction(fallbackStatements, { disallowRenderHooks: true });
+    if (!fallbackFn) return null;
+    ctx.helpersUsed.add("memo");
+    const discriminantAccessor = genTemp(ctx, "switchDisc");
+    const discriminantMemoDecl = t4.variableDeclaration("const", [
+      t4.variableDeclarator(
+        discriminantAccessor,
+        t4.callExpression(t4.identifier(RUNTIME_ALIASES.memo), [
+          t4.arrowFunctionExpression(
+            [],
+            t4.cloneNode(discriminant, true)
+          )
+        ])
+      )
+    ]);
+    let currentExpr = t4.callExpression(
+      t4.arrowFunctionExpression(
+        [],
+        t4.blockStatement(fallbackFn.body.body)
+      ),
+      []
+    );
+    for (let i = branches.length - 1; i >= 0; i--) {
+      const branch = branches[i];
+      const trueFn = buildBranchFunction(branch.statements, { disallowRenderHooks: true });
+      if (!trueFn) return null;
+      const falseFn = t4.arrowFunctionExpression(
+        [],
+        t4.blockStatement([t4.returnStatement(currentExpr)])
+      );
+      const comparisons = branch.tests.map(
+        (test) => t4.binaryExpression(
+          "===",
+          t4.callExpression(t4.cloneNode(discriminantAccessor), []),
+          t4.cloneNode(test, true)
+        )
+      );
+      if (comparisons.length === 0) return null;
+      const testExpr = comparisons.slice(1).reduce(
+        (acc, expr) => t4.logicalExpression("||", acc, expr),
+        comparisons[0]
+      );
+      currentExpr = buildConditionalBindingExpr(testExpr, trueFn, falseFn);
+    }
+    return t4.callExpression(
+      t4.arrowFunctionExpression(
+        [],
+        t4.blockStatement([discriminantMemoDecl, t4.returnStatement(currentExpr)])
+      ),
+      []
+    );
+  }
+  let nestedChanged = false;
+  const rewrittenStatements = statements.map((stmt) => {
+    if (!t4.isTryStatement(stmt)) return stmt;
+    const transformedTryBlock = transformControlFlowReturns(stmt.block.body, ctx);
+    const nextTryBlockBody = transformedTryBlock ?? stmt.block.body;
+    let nextHandler = stmt.handler;
+    if (stmt.handler) {
+      const transformedCatchBlock = transformControlFlowReturns(stmt.handler.body.body, ctx);
+      if (transformedCatchBlock) {
+        nextHandler = t4.catchClause(
+          stmt.handler.param ? t4.cloneNode(stmt.handler.param, true) : null,
+          t4.blockStatement(transformedCatchBlock)
+        );
+      }
+    }
+    let nextFinalizer = stmt.finalizer;
+    if (stmt.finalizer) {
+      const transformedFinalizer = transformControlFlowReturns(stmt.finalizer.body, ctx);
+      if (transformedFinalizer) {
+        nextFinalizer = t4.blockStatement(transformedFinalizer);
+      }
+    }
+    if (!transformedTryBlock && nextHandler === stmt.handler && nextFinalizer === stmt.finalizer) {
+      return stmt;
+    }
+    nestedChanged = true;
+    return t4.tryStatement(
+      t4.blockStatement(nextTryBlockBody),
+      nextHandler,
+      nextFinalizer ? t4.cloneNode(nextFinalizer, true) : null
+    );
+  });
+  for (let i = 0; i < rewrittenStatements.length; i++) {
+    const stmt = rewrittenStatements[i];
     if (!t4.isIfStatement(stmt)) continue;
-    const conditionalExpr = buildConditionalExpr(stmt, statements.slice(i + 1));
-    if (!conditionalExpr) continue;
-    const prefix = statements.slice(0, i);
+    const rest = rewrittenStatements.slice(i + 1);
+    const conditionalExpr = buildConditionalExpr(stmt, rest);
+    if (!conditionalExpr) {
+      const hasReturn = containsReturnStatement([stmt, ...rest]);
+      const hasReactiveReads = containsReactiveAccessorRead([stmt, ...rest]);
+      if (hasReturn && hasReactiveReads) {
+        emitControlFlowFallbackWarning(stmt, "if");
+      }
+      continue;
+    }
+    const prefix = rewrittenStatements.slice(0, i);
     return [...prefix, t4.returnStatement(conditionalExpr)];
   }
-  return null;
+  for (let i = 0; i < rewrittenStatements.length; i++) {
+    const stmt = rewrittenStatements[i];
+    if (!t4.isSwitchStatement(stmt)) continue;
+    const rest = rewrittenStatements.slice(i + 1);
+    const conditionalExpr = buildSwitchConditionalExpr(stmt, rest);
+    if (!conditionalExpr) {
+      const hasReturn = containsReturnStatement([stmt, ...rest]);
+      const hasReactiveReads = containsReactiveAccessorRead([stmt, ...rest]);
+      if (hasReturn && hasReactiveReads) {
+        emitControlFlowFallbackWarning(stmt, "switch");
+      }
+      continue;
+    }
+    const prefix = rewrittenStatements.slice(0, i);
+    return [...prefix, t4.returnStatement(conditionalExpr)];
+  }
+  return nestedChanged ? rewrittenStatements : null;
 }
 function lowerFunctionWithRegions(fn, ctx, options) {
   const { t: t4 } = ctx;
@@ -28314,6 +29030,7 @@ function collectRootNodesFromExpression(expr, onBinding, onEffect) {
           if (prop.kind === "SpreadElement") {
             visit(prop.argument, shadowed);
           } else {
+            if (prop.computed) visit(prop.key, shadowed);
             visit(prop.value, shadowed);
           }
         });
@@ -28458,6 +29175,14 @@ function collectDependenciesFromExpression(expr, deps, includeFunctionBodies, sh
             shadowed
           );
         } else {
+          if (prop.computed) {
+            collectDependenciesFromExpression(
+              prop.key,
+              deps,
+              includeFunctionBodies,
+              shadowed
+            );
+          }
           collectDependenciesFromExpression(
             prop.value,
             deps,
@@ -29420,7 +30145,7 @@ function expressionDependsOnReactive(expr, ctx) {
         if (prop.kind === "SpreadElement") {
           return expressionDependsOnReactive(prop.argument, ctx);
         }
-        return expressionDependsOnReactive(prop.value, ctx);
+        return prop.computed && expressionDependsOnReactive(prop.key, ctx) || expressionDependsOnReactive(prop.value, ctx);
       });
     case "TemplateLiteral":
       return expr.expressions.some((e) => expressionDependsOnReactive(e, ctx));
@@ -29520,6 +30245,7 @@ function collectWriteTargets(expr) {
           if (prop.kind === "SpreadElement") {
             visit(prop.argument);
           } else {
+            if (prop.computed) visit(prop.key);
             visit(prop.value);
           }
         });
@@ -29593,6 +30319,7 @@ function collectMemberCallTargets(expr) {
           if (prop.kind === "SpreadElement") {
             visit(prop.argument);
           } else {
+            if (prop.computed) visit(prop.key);
             visit(prop.value);
           }
         });
@@ -29720,7 +30447,7 @@ function expressionContainsImpureMarkers(expr) {
         if (prop.kind === "SpreadElement") {
           return expressionContainsImpureMarkers(prop.argument);
         }
-        return expressionContainsImpureMarkers(prop.value);
+        return prop.computed && expressionContainsImpureMarkers(prop.key) || expressionContainsImpureMarkers(prop.value);
       });
     case "TemplateLiteral":
       return expr.expressions.some((e) => expressionContainsImpureMarkers(e));
@@ -29925,6 +30652,7 @@ function extractConstObjectFields(expr, constants) {
   const fields = /* @__PURE__ */ new Map();
   for (const prop of expr.properties) {
     if (prop.kind === "SpreadElement") return null;
+    if (prop.computed) return null;
     const key = getObjectLiteralKey(prop.key);
     if (!key) return null;
     const value = evaluateLiteral(prop.value, constants);
@@ -30052,6 +30780,7 @@ function replaceConstMemberExpressions(expr, constObjects, constArrays) {
           }
           return {
             ...prop,
+            key: prop.computed ? replaceConstMemberExpressions(prop.key, constObjects, constArrays) : prop.key,
             value: replaceConstMemberExpressions(
               prop.value,
               constObjects,
@@ -30302,6 +31031,7 @@ function simplifyChildren(expr, constants, options) {
           if (prop.kind === "Property") {
             return {
               ...prop,
+              key: prop.computed ? simplifyAlgebraically(prop.key, constants, options) : prop.key,
               value: simplifyAlgebraically(prop.value, constants, options)
             };
           }
@@ -30420,8 +31150,8 @@ function replaceIdentifiersWithConstants(expr, constants, context = {}) {
           }
           return {
             ...prop,
-            value: replaceIdentifiersWithConstants(prop.value, constants),
-            key: prop.key
+            key: prop.computed ? replaceIdentifiersWithConstants(prop.key, constants) : prop.key,
+            value: replaceIdentifiersWithConstants(prop.value, constants)
           };
         })
       };
@@ -30973,6 +31703,7 @@ function walkExpression(expr, add, ctx) {
         if (prop.kind === "SpreadElement") {
           walkExpression(prop.argument, add, ctx);
         } else {
+          if (prop.computed) walkExpression(prop.key, add, ctx);
           walkExpression(prop.value, add, ctx);
         }
       });
@@ -31112,7 +31843,9 @@ function hashExpression(expr) {
       return `arr:${expr.elements.map((el) => el ? hashExpression(el) : "null").join(",")}`;
     case "ObjectExpression":
       return `obj:${expr.properties.map(
-        (p) => p.kind === "SpreadElement" ? `...${hashExpression(p.argument)}` : `${hashExpression(p.key)}:${hashExpression(p.value)}`
+        (p) => p.kind === "SpreadElement" ? `...${hashExpression(p.argument)}` : `${p.computed ? "[]" : "."}${hashExpression(p.key)}:${hashExpression(
+          p.value
+        )}`
       ).join(",")}`;
     case "TemplateLiteral":
       return `tpl:${expr.quasis.join("|")}:${expr.expressions.map((e) => hashExpression(e)).join("|")}`;
@@ -31159,7 +31892,7 @@ function isPureExpression(expr, ctx) {
     case "ObjectExpression":
       return expr.properties.every((prop) => {
         if (prop.kind === "SpreadElement") return isPureExpression(prop.argument, ctx);
-        return isPureExpression(prop.value, ctx);
+        return (!prop.computed || isPureExpression(prop.key, ctx)) && isPureExpression(prop.value, ctx);
       });
     case "MemberExpression":
     case "OptionalMemberExpression":
@@ -31371,7 +32104,7 @@ function replaceIdentifier(expr, target, replacement, inFunctionBody) {
           }
           return {
             ...prop,
-            key: prop.key,
+            key: prop.computed ? replaceIdentifier(prop.key, target, replacement, inFunctionBody) : prop.key,
             value: replaceIdentifier(prop.value, target, replacement, inFunctionBody)
           };
         })
@@ -31706,7 +32439,9 @@ function shouldSuppressWarning(suppressions, code, line) {
     return entry.codes.has(code);
   });
 }
+var DEFAULT_ERROR_WARNING_CODES = /* @__PURE__ */ new Set(["FICT-R004"]);
 function hasErrorEscalation(options) {
+  if (DEFAULT_ERROR_WARNING_CODES.size > 0) return true;
   if (options.warningsAsErrors === true) return true;
   if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.length > 0) return true;
   if (options.warningLevels) {
@@ -31721,6 +32456,7 @@ function resolveWarningLevel(code, options) {
   if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.includes(code)) {
     return "error";
   }
+  if (DEFAULT_ERROR_WARNING_CODES.has(code)) return "error";
   return "warn";
 }
 function formatWarningAsError(warning) {
@@ -31834,18 +32570,66 @@ function isDynamicPropertyAccess(node, t4) {
   if (!node.computed) return false;
   return !(t4.isStringLiteral(node.property) || t4.isNumericLiteral(node.property));
 }
-function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4) {
-  const isStateRoot = (expr) => {
+function runWarningPass(programPath, stateBindingIds, stateRootBindingIds, reactiveBindingIds, effectMacroNames, warn, fileName, t4) {
+  const hasTrackedBinding = (path2, name, tracked) => {
+    const binding = path2.scope.getBinding(name);
+    return !!(binding && tracked.has(binding.identifier));
+  };
+  const isStateRoot = (expr, path2) => {
+    const root = getRootIdentifier(expr, t4);
+    if (!root) return false;
+    return hasTrackedBinding(path2, root.name, stateRootBindingIds);
+  };
+  const isReactiveRoot = (expr, path2) => {
     const root = getRootIdentifier(expr, t4);
-    return !!(root && stateVars.has(root.name));
+    if (!root) return false;
+    return hasTrackedBinding(path2, root.name, reactiveBindingIds);
+  };
+  const argumentHasReactive = (argPath) => {
+    if (argPath.isSpreadElement()) {
+      const inner = argPath.get("argument");
+      return argumentHasReactive(inner);
+    }
+    if (argPath.isJSXElement() || argPath.isJSXFragment()) return false;
+    if (argPath.isIdentifier()) {
+      return hasTrackedBinding(argPath, argPath.node.name, reactiveBindingIds);
+    }
+    if (!argPath.isExpression()) return false;
+    let found = false;
+    argPath.traverse({
+      Function(path2) {
+        path2.skip();
+      },
+      JSXElement(path2) {
+        path2.skip();
+      },
+      JSXFragment(path2) {
+        path2.skip();
+      },
+      Identifier(idPath) {
+        if (idPath.parentPath.isMemberExpression({ property: idPath.node }) && !idPath.parent.computed) {
+          return;
+        }
+        if (idPath.parentPath.isObjectProperty({ key: idPath.node }) && !idPath.parent.computed && !idPath.parent.shorthand) {
+          return;
+        }
+        const binding = idPath.scope.getBinding(idPath.node.name);
+        if (binding && reactiveBindingIds.has(binding.identifier)) {
+          found = true;
+          idPath.stop();
+        }
+      }
+    });
+    return found;
   };
-  const reactiveNames = /* @__PURE__ */ new Set([...stateVars, ...derivedVars]);
   programPath.traverse({
     AssignmentExpression(path2) {
       const { left } = path2.node;
       if (t4.isIdentifier(left)) return;
       if (t4.isMemberExpression(left) || t4.isOptionalMemberExpression(left)) {
-        if (isStateRoot(left.object)) {
+        const stateRoot = isStateRoot(left.object, path2);
+        const reactiveRoot = isReactiveRoot(left.object, path2);
+        if (stateRoot || reactiveRoot) {
           emitWarning(
             path2.node,
             "FICT-M",
@@ -31862,13 +32646,16 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
               fileName
             );
           }
+          return;
         }
       }
     },
     UpdateExpression(path2) {
       const arg = path2.node.argument;
       if (t4.isMemberExpression(arg) || t4.isOptionalMemberExpression(arg)) {
-        if (isStateRoot(arg.object)) {
+        const stateRoot = isStateRoot(arg.object, path2);
+        const reactiveRoot = isReactiveRoot(arg.object, path2);
+        if (stateRoot || reactiveRoot) {
           emitWarning(
             path2.node,
             "FICT-M",
@@ -31885,6 +32672,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
               fileName
             );
           }
+          return;
         }
       }
     },
@@ -31892,7 +32680,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       if (!path2.node.computed) return;
       if (path2.parentPath.isAssignmentExpression({ left: path2.node })) return;
       if (path2.parentPath.isUpdateExpression({ argument: path2.node })) return;
-      if (isDynamicPropertyAccess(path2.node, t4) && isStateRoot(path2.node.object)) {
+      if (isDynamicPropertyAccess(path2.node, t4) && isReactiveRoot(path2.node.object, path2)) {
         emitWarning(
           path2.node,
           "FICT-H",
@@ -31912,9 +32700,9 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
           },
           Identifier(idPath) {
             const name = idPath.node.name;
-            if (!reactiveNames.has(name)) return;
             const binding = idPath.scope.getBinding(name);
             if (!binding) return;
+            if (!reactiveBindingIds.has(binding.identifier)) return;
             if (binding.scope === idPath.scope || binding.scope === path2.scope) return;
             captured.add(name);
           }
@@ -31932,7 +32720,8 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       }
     },
     CallExpression(path2) {
-      if (t4.isIdentifier(path2.node.callee, { name: "$effect" })) {
+      const isEffect = isEffectCall(path2.node, t4, effectMacroNames);
+      if (isEffect) {
         const argPath = path2.get("arguments.0");
         if (argPath?.isFunctionExpression() || argPath?.isArrowFunctionExpression()) {
           let hasReactiveDependency = false;
@@ -31946,7 +32735,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
               }
               const binding = idPath.scope.getBinding(idPath.node.name);
               if (binding && binding.scope === argPath.scope) return;
-              if (stateVars.has(idPath.node.name) || derivedVars.has(idPath.node.name)) {
+              if (binding && reactiveBindingIds.has(binding.identifier)) {
                 hasReactiveDependency = true;
                 idPath.stop();
               }
@@ -31976,13 +32765,16 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       }
       const isSafe = calleeName && SAFE_FUNCTIONS.has(calleeName);
       if (isSafe) return;
-      for (const arg of path2.node.arguments) {
-        if (!t4.isExpression(arg)) continue;
-        if (isStateRoot(arg)) {
+      const argPaths = path2.get("arguments");
+      for (const argPath of argPaths) {
+        if (argPath.isIdentifier() && hasTrackedBinding(argPath, argPath.node.name, stateBindingIds)) {
+          continue;
+        }
+        if (argumentHasReactive(argPath)) {
           emitWarning(
-            arg,
-            "FICT-H",
-            "State value passed to unknown function (black box); dependency tracking may be imprecise",
+            argPath.node,
+            "FICT-R002",
+            "Reactive value escapes scope when passed to an unknown function; dependency tracking may be imprecise",
             warn,
             fileName
           );
@@ -31994,7 +32786,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       if (!path2.node.computed) return;
       if (path2.parentPath.isAssignmentExpression({ left: path2.node })) return;
       if (path2.parentPath.isUpdateExpression({ argument: path2.node })) return;
-      if (isDynamicPropertyAccess(path2.node, t4) && isStateRoot(path2.node.object)) {
+      if (isDynamicPropertyAccess(path2.node, t4) && isReactiveRoot(path2.node.object, path2)) {
         emitWarning(
           path2.node,
           "FICT-H",
@@ -32123,6 +32915,17 @@ function createHIREntrypointVisitor(t4, options) {
           const name = getFunctionName(fnPath);
           return name && isComponentName2(name) || isHookName2(name) || functionHasJSX(fnPath) || functionUsesStateLike(fnPath, t4);
         };
+        const isBoundDefinition = (fnPath) => fnPath.isFunctionDeclaration() || fnPath.parentPath.isVariableDeclarator() && fnPath.parentPath.node.init === fnPath.node;
+        const isExportDefaultDefinition = (fnPath) => fnPath.parentPath?.isExportDefaultDeclaration() && fnPath.parentPath.node.declaration === fnPath.node;
+        const isNamedComponentOrHookDefinition = (fnPath) => {
+          if (!isBoundDefinition(fnPath)) return false;
+          const name = getFunctionName(fnPath);
+          return !!name && (isComponentName2(name) || isHookName2(name));
+        };
+        const isComponentDefinitionForProps = (fnPath) => {
+          if (!isComponentDefinition(fnPath)) return false;
+          return isBoundDefinition(fnPath) || isExportDefaultDefinition(fnPath);
+        };
         const memoHasSideEffects = (fn) => {
           const pureCalls = new Set(
             Array.from(SAFE_FUNCTIONS).filter(
@@ -32243,6 +33046,7 @@ function createHIREntrypointVisitor(t4, options) {
         const stateMacroNames = /* @__PURE__ */ new Set(["$state"]);
         const effectMacroNames = /* @__PURE__ */ new Set(["$effect"]);
         const memoMacroNames = /* @__PURE__ */ new Set(["$memo", "createMemo"]);
+        const importedReactiveBindingIds = /* @__PURE__ */ new Set();
         path2.traverse({
           ImportDeclaration(importPath) {
             if (importPath.node.source.value !== "fict" && importPath.node.source.value !== "fict/slim")
@@ -32263,6 +33067,44 @@ function createHIREntrypointVisitor(t4, options) {
             }
           }
         });
+        path2.traverse({
+          ImportDeclaration(importPath) {
+            const meta = resolveModuleMetadata(
+              importPath.node.source.value,
+              fileName,
+              optionsWithWarnings
+            );
+            if (!meta) return;
+            const hasReactiveExports = Object.keys(meta.exports).length > 0;
+            for (const spec of importPath.node.specifiers) {
+              if (t4.isImportSpecifier(spec)) {
+                const importedName = t4.isIdentifier(spec.imported) ? spec.imported.name : String(spec.imported.value);
+                if (meta.exports[importedName]) {
+                  const binding = importPath.scope.getBinding(spec.local.name);
+                  if (binding) {
+                    importedReactiveBindingIds.add(binding.identifier);
+                  }
+                }
+                continue;
+              }
+              if (t4.isImportDefaultSpecifier(spec)) {
+                if (meta.exports.default) {
+                  const binding = importPath.scope.getBinding(spec.local.name);
+                  if (binding) {
+                    importedReactiveBindingIds.add(binding.identifier);
+                  }
+                }
+                continue;
+              }
+              if (t4.isImportNamespaceSpecifier(spec) && hasReactiveExports) {
+                const binding = importPath.scope.getBinding(spec.local.name);
+                if (binding) {
+                  importedReactiveBindingIds.add(binding.identifier);
+                }
+              }
+            }
+          }
+        });
         path2.traverse({
           JSXExpressionContainer(exprPath) {
             const expr = exprPath.node.expression;
@@ -32273,10 +33115,10 @@ function createHIREntrypointVisitor(t4, options) {
             const cb = expr.arguments[0];
             if (!cb || !t4.isArrowFunctionExpression(cb) && !t4.isFunctionExpression(cb)) return;
             const getReturnedJsx = (fn) => {
-              if (t4.isJSXElement(fn.body)) return fn.body;
+              if (t4.isJSXElement(fn.body) || t4.isJSXFragment(fn.body)) return fn.body;
               if (t4.isBlockStatement(fn.body)) {
                 const ret = fn.body.body.find((stmt) => t4.isReturnStatement(stmt));
-                if (ret && t4.isReturnStatement(ret) && ret.argument && t4.isJSXElement(ret.argument)) {
+                if (ret && t4.isReturnStatement(ret) && ret.argument && (t4.isJSXElement(ret.argument) || t4.isJSXFragment(ret.argument))) {
                   return ret.argument;
                 }
               }
@@ -32284,6 +33126,16 @@ function createHIREntrypointVisitor(t4, options) {
             };
             const jsx = getReturnedJsx(cb);
             if (!jsx) return;
+            if (t4.isJSXFragment(jsx)) {
+              warn({
+                code: "FICT-J002",
+                message: "Missing key prop in list rendering.",
+                fileName,
+                line: expr.loc?.start.line ?? 0,
+                column: expr.loc ? expr.loc.start.column + 1 : 0
+              });
+              return;
+            }
             let hasKey = false;
             let hasUnknownSpread = false;
             for (const attr of jsx.openingElement.attributes) {
@@ -32306,8 +33158,48 @@ function createHIREntrypointVisitor(t4, options) {
           }
         });
         const stateVars = /* @__PURE__ */ new Set();
-        const derivedVars = /* @__PURE__ */ new Set();
+        const stateBindingIds = /* @__PURE__ */ new Set();
+        const derivedBindingIds = /* @__PURE__ */ new Set();
         const destructuredAliases = /* @__PURE__ */ new Set();
+        const aliasBindingIds = /* @__PURE__ */ new Set();
+        const stateAliasBindingIds = /* @__PURE__ */ new Set();
+        const propsBindingIds = /* @__PURE__ */ new Set();
+        const hasTrackedBinding = (path3, name, tracked) => {
+          const binding = path3.scope.getBinding(name);
+          return !!(binding && tracked.has(binding.identifier));
+        };
+        const trackBindingByName = (path3, name, tracked) => {
+          const binding = path3.scope.getBinding(name);
+          if (binding) tracked.add(binding.identifier);
+        };
+        const hasReactiveAliasSourceBinding = (path3, name) => hasTrackedBinding(path3, name, stateBindingIds) || hasTrackedBinding(path3, name, derivedBindingIds) || hasTrackedBinding(path3, name, aliasBindingIds) || hasTrackedBinding(path3, name, destructuredAliases) || hasTrackedBinding(path3, name, importedReactiveBindingIds);
+        const hasStateRootBinding = (path3, name) => hasTrackedBinding(path3, name, stateBindingIds) || hasTrackedBinding(path3, name, stateAliasBindingIds);
+        const unwrapIdentifier = (node) => {
+          if (!node) return null;
+          let current = node;
+          while (true) {
+            if (t4.isTSAsExpression(current)) {
+              current = current.expression;
+              continue;
+            }
+            if (t4.isTSNonNullExpression(current)) {
+              current = current.expression;
+              continue;
+            }
+            if (t4.isTypeCastExpression?.(current)) {
+              current = current.expression;
+              continue;
+            }
+            break;
+          }
+          return t4.isIdentifier(current) ? current : null;
+        };
+        const isStateRootIdentifier = (exprPath) => {
+          if (!exprPath) return null;
+          const id = unwrapIdentifier(exprPath.node);
+          if (!id) return null;
+          return hasStateRootBinding(exprPath, id.name) ? id : null;
+        };
         path2.traverse({
           VariableDeclarator(varPath) {
             const init = varPath.node.init;
@@ -32343,6 +33235,7 @@ For module-level shared state, use one of these alternatives:
                 );
               }
               stateVars.add(varPath.node.id.name);
+              trackBindingByName(varPath, varPath.node.id.name, stateBindingIds);
               if (isInsideLoop(varPath) || isInsideConditional(varPath)) {
                 throw varPath.buildCodeFrameError(
                   `$state() cannot be declared inside loops or conditionals.
@@ -32365,25 +33258,36 @@ or extract the nested logic into a custom hook (useXxx).`
                 let dependsOnState = false;
                 varPath.get("init").traverse({
                   Identifier(idPath) {
-                    if (stateVars.has(idPath.node.name)) {
+                    if (hasTrackedBinding(idPath, idPath.node.name, stateBindingIds)) {
                       dependsOnState = true;
                       idPath.stop();
                     }
                   }
                 });
                 if (dependsOnState) {
-                  derivedVars.add(varPath.node.id.name);
+                  trackBindingByName(varPath, varPath.node.id.name, derivedBindingIds);
                 }
               }
-            } else if ((t4.isObjectPattern(varPath.node.id) || t4.isArrayPattern(varPath.node.id)) && t4.isIdentifier(init) && stateVars.has(init.name)) {
-              collectPatternIdentifiers(varPath.node.id).forEach((id) => destructuredAliases.add(id));
             }
           },
           Function(fnPath) {
+            if (isComponentDefinitionForProps(fnPath)) {
+              for (const param of fnPath.node.params) {
+                if (t4.isIdentifier(param)) {
+                  trackBindingByName(fnPath, param.name, propsBindingIds);
+                  continue;
+                }
+                if (t4.isPatternLike(param)) {
+                  collectPatternIdentifiers(param).forEach(
+                    (name) => trackBindingByName(fnPath, name, propsBindingIds)
+                  );
+                }
+              }
+            }
             const parentFn = fnPath.getFunctionParent();
             if (!parentFn) return;
             if (!isComponentLike(parentFn)) return;
-            if (!isComponentLike(fnPath)) return;
+            if (!isNamedComponentOrHookDefinition(fnPath)) return;
             emitWarning(
               fnPath.node,
               "FICT-C003",
@@ -32478,7 +33382,7 @@ or extract the nested logic into a custom hook (useXxx).`
               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.",
+                "Reactive creation inside non-JSX control flow may not auto-dispose in complex paths. Prefer createScope/runInScope (or JSX-managed regions) for explicit lifecycle control.",
                 warn,
                 fileName
               );
@@ -32512,7 +33416,7 @@ or extract the nested logic into a custom hook (useXxx).`
               "createEffect"
             ]);
             callPath.node.arguments.forEach((arg) => {
-              if (t4.isIdentifier(arg) && stateVars.has(arg.name) && (!calleeId || !allowedStateCallees.has(calleeId))) {
+              if (t4.isIdentifier(arg) && hasTrackedBinding(callPath, arg.name, stateBindingIds) && (!calleeId || !allowedStateCallees.has(calleeId))) {
                 const loc = arg.loc?.start ?? callPath.node.loc?.start;
                 warn({
                   code: "FICT-S002",
@@ -32540,15 +33444,42 @@ or extract the nested logic into a custom hook (useXxx).`
         });
         const aliasStack = [/* @__PURE__ */ new Set()];
         const currentAliasSet = () => aliasStack[aliasStack.length - 1];
-        const rhsUsesState = (exprPath) => {
+        const getBindingIdentifier = (path3, name) => {
+          const binding = path3.scope.getBinding(name);
+          return binding ? binding.identifier : null;
+        };
+        const addAliasBinding = (path3, name) => {
+          const aliasSet = currentAliasSet();
+          if (!aliasSet) return;
+          const bindingId = getBindingIdentifier(path3, name);
+          if (!bindingId) return;
+          aliasSet.add(bindingId);
+          aliasBindingIds.add(bindingId);
+        };
+        const addStateAliasBinding = (path3, name) => {
+          const bindingId = getBindingIdentifier(path3, name);
+          if (!bindingId) return;
+          stateAliasBindingIds.add(bindingId);
+        };
+        const isAliasBinding = (path3, name) => {
+          const aliasSet = currentAliasSet();
+          if (!aliasSet) return false;
+          const bindingId = getBindingIdentifier(path3, name);
+          return !!(bindingId && aliasSet.has(bindingId));
+        };
+        const isDestructuredAliasBinding = (path3, name) => {
+          const bindingId = getBindingIdentifier(path3, name);
+          return !!(bindingId && destructuredAliases.has(bindingId));
+        };
+        const rhsUsesReactive = (exprPath) => {
           if (!exprPath) return false;
-          if (exprPath.isIdentifier() && t4.isIdentifier(exprPath.node) && stateVars.has(exprPath.node.name)) {
+          if (exprPath.isIdentifier() && t4.isIdentifier(exprPath.node) && hasReactiveAliasSourceBinding(exprPath, exprPath.node.name)) {
             return true;
           }
           let usesState = false;
           exprPath.traverse({
             Identifier(idPath) {
-              if (stateVars.has(idPath.node.name)) {
+              if (hasReactiveAliasSourceBinding(idPath, idPath.node.name)) {
                 usesState = true;
                 idPath.stop();
               }
@@ -32567,26 +33498,47 @@ or extract the nested logic into a custom hook (useXxx).`
             }
           },
           VariableDeclarator(varPath) {
-            const aliasSet = currentAliasSet();
-            if (aliasSet && t4.isIdentifier(varPath.node.id) && rhsUsesState(varPath.get("init"))) {
+            const initPath = varPath.get("init");
+            const stateRootId = isStateRootIdentifier(initPath);
+            if (t4.isIdentifier(varPath.node.id) && rhsUsesReactive(initPath)) {
               debugLog("alias", "add from decl", varPath.node.id.name);
-              aliasSet.add(varPath.node.id.name);
+              addAliasBinding(varPath, varPath.node.id.name);
+            }
+            if (t4.isIdentifier(varPath.node.id) && stateRootId) {
+              addStateAliasBinding(varPath, varPath.node.id.name);
+            }
+            if (t4.isObjectPattern(varPath.node.id) || t4.isArrayPattern(varPath.node.id)) {
+              if (rhsUsesReactive(initPath)) {
+                const targets = collectPatternIdentifiers(varPath.node.id);
+                for (const target of targets) {
+                  debugLog("alias", "add from destructuring decl", target);
+                  addAliasBinding(varPath, target);
+                }
+              }
+              if (stateRootId) {
+                collectPatternIdentifiers(varPath.node.id).forEach(
+                  (id) => trackBindingByName(varPath, id, destructuredAliases)
+                );
+              }
             }
           },
           AssignmentExpression(assignPath) {
-            const aliasSet = currentAliasSet();
-            if (!aliasSet) return;
             const rightPath = assignPath.get("right");
-            const usesState = rhsUsesState(rightPath);
+            const usesState = rhsUsesReactive(rightPath);
+            const stateRootId = isStateRootIdentifier(rightPath);
             const left = assignPath.node.left;
             if (t4.isIdentifier(left)) {
               const targetName = left.name;
               if (usesState) {
                 debugLog("alias", "add from assign", targetName);
-                aliasSet.add(targetName);
+                addAliasBinding(assignPath, targetName);
+                if (stateRootId) {
+                  addStateAliasBinding(assignPath, targetName);
+                }
                 return;
               }
-              if (aliasSet.has(targetName)) {
+              if (isAliasBinding(assignPath, targetName)) {
+                if (isDestructuredAliasBinding(assignPath, targetName)) return;
                 debugLog("alias", "reassignment detected", targetName);
                 throw assignPath.buildCodeFrameError(
                   `Alias reassignment is not supported for "${targetName}"`
@@ -32600,11 +33552,18 @@ or extract the nested logic into a custom hook (useXxx).`
               if (usesState) {
                 for (const target of targets) {
                   debugLog("alias", "add from destructuring assign", target);
-                  aliasSet.add(target);
+                  addAliasBinding(assignPath, target);
+                }
+                if (stateRootId) {
+                  targets.forEach(
+                    (target) => trackBindingByName(assignPath, target, destructuredAliases)
+                  );
                 }
                 return;
               }
-              const reassigned = targets.find((target) => aliasSet.has(target));
+              const reassigned = targets.find(
+                (target) => isAliasBinding(assignPath, target) && !isDestructuredAliasBinding(assignPath, target)
+              );
               if (reassigned) {
                 debugLog("alias", "reassignment detected", reassigned);
                 throw assignPath.buildCodeFrameError(
@@ -32612,20 +33571,31 @@ or extract the nested logic into a custom hook (useXxx).`
                 );
               }
             }
+          },
+          UpdateExpression(updatePath) {
+            const arg = updatePath.node.argument;
+            if (t4.isIdentifier(arg) && isAliasBinding(updatePath, arg.name) && !isDestructuredAliasBinding(updatePath, arg.name)) {
+              debugLog("alias", "reassignment detected", arg.name);
+              throw updatePath.buildCodeFrameError(
+                `Alias reassignment is not supported for "${arg.name}"`
+              );
+            }
           }
         });
-        if (derivedVars.size > 0) {
+        if (derivedBindingIds.size > 0) {
           path2.traverse({
             AssignmentExpression(assignPath) {
               const { left } = assignPath.node;
-              if (t4.isIdentifier(left) && derivedVars.has(left.name)) {
+              if (t4.isIdentifier(left) && hasTrackedBinding(assignPath, left.name, derivedBindingIds)) {
                 throw assignPath.buildCodeFrameError(
                   `Cannot reassign derived value '${left.name}'. Derived values are read-only.`
                 );
               }
               if (t4.isObjectPattern(left) || t4.isArrayPattern(left)) {
                 const targets = collectPatternIdentifiers(left);
-                const derivedTarget = targets.find((target) => derivedVars.has(target));
+                const derivedTarget = targets.find(
+                  (target) => hasTrackedBinding(assignPath, target, derivedBindingIds)
+                );
                 if (derivedTarget) {
                   throw assignPath.buildCodeFrameError(
                     `Cannot reassign derived value '${derivedTarget}'. Derived values are read-only.`
@@ -32639,14 +33609,16 @@ or extract the nested logic into a custom hook (useXxx).`
           path2.traverse({
             AssignmentExpression(assignPath) {
               const { left } = assignPath.node;
-              if (t4.isIdentifier(left) && destructuredAliases.has(left.name)) {
+              if (t4.isIdentifier(left) && hasTrackedBinding(assignPath, left.name, destructuredAliases)) {
                 throw assignPath.buildCodeFrameError(
                   `Cannot write to destructured state alias '${left.name}'. Update the original state (e.g. state.count++ or immutable update).`
                 );
               }
               if (t4.isObjectPattern(left) || t4.isArrayPattern(left)) {
                 const targets = collectPatternIdentifiers(left);
-                const aliasTarget = targets.find((target) => destructuredAliases.has(target));
+                const aliasTarget = targets.find(
+                  (target) => hasTrackedBinding(assignPath, target, destructuredAliases)
+                );
                 if (aliasTarget) {
                   throw assignPath.buildCodeFrameError(
                     `Cannot write to destructured state alias '${aliasTarget}'. Update the original state (e.g. state.count++ or immutable update).`
@@ -32656,7 +33628,7 @@ or extract the nested logic into a custom hook (useXxx).`
             },
             UpdateExpression(updatePath) {
               const arg = updatePath.node.argument;
-              if (t4.isIdentifier(arg) && destructuredAliases.has(arg.name)) {
+              if (t4.isIdentifier(arg) && hasTrackedBinding(updatePath, arg.name, destructuredAliases)) {
                 throw updatePath.buildCodeFrameError(
                   `Cannot write to destructured state alias '${arg.name}'. Update the original state (e.g. state.count++ or immutable update).`
                 );
@@ -32666,7 +33638,28 @@ or extract the nested logic into a custom hook (useXxx).`
         }
         const shouldRunWarnings = dev || hasErrorEscalation(options);
         if (shouldRunWarnings) {
-          runWarningPass(path2, stateVars, derivedVars, warn, fileName, t4);
+          const stateRootBindingIds = /* @__PURE__ */ new Set([
+            ...stateBindingIds,
+            ...stateAliasBindingIds
+          ]);
+          const reactiveBindingIds = /* @__PURE__ */ new Set([
+            ...stateBindingIds,
+            ...derivedBindingIds,
+            ...aliasBindingIds,
+            ...destructuredAliases,
+            ...propsBindingIds,
+            ...importedReactiveBindingIds
+          ]);
+          runWarningPass(
+            path2,
+            stateBindingIds,
+            stateRootBindingIds,
+            reactiveBindingIds,
+            effectMacroNames,
+            warn,
+            fileName,
+            t4
+          );
         }
         const fileAst = t4.file(path2.node);
         const hir = buildHIR(