@fictjs/compiler 0.15.0 → 0.17.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);
@@ -17073,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.",
@@ -17160,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) {
@@ -18880,6 +18921,22 @@ function structurizeBlockUntilJoin(ctx, blockId, joinBlock) {
       if (branchNode) nodes.push(branchNode);
       break;
     }
+    case "Switch": {
+      nodes.push(structurizeSwitch(ctx, block, term));
+      break;
+    }
+    case "ForOf": {
+      nodes.push(structurizeForOf(ctx, block, term));
+      break;
+    }
+    case "ForIn": {
+      nodes.push(structurizeForIn(ctx, block, term));
+      break;
+    }
+    case "Try": {
+      nodes.push(structurizeTry(ctx, block, term));
+      break;
+    }
     case "Break":
       nodes.push({ kind: "break", label: term.label });
       break;
@@ -19014,7 +19071,9 @@ function isSwitchCaseTerminated(node) {
   }
 }
 function structurizeForOf(ctx, block, term) {
+  ctx.reservedBlocks.add(term.exit);
   const body = structurizeBlock(ctx, term.body);
+  ctx.reservedBlocks.delete(term.exit);
   const exit = !ctx.emitted.has(term.exit) ? structurizeBlock(ctx, term.exit) : null;
   const forOfNode = {
     kind: "forOf",
@@ -19030,7 +19089,9 @@ function structurizeForOf(ctx, block, term) {
   return forOfNode;
 }
 function structurizeForIn(ctx, block, term) {
+  ctx.reservedBlocks.add(term.exit);
   const body = structurizeBlock(ctx, term.body);
+  ctx.reservedBlocks.delete(term.exit);
   const exit = !ctx.emitted.has(term.exit) ? structurizeBlock(ctx, term.exit) : null;
   const forInNode = {
     kind: "forIn",
@@ -24252,34 +24313,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
@@ -24884,6 +25049,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;
@@ -24983,7 +25157,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) {
@@ -25003,25 +25177,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)
     ]);
   }
@@ -25484,6 +25764,10 @@ function registerResumableComponent(componentName, ctx) {
   const hostParam = t4.identifier("host");
   const snapshotId = t4.identifier("snapshot");
   const ctxId = t4.identifier("ctx");
+  const runtimeModuleUrlExpr = t4.memberExpression(
+    t4.metaProperty(t4.identifier("import"), t4.identifier("meta")),
+    t4.identifier("url")
+  );
   ctx.helpersUsed.add("getSSRScope");
   ctx.helpersUsed.add("ensureScope");
   ctx.helpersUsed.add("prepareContext");
@@ -25557,7 +25841,10 @@ function registerResumableComponent(componentName, ctx) {
   ctx.helpersUsed.add("registerResume");
   const registerCall = t4.expressionStatement(
     t4.callExpression(t4.identifier(RUNTIME_ALIASES.registerResume), [
-      t4.stringLiteral(resumeExport),
+      t4.callExpression(t4.identifier(RUNTIME_ALIASES.qrl), [
+        runtimeModuleUrlExpr,
+        t4.stringLiteral(resumeExport)
+      ]),
       resumeFnId
     ])
   );
@@ -27347,18 +27634,8 @@ function lowerExpressionImpl(expr, ctx, valueUsed = true) {
         blocks,
         meta: { fromExpression: true }
       };
-      const cfg = analyzeCFG(fn.blocks);
-      const hasLoop = cfg.loopHeaders.size > 0 || cfg.backEdges.size > 0;
       const { node, diagnostics } = structurizeCFGWithDiagnostics(fn);
-      const structured = node.kind === "stateMachine" || hasLoop ? node.kind === "stateMachine" ? node : {
-        kind: "stateMachine",
-        blocks: fn.blocks.map((block) => ({
-          blockId: block.id,
-          instructions: block.instructions,
-          terminator: block.terminator
-        })),
-        entryBlock: fn.blocks[0]?.id ?? 0
-      } : diagnostics.isComplete ? node : {
+      const structured = node.kind === "stateMachine" ? node : diagnostics.isComplete ? node : {
         kind: "stateMachine",
         blocks: fn.blocks.map((block) => ({
           blockId: block.id,
@@ -33920,6 +34197,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({
@@ -34813,46 +35590,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.",
@@ -35414,9 +36222,11 @@ var createFictPlugin = declare(
 );
 var index_default = createFictPlugin;
 export {
+  analyzeFictFile,
   clearModuleMetadata,
   createFictPlugin,
   index_default as default,
+  inferTraceMarkersForComponent,
   resolveModuleMetadata,
   setModuleMetadata
 };