@fictjs/compiler 0.14.0 → 0.16.0

package/dist/index.js

@@ -3059,7 +3059,7 @@ var require_identifier = __commonJS({
       value: true
     });
     exports.isIdentifierChar = isIdentifierChar;
-    exports.isIdentifierName = isIdentifierName;
+    exports.isIdentifierName = isIdentifierName2;
     exports.isIdentifierStart = isIdentifierStart;
     var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088F\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5C\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDC-\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7DC\uA7F1-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
     var nonASCIIidentifierChars = "\xB7\u0300-\u036F\u0387\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u180F-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19D0-\u19DA\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1ABF-\u1ADD\u1AE0-\u1AEB\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\u30FB\uA620-\uA629\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F1\uA8FF-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F\uFF65";
@@ -3100,7 +3100,7 @@ var require_identifier = __commonJS({
       }
       return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
     }
-    function isIdentifierName(name) {
+    function isIdentifierName2(name) {
       let isFirst = true;
       for (let i = 0; i < name.length; i++) {
         let cp = name.charCodeAt(i);
@@ -14159,6 +14159,7 @@ var RUNTIME_HELPERS = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -14216,6 +14217,7 @@ var RUNTIME_ALIASES = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -17071,6 +17073,37 @@ function clearModuleMetadata(options) {
 }
 
 // src/validation.ts
+var DiagnosticCode = /* @__PURE__ */ ((DiagnosticCode2) => {
+  DiagnosticCode2["FICT_P001"] = "FICT-P001";
+  DiagnosticCode2["FICT_P002"] = "FICT-P002";
+  DiagnosticCode2["FICT_P003"] = "FICT-P003";
+  DiagnosticCode2["FICT_P004"] = "FICT-P004";
+  DiagnosticCode2["FICT_P005"] = "FICT-P005";
+  DiagnosticCode2["FICT_S001"] = "FICT-S001";
+  DiagnosticCode2["FICT_S002"] = "FICT-S002";
+  DiagnosticCode2["FICT_E001"] = "FICT-E001";
+  DiagnosticCode2["FICT_E002"] = "FICT-E002";
+  DiagnosticCode2["FICT_E003"] = "FICT-E003";
+  DiagnosticCode2["FICT_M001"] = "FICT-M001";
+  DiagnosticCode2["FICT_M002"] = "FICT-M002";
+  DiagnosticCode2["FICT_M003"] = "FICT-M003";
+  DiagnosticCode2["FICT_C001"] = "FICT-C001";
+  DiagnosticCode2["FICT_C002"] = "FICT-C002";
+  DiagnosticCode2["FICT_C003"] = "FICT-C003";
+  DiagnosticCode2["FICT_C004"] = "FICT-C004";
+  DiagnosticCode2["FICT_J001"] = "FICT-J001";
+  DiagnosticCode2["FICT_J002"] = "FICT-J002";
+  DiagnosticCode2["FICT_J003"] = "FICT-J003";
+  DiagnosticCode2["FICT_R001"] = "FICT-R001";
+  DiagnosticCode2["FICT_R002"] = "FICT-R002";
+  DiagnosticCode2["FICT_R003"] = "FICT-R003";
+  DiagnosticCode2["FICT_R004"] = "FICT-R004";
+  DiagnosticCode2["FICT_R005"] = "FICT-R005";
+  DiagnosticCode2["FICT_X001"] = "FICT-X001";
+  DiagnosticCode2["FICT_X002"] = "FICT-X002";
+  DiagnosticCode2["FICT_X003"] = "FICT-X003";
+  return DiagnosticCode2;
+})(DiagnosticCode || {});
 var DiagnosticMessages = {
   ["FICT-P001" /* FICT_P001 */]: "Props destructuring falls back to non-reactive binding.",
   ["FICT-P002" /* FICT_P002 */]: "Array rest in props destructuring falls back to non-reactive binding.",
@@ -17158,6 +17191,16 @@ function reportDiagnostic(ctx, code, node, context) {
     });
   }
 }
+function getAllDiagnosticCodes() {
+  return Object.values(DiagnosticCode);
+}
+function getDiagnosticInfo(code) {
+  return {
+    code,
+    severity: DiagnosticSeverities[code],
+    message: DiagnosticMessages[code]
+  };
+}
 
 // src/ir/ssa.ts
 function enterSSA(program) {
@@ -22601,138 +22644,212 @@ function emitConditionalChild(startMarkerId, endMarkerId, expr, statements, ctx,
   );
 }
 
-// src/ir/codegen-expression-deps.ts
-function getMemberDependencyPath(expr) {
-  if (expr.kind === "MemberExpression") {
-    const prop = expr.property;
-    let propName;
-    if (!expr.computed && prop.kind === "Identifier") {
-      propName = prop.name;
-    } else if (prop.kind === "Literal" && typeof prop.value === "string") {
-      propName = prop.value;
-    }
-    if (!propName) return void 0;
-    const object = expr.object;
-    if (object.kind === "Identifier") {
-      return `${deSSAVarName(object.name)}.${propName}`;
-    }
-    if (object.kind === "MemberExpression") {
-      const parent = getMemberDependencyPath(object);
-      return parent ? `${parent}.${propName}` : void 0;
-    }
+// src/ir/walk-expression.ts
+function assertNever(value) {
+  throw new Error(`Unhandled node in walkExpression: ${JSON.stringify(value)}`);
+}
+function walkTerminator(term, visitNode, inFunctionBody) {
+  switch (term.kind) {
+    case "Return":
+      if (term.argument) visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Throw":
+      visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Branch":
+      visitNode(term.test, null, inFunctionBody);
+      return;
+    case "Switch":
+      visitNode(term.discriminant, null, inFunctionBody);
+      term.cases.forEach((c) => {
+        if (c.test) visitNode(c.test, null, inFunctionBody);
+      });
+      return;
+    case "ForOf":
+      visitNode(term.iterable, null, inFunctionBody);
+      return;
+    case "ForIn":
+      visitNode(term.object, null, inFunctionBody);
+      return;
+    case "Jump":
+    case "Unreachable":
+    case "Break":
+    case "Continue":
+    case "Try":
+      return;
+    default:
+      assertNever(term);
+  }
+}
+function walkInstruction(instr, visitNode, inFunctionBody) {
+  switch (instr.kind) {
+    case "Assign":
+    case "Expression":
+      visitNode(instr.value, null, inFunctionBody);
+      return;
+    case "Phi":
+      instr.sources.forEach((source) => visitNode(source.id, null, inFunctionBody));
+      return;
+    default:
+      assertNever(instr);
   }
-  return void 0;
 }
-function collectBlockDependencies(blocks, deps) {
+function walkBlocks(blocks, visitNode, inFunctionBody) {
   for (const block of blocks) {
-    for (const instr of block.instructions) {
-      switch (instr.kind) {
-        case "Assign":
-        case "Expression":
-          collectExpressionDependencies(instr.value, deps);
-          break;
-        case "Phi":
-          for (const source of instr.sources) {
-            deps.add(deSSAVarName(source.id.name));
+    block.instructions.forEach((instr) => walkInstruction(instr, visitNode, inFunctionBody));
+    walkTerminator(block.terminator, visitNode, inFunctionBody);
+  }
+}
+function walkExpression(expr, visit, options = {}) {
+  const includeFunctionBodies = options.includeFunctionBodies ?? true;
+  const visitNode = (node, parent, inFunctionBody) => {
+    visit(node, { parent, inFunctionBody });
+    switch (node.kind) {
+      case "Identifier":
+      case "Literal":
+      case "MetaProperty":
+      case "ThisExpression":
+      case "SuperExpression":
+        return;
+      case "ImportExpression":
+        visitNode(node.source, node, inFunctionBody);
+        return;
+      case "CallExpression":
+      case "OptionalCallExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visitNode(node.object, node, inFunctionBody);
+        if (node.computed) {
+          visitNode(node.property, node, inFunctionBody);
+        }
+        return;
+      case "BinaryExpression":
+      case "LogicalExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UnaryExpression":
+      case "AwaitExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "ConditionalExpression":
+        visitNode(node.test, node, inFunctionBody);
+        visitNode(node.consequent, node, inFunctionBody);
+        visitNode(node.alternate, node, inFunctionBody);
+        return;
+      case "ArrayExpression":
+        node.elements.forEach((el) => visitNode(el, node, inFunctionBody));
+        return;
+      case "ObjectExpression":
+        node.properties.forEach((prop) => {
+          if (prop.kind === "SpreadElement") {
+            visitNode(prop.argument, node, inFunctionBody);
+          } else {
+            if (prop.computed) {
+              visitNode(prop.key, node, inFunctionBody);
+            }
+            visitNode(prop.value, node, inFunctionBody);
           }
-          break;
-        default:
-          break;
-      }
-    }
-    const term = block.terminator;
-    switch (term.kind) {
-      case "Return":
-        if (term.argument) collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Throw":
-        collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Branch":
-        collectExpressionDependencies(term.test, deps);
-        break;
-      case "Switch":
-        collectExpressionDependencies(term.discriminant, deps);
-        for (const c of term.cases) {
-          if (c.test) collectExpressionDependencies(c.test, deps);
+        });
+        return;
+      case "JSXElement":
+        if (typeof node.tagName !== "string") {
+          visitNode(node.tagName, node, inFunctionBody);
         }
-        break;
-      case "ForOf":
-        collectExpressionDependencies(term.iterable, deps);
-        break;
-      case "ForIn":
-        collectExpressionDependencies(term.object, deps);
-        break;
+        node.attributes.forEach((attr) => {
+          if (attr.isSpread && attr.spreadExpr) {
+            visitNode(attr.spreadExpr, node, inFunctionBody);
+          } else if (attr.value) {
+            visitNode(attr.value, node, inFunctionBody);
+          }
+        });
+        node.children.forEach((child) => {
+          if (child.kind === "expression") {
+            visitNode(child.value, node, inFunctionBody);
+          } else if (child.kind === "element") {
+            visitNode(child.value, node, inFunctionBody);
+          }
+        });
+        return;
+      case "ArrowFunction":
+        if (!includeFunctionBodies) return;
+        if (node.isExpression && !Array.isArray(node.body)) {
+          visitNode(node.body, node, true);
+        } else if (Array.isArray(node.body)) {
+          walkBlocks(node.body, visitNode, true);
+        }
+        return;
+      case "FunctionExpression":
+        if (!includeFunctionBodies) return;
+        walkBlocks(node.body, visitNode, true);
+        return;
+      case "AssignmentExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UpdateExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "TemplateLiteral":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "SpreadElement":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "NewExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "SequenceExpression":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "YieldExpression":
+        if (node.argument) {
+          visitNode(node.argument, node, inFunctionBody);
+        }
+        return;
+      case "TaggedTemplateExpression":
+        visitNode(node.tag, node, inFunctionBody);
+        node.quasi.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "ClassExpression":
+        if (node.superClass) {
+          visitNode(node.superClass, node, inFunctionBody);
+        }
+        return;
       default:
-        break;
+        assertNever(node);
     }
+  };
+  visitNode(expr, null, false);
+}
+
+// src/ir/codegen-expression-deps.ts
+function getMemberDependencyPath(expr) {
+  if (expr.kind !== "MemberExpression" && expr.kind !== "OptionalMemberExpression") return void 0;
+  const depPath = extractDependencyPath(expr);
+  if (!depPath || depPath.segments.length === 0) return void 0;
+  const base = deSSAVarName(depPath.base);
+  if (depPath.segments.some((segment) => segment.computed)) {
+    return base;
   }
+  const tail = depPath.segments.map((segment) => segment.property).join(".");
+  return tail ? `${base}.${tail}` : void 0;
 }
 function collectExpressionDependencies(expr, deps) {
-  if (expr.kind === "Identifier") {
-    deps.add(deSSAVarName(expr.name));
-    return;
-  }
-  if (expr.kind === "ArrowFunction") {
-    if (expr.isExpression && !Array.isArray(expr.body)) {
-      collectExpressionDependencies(expr.body, deps);
-    } else if (Array.isArray(expr.body)) {
-      collectBlockDependencies(expr.body, deps);
+  walkExpression(expr, (node) => {
+    if (node.kind === "Identifier") {
+      deps.add(deSSAVarName(node.name));
+      return;
     }
-    return;
-  }
-  if (expr.kind === "FunctionExpression") {
-    collectBlockDependencies(expr.body, deps);
-    return;
-  }
-  if (expr.kind === "MemberExpression") {
-    const path2 = getMemberDependencyPath(expr);
-    if (path2) deps.add(path2);
-    collectExpressionDependencies(expr.object, deps);
-    if (expr.computed && expr.property.kind !== "Literal") {
-      collectExpressionDependencies(expr.property, deps);
+    const path2 = getMemberDependencyPath(node);
+    if (path2) {
+      deps.add(path2);
     }
-    return;
-  }
-  if (expr.kind === "CallExpression") {
-    collectExpressionDependencies(expr.callee, deps);
-    expr.arguments.forEach((a) => collectExpressionDependencies(a, deps));
-    return;
-  }
-  if (expr.kind === "BinaryExpression" || expr.kind === "LogicalExpression") {
-    collectExpressionDependencies(expr.left, deps);
-    collectExpressionDependencies(expr.right, deps);
-    return;
-  }
-  if (expr.kind === "ConditionalExpression") {
-    collectExpressionDependencies(expr.test, deps);
-    collectExpressionDependencies(expr.consequent, deps);
-    collectExpressionDependencies(expr.alternate, deps);
-    return;
-  }
-  if (expr.kind === "UnaryExpression") {
-    collectExpressionDependencies(expr.argument, deps);
-    return;
-  }
-  if (expr.kind === "ArrayExpression") {
-    expr.elements.forEach((el) => collectExpressionDependencies(el, deps));
-    return;
-  }
-  if (expr.kind === "ObjectExpression") {
-    expr.properties.forEach((p) => {
-      if (p.kind === "SpreadElement") {
-        collectExpressionDependencies(p.argument, deps);
-      } else {
-        if (p.computed) collectExpressionDependencies(p.key, deps);
-        collectExpressionDependencies(p.value, deps);
-      }
-    });
-    return;
-  }
-  if (expr.kind === "TemplateLiteral") {
-    expr.expressions.forEach((e) => collectExpressionDependencies(e, deps));
-    return;
-  }
+  });
 }
 
 // src/ir/codegen-reactive-kind.ts
@@ -24176,34 +24293,138 @@ function extractKeyFromAttributes(attributes) {
   }
   return void 0;
 }
+function collectReturnedJSXFromExpression(expression, returned) {
+  if (expression.kind === "JSXElement") {
+    returned.push(expression);
+    return;
+  }
+  if (expression.kind === "ConditionalExpression") {
+    collectReturnedJSXFromExpression(expression.consequent, returned);
+    collectReturnedJSXFromExpression(expression.alternate, returned);
+    return;
+  }
+  if (expression.kind === "LogicalExpression") {
+    collectReturnedJSXFromExpression(expression.left, returned);
+    collectReturnedJSXFromExpression(expression.right, returned);
+    return;
+  }
+  if (expression.kind === "SequenceExpression") {
+    const tail = expression.expressions[expression.expressions.length - 1];
+    if (tail) collectReturnedJSXFromExpression(tail, returned);
+  }
+}
+function extractKeyExpressionFromReturnedExpression(expression) {
+  if (expression.kind === "JSXElement") {
+    return extractKeyFromAttributes(expression.attributes);
+  }
+  if (expression.kind === "ConditionalExpression") {
+    const consequentKey = extractKeyExpressionFromReturnedExpression(expression.consequent);
+    const alternateKey = extractKeyExpressionFromReturnedExpression(expression.alternate);
+    if (!consequentKey || !alternateKey) return void 0;
+    return {
+      kind: "ConditionalExpression",
+      test: expression.test,
+      consequent: consequentKey,
+      alternate: alternateKey,
+      loc: expression.loc
+    };
+  }
+  if (expression.kind === "SequenceExpression") {
+    const tail = expression.expressions[expression.expressions.length - 1];
+    return tail ? extractKeyExpressionFromReturnedExpression(tail) : void 0;
+  }
+  return void 0;
+}
+function getReturnedKeyExpressionsFromCallback(callback) {
+  const returned = [];
+  if (callback.kind === "ArrowFunction") {
+    if (callback.isExpression && !Array.isArray(callback.body)) {
+      const keyExpr = extractKeyExpressionFromReturnedExpression(callback.body);
+      if (keyExpr) returned.push(keyExpr);
+      return returned;
+    }
+    if (Array.isArray(callback.body)) {
+      for (const block of callback.body) {
+        const term = block.terminator;
+        if (term.kind !== "Return" || !term.argument) continue;
+        const keyExpr = extractKeyExpressionFromReturnedExpression(term.argument);
+        if (keyExpr) returned.push(keyExpr);
+      }
+    }
+    return returned;
+  }
+  if (callback.kind === "FunctionExpression") {
+    for (const block of callback.body ?? []) {
+      const term = block.terminator;
+      if (term.kind !== "Return" || !term.argument) continue;
+      const keyExpr = extractKeyExpressionFromReturnedExpression(term.argument);
+      if (keyExpr) returned.push(keyExpr);
+    }
+  }
+  return returned;
+}
 function getReturnedJSXFromCallback(callback) {
+  const returned = [];
   if (callback.kind === "ArrowFunction") {
-    if (callback.isExpression && !Array.isArray(callback.body) && callback.body.kind === "JSXElement") {
-      return callback.body;
+    if (callback.isExpression && !Array.isArray(callback.body)) {
+      collectReturnedJSXFromExpression(callback.body, returned);
+      return returned;
     }
     if (Array.isArray(callback.body)) {
       for (const block of callback.body) {
         const term = block.terminator;
-        if (term.kind === "Return" && term.argument?.kind === "JSXElement") {
-          return term.argument;
+        if (term.kind === "Return" && term.argument) {
+          collectReturnedJSXFromExpression(term.argument, returned);
         }
       }
     }
+    return returned;
   }
   if (callback.kind === "FunctionExpression") {
     for (const block of callback.body ?? []) {
       const term = block.terminator;
-      if (term.kind === "Return" && term.argument?.kind === "JSXElement") {
-        return term.argument;
+      if (term.kind === "Return" && term.argument) {
+        collectReturnedJSXFromExpression(term.argument, returned);
       }
     }
   }
-  return null;
+  return returned;
+}
+function keyExpressionSignature(expression) {
+  try {
+    return JSON.stringify(expression, (key, value) => {
+      if (key === "loc") return void 0;
+      if (typeof value === "bigint") return `__bigint:${value.toString()}`;
+      return value;
+    }) ?? "";
+  } catch {
+    return "";
+  }
 }
 function extractKeyFromMapCallback(callback) {
-  const jsx = getReturnedJSXFromCallback(callback);
-  if (!jsx) return void 0;
-  return extractKeyFromAttributes(jsx.attributes);
+  const returnedKeyExpressions = getReturnedKeyExpressionsFromCallback(callback);
+  if (returnedKeyExpressions.length === 1) {
+    return returnedKeyExpressions[0];
+  }
+  if (returnedKeyExpressions.length > 1) {
+    const [firstKey2, ...restKeys2] = returnedKeyExpressions;
+    const firstSignature2 = keyExpressionSignature(firstKey2);
+    if (firstSignature2 && restKeys2.every((keyExpr) => keyExpressionSignature(keyExpr) === firstSignature2)) {
+      return firstKey2;
+    }
+  }
+  const returned = getReturnedJSXFromCallback(callback);
+  if (returned.length === 0) return void 0;
+  const keyExpressions = returned.map((jsx) => extractKeyFromAttributes(jsx.attributes));
+  if (keyExpressions.some((expr) => !expr)) return void 0;
+  const [firstKey, ...restKeys] = keyExpressions;
+  const firstSignature = keyExpressionSignature(firstKey);
+  if (!firstSignature) return void 0;
+  const allBranchesSameKey = restKeys.every(
+    (keyExpr) => keyExpressionSignature(keyExpr) === firstSignature
+  );
+  if (!allBranchesSameKey) return void 0;
+  return firstKey;
 }
 
 // src/ir/codegen-overrides.ts
@@ -24808,6 +25029,15 @@ function buildListCallExpression(expr, statements, ctx, ops) {
   ctx.inListRender = true;
   let callbackExpr = ops.lowerExpression(mapCallback, ctx);
   ctx.inListRender = prevInListRender;
+  const shouldDeferOptionalCallbackEvaluation = isOptional && !t4.isArrowFunctionExpression(callbackExpr) && !t4.isFunctionExpression(callbackExpr);
+  let deferredCallbackId = null;
+  let deferredCallbackInitId = null;
+  let deferredItemsId = null;
+  if (shouldDeferOptionalCallbackEvaluation) {
+    deferredCallbackId = ops.genTemp(ctx, "mapCb");
+    deferredCallbackInitId = ops.genTemp(ctx, "mapCbReady");
+    deferredItemsId = ops.genTemp(ctx, "mapItems");
+  }
   const capturedKeyParamName = ctx.listKeyParamName;
   ctx.listKeyExpr = prevListKeyExpr;
   ctx.listItemParamName = prevListItemParamName;
@@ -24907,7 +25137,7 @@ function buildListCallExpression(expr, statements, ctx, ops) {
       ],
       keyExprAst
     );
-    const hasIndexParam = (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr)) && callbackExpr.params.length >= 2;
+    const hasIndexParam = shouldDeferOptionalCallbackEvaluation || (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr)) && callbackExpr.params.length >= 2;
     if (canConstifyKey && (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr))) {
       const newParams = [...callbackExpr.params];
       while (newParams.length < 2) {
@@ -24927,25 +25157,131 @@ function buildListCallExpression(expr, statements, ctx, ops) {
       }
     }
     statements.push(...hoistedStatements);
+    if (shouldDeferOptionalCallbackEvaluation) {
+      statements.push(
+        t4.variableDeclaration("let", [
+          t4.variableDeclarator(t4.cloneNode(deferredCallbackId, true))
+        ]),
+        t4.variableDeclaration("let", [
+          t4.variableDeclarator(t4.cloneNode(deferredCallbackInitId, true), t4.booleanLiteral(false))
+        ])
+      );
+    }
+    const getItemsExpr = shouldDeferOptionalCallbackEvaluation ? t4.arrowFunctionExpression(
+      [],
+      t4.blockStatement([
+        t4.variableDeclaration("const", [
+          t4.variableDeclarator(
+            t4.cloneNode(deferredItemsId, true),
+            t4.cloneNode(arrayExprBase, true)
+          )
+        ]),
+        t4.ifStatement(
+          t4.binaryExpression("==", t4.cloneNode(deferredItemsId, true), t4.nullLiteral()),
+          t4.blockStatement([t4.returnStatement(t4.arrayExpression([]))])
+        ),
+        t4.ifStatement(
+          t4.unaryExpression("!", t4.cloneNode(deferredCallbackInitId, true)),
+          t4.blockStatement([
+            t4.expressionStatement(
+              t4.assignmentExpression(
+                "=",
+                t4.cloneNode(deferredCallbackId, true),
+                t4.cloneNode(callbackExpr, true)
+              )
+            ),
+            t4.expressionStatement(
+              t4.assignmentExpression(
+                "=",
+                t4.cloneNode(deferredCallbackInitId, true),
+                t4.booleanLiteral(true)
+              )
+            )
+          ])
+        ),
+        t4.returnStatement(t4.cloneNode(deferredItemsId, true))
+      ])
+    ) : t4.arrowFunctionExpression([], arrayExpr);
+    const renderExpr = shouldDeferOptionalCallbackEvaluation ? t4.arrowFunctionExpression(
+      [t4.identifier("__item"), t4.identifier("__index"), t4.identifier("__key")],
+      t4.callExpression(t4.cloneNode(deferredCallbackId, true), [
+        t4.identifier("__item"),
+        t4.identifier("__index"),
+        t4.identifier("__key")
+      ])
+    ) : callbackExpr;
     listCall = t4.callExpression(t4.identifier(RUNTIME_ALIASES.keyedList), [
-      t4.arrowFunctionExpression([], arrayExpr),
+      getItemsExpr,
       keyFn,
-      callbackExpr,
+      renderExpr,
       t4.booleanLiteral(hasIndexParam)
     ]);
   } else {
     statements.push(...hoistedStatements);
+    if (shouldDeferOptionalCallbackEvaluation) {
+      statements.push(
+        t4.variableDeclaration("let", [
+          t4.variableDeclarator(t4.cloneNode(deferredCallbackId, true))
+        ]),
+        t4.variableDeclaration("let", [
+          t4.variableDeclarator(t4.cloneNode(deferredCallbackInitId, true), t4.booleanLiteral(false))
+        ])
+      );
+    }
     const itemParamName = t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr) ? t4.isIdentifier(callbackExpr.params[0]) ? callbackExpr.params[0].name : "__item" : "__item";
     const indexParamName = t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr) ? t4.isIdentifier(callbackExpr.params[1]) ? callbackExpr.params[1].name : "__index" : "__index";
-    const hasIndexParam = (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr)) && callbackExpr.params.length >= 2;
+    const hasIndexParam = shouldDeferOptionalCallbackEvaluation || (t4.isArrowFunctionExpression(callbackExpr) || t4.isFunctionExpression(callbackExpr)) && callbackExpr.params.length >= 2;
+    const getItemsExpr = shouldDeferOptionalCallbackEvaluation ? t4.arrowFunctionExpression(
+      [],
+      t4.blockStatement([
+        t4.variableDeclaration("const", [
+          t4.variableDeclarator(
+            t4.cloneNode(deferredItemsId, true),
+            t4.cloneNode(arrayExprBase, true)
+          )
+        ]),
+        t4.ifStatement(
+          t4.binaryExpression("==", t4.cloneNode(deferredItemsId, true), t4.nullLiteral()),
+          t4.blockStatement([t4.returnStatement(t4.arrayExpression([]))])
+        ),
+        t4.ifStatement(
+          t4.unaryExpression("!", t4.cloneNode(deferredCallbackInitId, true)),
+          t4.blockStatement([
+            t4.expressionStatement(
+              t4.assignmentExpression(
+                "=",
+                t4.cloneNode(deferredCallbackId, true),
+                t4.cloneNode(callbackExpr, true)
+              )
+            ),
+            t4.expressionStatement(
+              t4.assignmentExpression(
+                "=",
+                t4.cloneNode(deferredCallbackInitId, true),
+                t4.booleanLiteral(true)
+              )
+            )
+          ])
+        ),
+        t4.returnStatement(t4.cloneNode(deferredItemsId, true))
+      ])
+    ) : t4.arrowFunctionExpression([], arrayExpr);
+    const renderExpr = shouldDeferOptionalCallbackEvaluation ? t4.arrowFunctionExpression(
+      [t4.identifier("__item"), t4.identifier("__index"), t4.identifier("__key")],
+      t4.callExpression(t4.cloneNode(deferredCallbackId, true), [
+        t4.identifier("__item"),
+        t4.identifier("__index"),
+        t4.identifier("__key")
+      ])
+    ) : callbackExpr;
     const keyFn = t4.arrowFunctionExpression(
       [t4.identifier(itemParamName), t4.identifier(indexParamName)],
       t4.identifier(indexParamName)
     );
     listCall = t4.callExpression(t4.identifier(RUNTIME_ALIASES.keyedList), [
-      t4.arrowFunctionExpression([], arrayExpr),
+      getItemsExpr,
       keyFn,
-      callbackExpr,
+      renderExpr,
       t4.booleanLiteral(hasIndexParam)
     ]);
   }
@@ -26110,8 +26446,31 @@ function extractHIRStaticHtml(jsx, ctx, ops, parentPath = [], namespace = null)
   const resolvedNamespace = resolveNamespaceContext(tagName, namespace);
   let html = `<${tagName}`;
   const bindings = [];
-  for (const attr of jsx.attributes) {
+  for (let attrIndex = 0; attrIndex < jsx.attributes.length; attrIndex++) {
+    const attr = jsx.attributes[attrIndex];
     if (attr.isSpread) {
+      if (attr.spreadExpr) {
+        const excluded = /* @__PURE__ */ new Set();
+        for (let nextIndex = attrIndex + 1; nextIndex < jsx.attributes.length; nextIndex++) {
+          const nextAttr = jsx.attributes[nextIndex];
+          if (nextAttr.isSpread) continue;
+          let nextName = normalizeHIRAttrName(nextAttr.name);
+          if (nextName.endsWith("$")) {
+            nextName = nextName.slice(0, -1);
+          }
+          if (nextName === "key") continue;
+          excluded.add(nextName);
+          if (nextName !== nextAttr.name) {
+            excluded.add(nextAttr.name);
+          }
+        }
+        bindings.push({
+          type: "spread",
+          path: [...parentPath],
+          expr: attr.spreadExpr,
+          exclude: excluded.size > 0 ? Array.from(excluded) : void 0
+        });
+      }
       continue;
     }
     let name = normalizeHIRAttrName(attr.name);
@@ -28296,10 +28655,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         )
       );
     }
+    fusedPatchGroups.clear();
   };
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx, genTemp3);
-    if (binding.type === "event" && binding.expr && binding.name) {
+    if (binding.type === "spread" && binding.expr) {
+      flushFusedPatchGroups();
+      ctx.helpersUsed.add("spread");
+      const spreadValueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
+      const spreadGetter = t4.arrowFunctionExpression([], spreadValueExpr);
+      const spreadArgs = [
+        targetId,
+        spreadGetter,
+        t4.booleanLiteral(Boolean(isSVG || isMathML)),
+        t4.booleanLiteral(true)
+      ];
+      if (binding.exclude && binding.exclude.length > 0) {
+        spreadArgs.push(t4.arrayExpression(binding.exclude.map((name) => t4.stringLiteral(name))));
+      }
+      statements.push(
+        t4.expressionStatement(t4.callExpression(t4.identifier(RUNTIME_ALIASES.spread), spreadArgs))
+      );
+    } else if (binding.type === "event" && binding.expr && binding.name) {
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
@@ -33087,106 +33464,106 @@ function collectUsesFromTerminator(term, add, inFunctionBody = false) {
   }
 }
 function collectUsesFromExpression(expr, add, inFunctionBody = false) {
-  walkExpression(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
+  walkExpression2(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
 }
-function walkExpression(expr, add, ctx) {
+function walkExpression2(expr, add, ctx) {
   switch (expr.kind) {
     case "Identifier":
       if (!ctx.shadowed.has(expr.name)) add(expr.name, ctx.inFunctionBody);
       return;
     case "CallExpression":
     case "OptionalCallExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "MemberExpression":
     case "OptionalMemberExpression":
-      walkExpression(expr.object, add, ctx);
-      if (expr.computed) walkExpression(expr.property, add, ctx);
+      walkExpression2(expr.object, add, ctx);
+      if (expr.computed) walkExpression2(expr.property, add, ctx);
       return;
     case "BinaryExpression":
     case "LogicalExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UnaryExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "ConditionalExpression":
-      walkExpression(expr.test, add, ctx);
-      walkExpression(expr.consequent, add, ctx);
-      walkExpression(expr.alternate, add, ctx);
+      walkExpression2(expr.test, add, ctx);
+      walkExpression2(expr.consequent, add, ctx);
+      walkExpression2(expr.alternate, add, ctx);
       return;
     case "ArrayExpression":
       expr.elements.forEach((el) => {
-        if (el) walkExpression(el, add, ctx);
+        if (el) walkExpression2(el, add, ctx);
       });
       return;
     case "ObjectExpression":
       expr.properties.forEach((prop) => {
         if (prop.kind === "SpreadElement") {
-          walkExpression(prop.argument, add, ctx);
+          walkExpression2(prop.argument, add, ctx);
         } else {
-          if (prop.computed) walkExpression(prop.key, add, ctx);
-          walkExpression(prop.value, add, ctx);
+          if (prop.computed) walkExpression2(prop.key, add, ctx);
+          walkExpression2(prop.value, add, ctx);
         }
       });
       return;
     case "TemplateLiteral":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "SpreadElement":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "SequenceExpression":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "AwaitExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "NewExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "ArrowFunction": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
       if (expr.isExpression) {
-        walkExpression(expr.body, add, { inFunctionBody: true, shadowed });
+        walkExpression2(expr.body, add, { inFunctionBody: true, shadowed });
         return;
       }
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "FunctionExpression": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "AssignmentExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UpdateExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "JSXElement":
       if (typeof expr.tagName !== "string") {
-        walkExpression(expr.tagName, add, ctx);
+        walkExpression2(expr.tagName, add, ctx);
       }
       expr.attributes.forEach((attr) => {
         if (attr.isSpread && attr.spreadExpr) {
-          walkExpression(attr.spreadExpr, add, ctx);
+          walkExpression2(attr.spreadExpr, add, ctx);
         } else if (attr.value) {
-          walkExpression(attr.value, add, ctx);
+          walkExpression2(attr.value, add, ctx);
         }
       });
       expr.children.forEach((child) => {
         if (child.kind === "expression") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         } else if (child.kind === "element") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         }
       });
       return;
@@ -33194,16 +33571,16 @@ function walkExpression(expr, add, ctx) {
       return;
   }
 }
-function walkBlocks(blocks, add, ctx) {
+function walkBlocks2(blocks, add, ctx) {
   for (const block of blocks) {
     for (const instr of block.instructions) {
       if (instr.kind === "Assign") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
         if (instr.declarationKind) {
           ctx.shadowed.add(instr.target.name);
         }
       } else if (instr.kind === "Expression") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
       } else if (instr.kind === "Phi") {
         instr.sources.forEach((src) => {
           if (!ctx.shadowed.has(src.id.name)) add(src.id.name, ctx.inFunctionBody);
@@ -33222,7 +33599,7 @@ function walkBlocks(blocks, add, ctx) {
 function collectExpressionIdentifiers2(expr, deep = false) {
   const deps = /* @__PURE__ */ new Set();
   const collect = (name) => deps.add(name);
-  walkExpression(expr, (name, _inFunctionBody) => collect(name), {
+  walkExpression2(expr, (name, _inFunctionBody) => collect(name), {
     inFunctionBody: deep,
     shadowed: /* @__PURE__ */ new Set()
   });
@@ -33803,6 +34180,506 @@ function getRootIdentifier(expr, t4) {
   return null;
 }
 
+// src/tooling/analyze.ts
+import { parseSync, transformSync } from "@babel/core";
+
+// src/tooling/trace-infer.ts
+var TRACE_REGEX_ESCAPES = /[.*+?^${}()|[\]\\]/g;
+var IDENTIFIER_NAME = /^[A-Za-z_$][\w$]*$/;
+function isIdentifierName(name) {
+  return IDENTIFIER_NAME.test(name);
+}
+function lineContainsIdentifier(lineText, identifier2) {
+  const pattern = new RegExp(`\\b${identifier2.replace(TRACE_REGEX_ESCAPES, "\\$&")}\\b`);
+  return pattern.test(lineText);
+}
+function lineContainsAnyIdentifier(lineText, identifiers) {
+  for (const id of identifiers) {
+    if (lineContainsIdentifier(lineText, id)) return true;
+  }
+  return false;
+}
+function pushTraceMarker(markersByLine, line, marker) {
+  const markers = markersByLine.get(line);
+  if (!markers) {
+    markersByLine.set(line, [marker]);
+    return;
+  }
+  const duplicate = markers.some(
+    (existing) => existing.kind === marker.kind && existing.label === marker.label
+  );
+  if (!duplicate) markers.push(marker);
+}
+function inferReactiveLocalNames(startLine, endLine, sourceLines, baseReactiveNames) {
+  const reactiveNames = new Set(baseReactiveNames);
+  const declarationLines = [];
+  const declarationPattern = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(.+?)(?:;)?$/;
+  for (let line = startLine; line <= endLine; line++) {
+    const text = (sourceLines[line - 1] ?? "").trim();
+    if (!text) continue;
+    const withoutComment = text.replace(/\/\/.*$/, "").trim();
+    if (!withoutComment) continue;
+    const match = withoutComment.match(declarationPattern);
+    if (!match) continue;
+    const name = match[1];
+    const expression = match[2];
+    if (!name || !expression) continue;
+    declarationLines.push({ name, expression });
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const declaration of declarationLines) {
+      if (reactiveNames.has(declaration.name)) continue;
+      if (!lineContainsAnyIdentifier(declaration.expression, reactiveNames)) continue;
+      reactiveNames.add(declaration.name);
+      changed = true;
+    }
+  }
+  return reactiveNames;
+}
+function isStateCallInstruction(instr) {
+  if (instr.kind !== "Assign") return false;
+  const value = instr.value;
+  return value.kind === "CallExpression" && value.callee.kind === "Identifier" && value.callee.name === "$state";
+}
+function collectStateDeclNames(fn) {
+  const result = [];
+  for (const block of fn.blocks) {
+    for (const instr of block.instructions) {
+      if (!isStateCallInstruction(instr) || !instr.loc) continue;
+      const name = deSSAVarName(instr.target.name);
+      if (!isIdentifierName(name)) continue;
+      result.push({ name, line: instr.loc.start.line });
+    }
+  }
+  return result;
+}
+function expressionContainsEffectCall(instr) {
+  const value = instr.kind === "Assign" || instr.kind === "Expression" ? instr.value : null;
+  if (!value || !instr.loc) return null;
+  let found = false;
+  walkExpression(value, (expr) => {
+    if (expr.kind === "CallExpression" && expr.callee.kind === "Identifier" && deSSAVarName(expr.callee.name) === "$effect") {
+      found = true;
+    }
+  });
+  return found ? instr.loc.start.line : null;
+}
+function flattenRegions2(regions) {
+  if (!regions || regions.length === 0) return [];
+  const result = [];
+  const visit = (region) => {
+    result.push(region);
+    region.children?.forEach((child) => visit(child));
+  };
+  regions.forEach((region) => visit(region));
+  return result;
+}
+function findContainingRegion2(line, flatRegions) {
+  let best;
+  for (const region of flatRegions) {
+    if (region.startLine === void 0 || region.endLine === void 0 || line < region.startLine || line > region.endLine) {
+      continue;
+    }
+    const bestSpan = best && best.startLine !== void 0 && best.endLine !== void 0 ? best.endLine - best.startLine : Number.POSITIVE_INFINITY;
+    const span = region.endLine - region.startLine;
+    if (span <= bestSpan) best = region;
+  }
+  return best;
+}
+function inferTraceMarkersForComponent(input) {
+  const { fn, sourceLines, startLine, endLine, verbosity, regions } = input;
+  const markersByLine = /* @__PURE__ */ new Map();
+  pushTraceMarker(markersByLine, startLine, {
+    kind: "once",
+    label: "Component setup runs on mount"
+  });
+  const stateDecls = collectStateDeclNames(fn);
+  const reactiveNames = inferReactiveLocalNames(
+    startLine,
+    endLine,
+    sourceLines,
+    stateDecls.map((item) => item.name)
+  );
+  for (const stateDecl of stateDecls) {
+    pushTraceMarker(markersByLine, stateDecl.line, {
+      kind: "once",
+      label: "Signal initialization runs once"
+    });
+  }
+  for (const block of fn.blocks) {
+    for (const instr of block.instructions) {
+      const line = expressionContainsEffectCall(instr);
+      if (!line || line < startLine || line > endLine) continue;
+      pushTraceMarker(markersByLine, line, {
+        kind: "effect",
+        label: "Effect reruns when dependencies change"
+      });
+    }
+  }
+  const flatRegions = flattenRegions2(regions);
+  for (let line = startLine; line <= endLine; line++) {
+    const lineText = sourceLines[line - 1] ?? "";
+    if (!lineText) continue;
+    const hasReactiveName = lineContainsAnyIdentifier(lineText, reactiveNames);
+    if (hasReactiveName && /\{[^}]*\b[A-Za-z_$][\w$]*\b[^}]*\}/.test(lineText)) {
+      pushTraceMarker(markersByLine, line, {
+        kind: "reactive",
+        label: "JSX expression updates with reactive values"
+      });
+    }
+    if (hasReactiveName && /\bconsole\.(?:log|debug|info|warn|error)\s*\(/.test(lineText)) {
+      pushTraceMarker(markersByLine, line, {
+        kind: "reactive",
+        label: "Statement reruns when reactive values change"
+      });
+    }
+    if (/\b(?:\$effect|effect)\s*\(/.test(lineText)) {
+      pushTraceMarker(markersByLine, line, {
+        kind: "effect",
+        label: "Effect callback executes reactively"
+      });
+    }
+    if (verbosity === "verbose" && !hasReactiveName && /\{[^}]*\}/.test(lineText)) {
+      pushTraceMarker(markersByLine, line, {
+        kind: "once",
+        label: "JSX expression runs during setup only"
+      });
+    }
+    if (/\bconsole\.(?:log|debug|info|warn|error)\s*\(/.test(lineText) && !hasReactiveName && line !== startLine) {
+      pushTraceMarker(markersByLine, line, {
+        kind: "once",
+        label: "Statement runs only during setup"
+      });
+    }
+    const containingRegion = findContainingRegion2(line, flatRegions);
+    if (!containingRegion) continue;
+    const markers = markersByLine.get(line);
+    if (!markers) continue;
+    for (const marker of markers) {
+      marker.regionId = containingRegion.id;
+      marker.deps = containingRegion.dependencies;
+    }
+  }
+  return [...markersByLine.entries()].sort((a, b) => a[0] - b[0]).map(([line, markers]) => ({ line, markers }));
+}
+
+// src/tooling/analyze.ts
+function mergeLoc(a, b) {
+  if (!a) return b ?? null;
+  if (!b) return a;
+  const start = b.start.line < a.start.line || b.start.line === a.start.line && b.start.column < a.start.column ? b.start : a.start;
+  const end = b.end.line > a.end.line || b.end.line === a.end.line && b.end.column > a.end.column ? b.end : a.end;
+  return {
+    start,
+    end,
+    filename: a.filename ?? b.filename,
+    identifierName: a.identifierName ?? b.identifierName
+  };
+}
+function expressionContainsMacroCall(expr, macroName) {
+  let found = false;
+  const visit = (value) => {
+    if (found) return;
+    if (value.kind === "CallExpression" && value.callee.kind === "Identifier" && deSSAVarName(value.callee.name) === macroName) {
+      found = true;
+      return;
+    }
+    switch (value.kind) {
+      case "CallExpression":
+      case "OptionalCallExpression":
+        visit(value.callee);
+        value.arguments.forEach((arg) => visit(arg));
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visit(value.object);
+        if (value.computed) visit(value.property);
+        return;
+      case "BinaryExpression":
+      case "LogicalExpression":
+        visit(value.left);
+        visit(value.right);
+        return;
+      case "UnaryExpression":
+      case "AwaitExpression":
+      case "UpdateExpression":
+      case "SpreadElement":
+        visit(value.argument);
+        return;
+      case "ConditionalExpression":
+        visit(value.test);
+        visit(value.consequent);
+        visit(value.alternate);
+        return;
+      case "ArrayExpression":
+        value.elements.forEach((el) => visit(el));
+        return;
+      case "ObjectExpression":
+        value.properties.forEach((prop) => {
+          if (prop.kind === "SpreadElement") {
+            visit(prop.argument);
+            return;
+          }
+          if (prop.computed) visit(prop.key);
+          visit(prop.value);
+        });
+        return;
+      case "TemplateLiteral":
+        value.expressions.forEach((item) => visit(item));
+        return;
+      case "AssignmentExpression":
+        visit(value.left);
+        visit(value.right);
+        return;
+      case "SequenceExpression":
+        value.expressions.forEach((item) => visit(item));
+        return;
+      case "YieldExpression":
+        if (value.argument) visit(value.argument);
+        return;
+      case "TaggedTemplateExpression":
+        visit(value.tag);
+        value.quasi.expressions.forEach((item) => visit(item));
+        return;
+      case "ImportExpression":
+        visit(value.source);
+        return;
+      case "ArrowFunction":
+        if (Array.isArray(value.body)) {
+          value.body.forEach((block) => {
+            block.instructions.forEach((instr) => {
+              if (instr.kind === "Assign" || instr.kind === "Expression") {
+                visit(instr.value);
+              }
+            });
+          });
+        } else {
+          visit(value.body);
+        }
+        return;
+      case "FunctionExpression":
+        value.body.forEach((block) => {
+          block.instructions.forEach((instr) => {
+            if (instr.kind === "Assign" || instr.kind === "Expression") {
+              visit(instr.value);
+            }
+          });
+        });
+        return;
+      case "JSXElement":
+        if (typeof value.tagName !== "string") visit(value.tagName);
+        value.attributes.forEach((attr) => {
+          if (attr.isSpread && attr.spreadExpr) {
+            visit(attr.spreadExpr);
+          } else if (attr.value) {
+            visit(attr.value);
+          }
+        });
+        value.children.forEach((child) => {
+          if (child.kind === "expression") visit(child.value);
+          if (child.kind === "element") visit(child.value);
+        });
+        return;
+      case "Identifier":
+      case "Literal":
+      case "MetaProperty":
+      case "NewExpression":
+      case "ClassExpression":
+      case "ThisExpression":
+      case "SuperExpression":
+        if (value.kind === "NewExpression") {
+          visit(value.callee);
+          value.arguments.forEach((arg) => visit(arg));
+        }
+        if (value.kind === "ClassExpression" && value.superClass) visit(value.superClass);
+        return;
+      default:
+        return;
+    }
+  };
+  visit(expr);
+  return found;
+}
+function instructionContainsMacroCall(instruction, macroName) {
+  if (instruction.kind !== "Assign" && instruction.kind !== "Expression") return false;
+  return expressionContainsMacroCall(instruction.value, macroName);
+}
+function functionUsesMacro(fn, macroName) {
+  for (const block of fn.blocks) {
+    for (const instruction of block.instructions) {
+      if (instructionContainsMacroCall(instruction, macroName)) return true;
+    }
+    const term = block.terminator;
+    if ("argument" in term && term.argument && expressionContainsMacroCall(term.argument, macroName)) {
+      return true;
+    }
+    if (term.kind === "Branch" && expressionContainsMacroCall(term.test, macroName)) {
+      return true;
+    }
+    if (term.kind === "Switch") {
+      if (expressionContainsMacroCall(term.discriminant, macroName)) return true;
+      if (term.cases.some((entry) => entry.test && expressionContainsMacroCall(entry.test, macroName))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function computeRegionLoc(region, fn) {
+  let loc = null;
+  for (const instruction of region.instructions) {
+    loc = mergeLoc(loc, instruction.loc);
+  }
+  for (const blockId of region.blocks) {
+    const block = fn.blocks.find((entry) => entry.id === blockId);
+    if (!block) continue;
+    loc = mergeLoc(loc, block.terminator.loc);
+  }
+  return loc;
+}
+function regionToSerializable(region, fn) {
+  const loc = computeRegionLoc(region, fn);
+  return {
+    id: region.id,
+    startLine: loc?.start.line,
+    startColumn: loc?.start.column,
+    endLine: loc?.end.line,
+    endColumn: loc?.end.column,
+    dependencies: [...region.dependencies].map(deSSAVarName),
+    declarations: [...region.declarations].map(deSSAVarName),
+    hasControlFlow: region.hasControlFlow,
+    hasReactiveWrites: region.declarations.size > 0,
+    children: region.children.map((child) => regionToSerializable(child, fn))
+  };
+}
+function warningSeverity(code) {
+  const diagnosticCodes = new Set(getAllDiagnosticCodes());
+  if (!diagnosticCodes.has(code)) return "warning" /* Warning */;
+  return getDiagnosticInfo(code).severity;
+}
+function normalizeWarningToDiagnostic(warning) {
+  return {
+    code: warning.code,
+    message: warning.message,
+    severity: warningSeverity(warning.code),
+    line: warning.line,
+    column: warning.column
+  };
+}
+function normalizeThrownError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    code: "FICT-COMPILE",
+    message,
+    severity: "error" /* Error */,
+    line: 0,
+    column: 0
+  };
+}
+function analyzeDiagnostics(code, fileName, options) {
+  const warnings = [];
+  const pluginOptions = {
+    dev: true,
+    filename: fileName,
+    emitModuleMetadata: false,
+    strictGuarantee: false,
+    warningLevels: {
+      ...options.compilerOptions?.warningLevels ?? {},
+      "FICT-R004": "warn"
+    },
+    ...options.compilerOptions,
+    onWarn: (warning) => warnings.push(warning)
+  };
+  try {
+    transformSync(code, {
+      filename: fileName,
+      configFile: false,
+      babelrc: false,
+      sourceType: "module",
+      parserOpts: {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"],
+        allowReturnOutsideFunction: true
+      },
+      plugins: [[index_default, pluginOptions]],
+      generatorOpts: {
+        compact: false
+      }
+    });
+  } catch (error) {
+    return [...warnings.map(normalizeWarningToDiagnostic), normalizeThrownError(error)];
+  }
+  return warnings.map(normalizeWarningToDiagnostic);
+}
+function shouldIncludeFunction(fn) {
+  return functionContainsJSX(fn) || functionUsesMacro(fn, "$state") || functionUsesMacro(fn, "$effect");
+}
+function parseFileAst(code, fileName) {
+  const ast = parseSync(code, {
+    filename: fileName,
+    sourceType: "module",
+    parserOpts: {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"],
+      allowReturnOutsideFunction: true
+    }
+  });
+  if (!ast || ast.type !== "File") {
+    throw new Error("Failed to parse source file for Fict analysis.");
+  }
+  return ast;
+}
+function analyzeFictFile(code, fileName, options = {}) {
+  const includeRegions = options.includeRegions ?? true;
+  const includeDiagnostics = options.includeDiagnostics ?? true;
+  const verbosity = options.verbosity ?? "minimal";
+  const ast = parseFileAst(code, fileName);
+  const hir = buildHIR(
+    ast,
+    {
+      state: /* @__PURE__ */ new Set(["$state"]),
+      effect: /* @__PURE__ */ new Set(["$effect"])
+    },
+    {
+      dev: true,
+      fileName
+    }
+  );
+  const sourceLines = code.split(/\r?\n/);
+  const components = [];
+  for (const fn of hir.functions) {
+    if (!fn.loc || !shouldIncludeFunction(fn)) continue;
+    const startLine = fn.loc.start.line;
+    const endLine = fn.loc.end.line;
+    const scopeResult = analyzeReactiveScopesWithSSA(fn);
+    const regionResult = generateRegions(fn, scopeResult);
+    const regions = includeRegions ? regionResult.topLevelRegions.map((region) => regionToSerializable(region, fn)) : void 0;
+    const trace = inferTraceMarkersForComponent({
+      fn,
+      sourceLines,
+      startLine,
+      endLine,
+      verbosity,
+      regions
+    });
+    components.push({
+      name: fn.name ?? "<anonymous>",
+      startLine,
+      endLine,
+      trace,
+      regions
+    });
+  }
+  const diagnostics = includeDiagnostics ? analyzeDiagnostics(code, fileName, options) : [];
+  return {
+    fileName,
+    components,
+    diagnostics
+  };
+}
+
 // src/index.ts
 function stripMacroImports(path2, t4) {
   path2.traverse({
@@ -34696,46 +35573,77 @@ function createHIREntrypointVisitor(t4, options) {
         path2.traverse({
           JSXExpressionContainer(exprPath) {
             const expr = exprPath.node.expression;
-            if (!t4.isCallExpression(expr)) return;
-            if (!t4.isMemberExpression(expr.callee) || !t4.isIdentifier(expr.callee.property, { name: "map" })) {
+            if (!t4.isCallExpression(expr) && !t4.isOptionalCallExpression(expr)) return;
+            if (!t4.isMemberExpression(expr.callee) && !t4.isOptionalMemberExpression(expr.callee) || !t4.isIdentifier(expr.callee.property, { name: "map" })) {
               return;
             }
-            const cb = expr.arguments[0];
-            if (!cb || !t4.isArrowFunctionExpression(cb) && !t4.isFunctionExpression(cb)) return;
-            const getReturnedJsx = (fn) => {
-              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) || t4.isJSXFragment(ret.argument))) {
-                  return ret.argument;
-                }
-              }
-              return null;
-            };
-            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
-              });
+            const callExprPath = exprPath.get("expression");
+            if (!callExprPath.isCallExpression() && !callExprPath.isOptionalCallExpression()) return;
+            const argPaths = callExprPath.get("arguments");
+            const cbPath = Array.isArray(argPaths) ? argPaths[0] : void 0;
+            if (!cbPath || !cbPath.isArrowFunctionExpression() && !cbPath.isFunctionExpression()) {
               return;
             }
-            let hasKey = false;
-            let hasUnknownSpread = false;
-            for (const attr of jsx.openingElement.attributes) {
-              if (t4.isJSXAttribute(attr) && t4.isJSXIdentifier(attr.name, { name: "key" })) {
-                hasKey = true;
-                break;
+            const getReturnedJsx = (fnPath) => {
+              const collectReturnedJsxFromExpression = (node, returned2) => {
+                if (!node) return;
+                if (t4.isJSXElement(node) || t4.isJSXFragment(node)) {
+                  returned2.push(node);
+                  return;
+                }
+                if (t4.isConditionalExpression(node)) {
+                  collectReturnedJsxFromExpression(node.consequent, returned2);
+                  collectReturnedJsxFromExpression(node.alternate, returned2);
+                  return;
+                }
+                if (t4.isLogicalExpression(node)) {
+                  collectReturnedJsxFromExpression(node.left, returned2);
+                  collectReturnedJsxFromExpression(node.right, returned2);
+                  return;
+                }
+                if (t4.isSequenceExpression(node)) {
+                  const tail = node.expressions[node.expressions.length - 1];
+                  collectReturnedJsxFromExpression(tail, returned2);
+                  return;
+                }
+                if (t4.isParenthesizedExpression(node)) {
+                  collectReturnedJsxFromExpression(node.expression, returned2);
+                  return;
+                }
+                if (t4.isTSAsExpression(node) || t4.isTSTypeAssertion(node) || t4.isTSNonNullExpression(node) || t4.isTSSatisfiesExpression(node) || t4.isTypeCastExpression(node)) {
+                  collectReturnedJsxFromExpression(node.expression, returned2);
+                }
+              };
+              const fn = fnPath.node;
+              const returned = [];
+              if (!t4.isBlockStatement(fn.body)) {
+                collectReturnedJsxFromExpression(fn.body, returned);
+                return returned;
               }
-              if (t4.isJSXSpreadAttribute(attr)) {
-                hasUnknownSpread = true;
+              fnPath.get("body").traverse({
+                Function(innerFnPath) {
+                  innerFnPath.skip();
+                },
+                ReturnStatement(retPath) {
+                  collectReturnedJsxFromExpression(retPath.node.argument, returned);
+                }
+              });
+              return returned;
+            };
+            const returnedJsx = getReturnedJsx(cbPath);
+            if (returnedJsx.length === 0) return;
+            const hasMissingKeyBranch = returnedJsx.some((jsx) => {
+              if (t4.isJSXFragment(jsx)) return true;
+              let hasKey = false;
+              for (const attr of jsx.openingElement.attributes) {
+                if (t4.isJSXAttribute(attr) && t4.isJSXIdentifier(attr.name, { name: "key" })) {
+                  hasKey = true;
+                  break;
+                }
               }
-            }
-            if (hasKey || hasUnknownSpread) return;
+              return !hasKey;
+            });
+            if (!hasMissingKeyBranch) return;
             warn({
               code: "FICT-J002",
               message: "Missing key prop in list rendering.",
@@ -35297,9 +36205,11 @@ var createFictPlugin = declare(
 );
 var index_default = createFictPlugin;
 export {
+  analyzeFictFile,
   clearModuleMetadata,
   createFictPlugin,
   index_default as default,
+  inferTraceMarkersForComponent,
   resolveModuleMetadata,
   setModuleMetadata
 };