@fictjs/compiler 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -14121,8 +14121,34 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_helper_plugin_utils = require("@babel/helper-plugin-utils");
 
+// ../runtime/src/delegated-events.ts
+var DelegatedEventNames = [
+  "beforeinput",
+  "click",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+
 // src/constants.ts
-var RUNTIME_MODULE = "@fictjs/runtime";
+var RUNTIME_MODULE = "@fictjs/runtime/internal";
 var RUNTIME_HELPERS = {
   signal: "createSignal",
   createSelector: "createSelector",
@@ -14139,11 +14165,10 @@ var RUNTIME_HELPERS = {
   propGetter: "__fictProp",
   propsRest: "__fictPropsRest",
   mergeProps: "mergeProps",
-  useProp: "useProp",
+  prop: "prop",
   runInScope: "runInScope",
   createElement: "createElement",
   conditional: "createConditional",
-  list: "createList",
   keyedList: "createKeyedList",
   insert: "insert",
   onDestroy: "onDestroy",
@@ -14156,11 +14181,6 @@ var RUNTIME_HELPERS = {
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
   toNodeArray: "toNodeArray",
-  createKeyedListContainer: "createKeyedListContainer",
-  createKeyedBlock: "createKeyedBlock",
-  moveMarkerBlock: "moveMarkerBlock",
-  destroyMarkerBlock: "destroyMarkerBlock",
-  getFirstNodeAfter: "getFirstNodeAfter",
   template: "template",
   delegateEvents: "delegateEvents"
 };
@@ -14179,12 +14199,11 @@ var RUNTIME_ALIASES = {
   fragment: "Fragment",
   propGetter: "__fictProp",
   propsRest: "__fictPropsRest",
-  useProp: "useProp",
+  prop: "prop",
   mergeProps: "mergeProps",
   runInScope: "runInScope",
   createElement: "createElement",
   conditional: "createConditional",
-  list: "createList",
   keyedList: "createKeyedList",
   insert: "insert",
   onDestroy: "onDestroy",
@@ -14197,38 +14216,10 @@ var RUNTIME_ALIASES = {
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
   toNodeArray: "toNodeArray",
-  createKeyedListContainer: "createKeyedListContainer",
-  createKeyedBlock: "createKeyedBlock",
-  moveMarkerBlock: "moveMarkerBlock",
-  destroyMarkerBlock: "destroyMarkerBlock",
-  getFirstNodeAfter: "getFirstNodeAfter",
   template: "template",
   delegateEvents: "delegateEvents"
 };
-var DelegatedEvents = /* @__PURE__ */ new Set([
-  "beforeinput",
-  "click",
-  "dblclick",
-  "contextmenu",
-  "focusin",
-  "focusout",
-  "input",
-  "keydown",
-  "keyup",
-  "mousedown",
-  "mousemove",
-  "mouseout",
-  "mouseover",
-  "mouseup",
-  "pointerdown",
-  "pointermove",
-  "pointerout",
-  "pointerover",
-  "pointerup",
-  "touchend",
-  "touchmove",
-  "touchstart"
-]);
+var DelegatedEvents = /* @__PURE__ */ new Set([...DelegatedEventNames]);
 var SAFE_FUNCTIONS = /* @__PURE__ */ new Set([
   // Console methods
   "console.log",
@@ -14318,9 +14309,13 @@ var HIRError = class extends Error {
   }
 };
 var SSA_PATTERN = /\$\$ssa\d+$/;
+var GENERATED_SSA_NAMES = /* @__PURE__ */ new Set();
 function getSSABaseName(name) {
   if (name.startsWith("__")) return name;
-  return name.replace(SSA_PATTERN, "");
+  if (GENERATED_SSA_NAMES.has(name)) {
+    return name.replace(SSA_PATTERN, "");
+  }
+  return SSA_PATTERN.test(name) ? name : name;
 }
 function extractDependencyPath(expr) {
   if (expr.kind === "Identifier") {
@@ -16050,38 +16045,6 @@ function debugEnabled(flag) {
   return parts.includes(normalized) || parts.includes("all");
 }
 
-// src/utils.ts
-function isStateCall(node, t2) {
-  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$state";
-}
-function isEffectCall(node, t2) {
-  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$effect";
-}
-function getRootIdentifier(expr, t2) {
-  if (t2.isIdentifier(expr)) {
-    return expr;
-  }
-  if (t2.isMemberExpression(expr) && t2.isExpression(expr.object) && !t2.isOptionalMemberExpression(expr)) {
-    return getRootIdentifier(expr.object, t2);
-  }
-  if (t2.isOptionalMemberExpression(expr) && t2.isExpression(expr.object)) {
-    return getRootIdentifier(expr.object, t2);
-  }
-  if (t2.isCallExpression(expr) && t2.isExpression(expr.callee)) {
-    return getRootIdentifier(expr.callee, t2);
-  }
-  if (t2.isOptionalCallExpression(expr) && t2.isExpression(expr.callee)) {
-    return getRootIdentifier(expr.callee, t2);
-  }
-  if (t2.isTSAsExpression(expr) && t2.isExpression(expr.expression)) {
-    return getRootIdentifier(expr.expression, t2);
-  }
-  if (t2.isTSNonNullExpression(expr) && t2.isExpression(expr.expression)) {
-    return getRootIdentifier(expr.expression, t2);
-  }
-  return null;
-}
-
 // src/fine-grained-dom.ts
 function normalizeDependencyKey(name) {
   return name.split(".").map((part) => part.replace(/_\d+$/, "")).join(".");
@@ -16090,35 +16053,113 @@ function applyRegionMetadata(state, options) {
   if (!options.region) return;
   const region = options.region;
   state.regionMetadata = region;
-  if (region.dependencies.size > 0) {
-    state.identifierOverrides = state.identifierOverrides ?? {};
-    const dependencyGetter = options.dependencyGetter ?? null;
-    if (!dependencyGetter) {
-      return;
-    }
-    for (const dep of region.dependencies) {
-      const key = normalizeDependencyKey(dep);
-      state.identifierOverrides[key] = () => dependencyGetter(dep);
-      const base = key.split(".")[0];
-      if (base && !state.identifierOverrides[base]) {
-        state.identifierOverrides[base] = () => dependencyGetter(base);
-      }
+  if (region.dependencies.size === 0) return;
+  const dependencyGetter = options.dependencyGetter;
+  if (!dependencyGetter) return;
+  state.identifierOverrides = state.identifierOverrides ?? {};
+  for (const dep of region.dependencies) {
+    const key = normalizeDependencyKey(dep);
+    state.identifierOverrides[key] = () => dependencyGetter(dep);
+    const base = key.split(".")[0];
+    if (base && !state.identifierOverrides[base]) {
+      state.identifierOverrides[base] = () => dependencyGetter(base);
     }
   }
 }
 function shouldMemoizeRegion(region) {
-  if (region.dependencies.size > 0) {
-    return true;
-  }
-  if (region.hasControlFlow) {
-    return true;
-  }
-  if (region.hasReactiveWrites) {
-    return true;
-  }
+  if (region.dependencies.size > 0) return true;
+  if (region.hasControlFlow) return true;
+  if (region.hasReactiveWrites) return true;
   return false;
 }
 
+// src/validation.ts
+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.",
+  ["FICT-P003" /* FICT_P003 */]: "Computed property in props pattern cannot be made reactive.",
+  ["FICT-P004" /* FICT_P004 */]: "Nested props destructuring falls back to non-reactive binding; access props directly or use prop.",
+  ["FICT-S001" /* FICT_S001 */]: "State variable mutation detected outside component scope.",
+  ["FICT-S002" /* FICT_S002 */]: "State variable escaped to external scope, may cause memory leaks.",
+  ["FICT-E001" /* FICT_E001 */]: "Effect without reactive dependencies will run only once; consider adding state reads or removing the effect.",
+  ["FICT-E002" /* FICT_E002 */]: "Effect captures reactive value that may change.",
+  ["FICT-E003" /* FICT_E003 */]: "Effect cleanup function is not properly tracked.",
+  ["FICT-M001" /* FICT_M001 */]: "Memo has no reactive dependencies and could be a constant.",
+  ["FICT-M002" /* FICT_M002 */]: "Unnecessary memo wrapping a constant value.",
+  ["FICT-M003" /* FICT_M003 */]: "Memo should not contain side effects.",
+  ["FICT-C001" /* FICT_C001 */]: "Hooks should not be called conditionally.",
+  ["FICT-C002" /* FICT_C002 */]: "Hooks should not be called inside loops.",
+  ["FICT-C003" /* FICT_C003 */]: "Components should not be defined inside other components.",
+  ["FICT-C004" /* FICT_C004 */]: "Component has no return statement and will render nothing.",
+  ["FICT-J001" /* FICT_J001 */]: "Dynamic key expression may impact performance.",
+  ["FICT-J002" /* FICT_J002 */]: "Missing key prop in list rendering.",
+  ["FICT-J003" /* FICT_J003 */]: "Spread on native element may include unknown props.",
+  ["FICT-R001" /* FICT_R001 */]: "Expression crosses reactive region boundary.",
+  ["FICT-R002" /* FICT_R002 */]: "Scope escape detected, value may not be tracked.",
+  ["FICT-R003" /* FICT_R003 */]: "Expression cannot be memoized automatically.",
+  ["FICT-R004" /* FICT_R004 */]: "Reactive creation inside non-JSX control flow will not auto-dispose; wrap it in createScope/runInScope or move it into JSX-managed regions.",
+  ["FICT-R005" /* FICT_R005 */]: "Function captures reactive variables from outer scope; pass them as parameters or memoize explicitly to avoid hidden dependencies.",
+  ["FICT-X001" /* FICT_X001 */]: "Object is recreated on each render, consider memoizing.",
+  ["FICT-X002" /* FICT_X002 */]: "Array is recreated on each render, consider memoizing.",
+  ["FICT-X003" /* FICT_X003 */]: "Inline function in JSX props may cause unnecessary re-renders."
+};
+var DiagnosticSeverities = {
+  ["FICT-P001" /* FICT_P001 */]: "warning" /* Warning */,
+  ["FICT-P002" /* FICT_P002 */]: "warning" /* Warning */,
+  ["FICT-P003" /* FICT_P003 */]: "warning" /* Warning */,
+  ["FICT-P004" /* FICT_P004 */]: "warning" /* Warning */,
+  ["FICT-S001" /* FICT_S001 */]: "error" /* Error */,
+  ["FICT-S002" /* FICT_S002 */]: "warning" /* Warning */,
+  ["FICT-E001" /* FICT_E001 */]: "warning" /* Warning */,
+  ["FICT-E002" /* FICT_E002 */]: "info" /* Info */,
+  ["FICT-E003" /* FICT_E003 */]: "warning" /* Warning */,
+  ["FICT-M001" /* FICT_M001 */]: "info" /* Info */,
+  ["FICT-M002" /* FICT_M002 */]: "hint" /* Hint */,
+  ["FICT-M003" /* FICT_M003 */]: "error" /* Error */,
+  ["FICT-C001" /* FICT_C001 */]: "error" /* Error */,
+  ["FICT-C002" /* FICT_C002 */]: "error" /* Error */,
+  ["FICT-C003" /* FICT_C003 */]: "warning" /* Warning */,
+  ["FICT-C004" /* FICT_C004 */]: "warning" /* Warning */,
+  ["FICT-J001" /* FICT_J001 */]: "info" /* Info */,
+  ["FICT-J002" /* FICT_J002 */]: "warning" /* Warning */,
+  ["FICT-J003" /* FICT_J003 */]: "info" /* Info */,
+  ["FICT-R001" /* FICT_R001 */]: "info" /* Info */,
+  ["FICT-R002" /* FICT_R002 */]: "warning" /* Warning */,
+  ["FICT-R003" /* FICT_R003 */]: "info" /* Info */,
+  ["FICT-R004" /* FICT_R004 */]: "warning" /* Warning */,
+  ["FICT-R005" /* FICT_R005 */]: "warning" /* Warning */,
+  ["FICT-X001" /* FICT_X001 */]: "hint" /* Hint */,
+  ["FICT-X002" /* FICT_X002 */]: "hint" /* Hint */,
+  ["FICT-X003" /* FICT_X003 */]: "hint" /* Hint */
+};
+function createDiagnostic(code, node, fileName, context) {
+  const loc = node.loc;
+  return {
+    code,
+    severity: DiagnosticSeverities[code],
+    message: DiagnosticMessages[code],
+    fileName,
+    line: loc?.start.line ?? 0,
+    column: loc?.start.column ?? 0,
+    endLine: loc?.end.line,
+    endColumn: loc?.end.column,
+    context
+  };
+}
+function reportDiagnostic(ctx, code, node, context) {
+  const fileName = ctx.file?.opts?.filename || "<unknown>";
+  const diagnostic = createDiagnostic(code, node, fileName, context);
+  if (ctx.options?.onWarn) {
+    ctx.options.onWarn({
+      code: diagnostic.code,
+      message: diagnostic.message,
+      fileName: diagnostic.fileName,
+      line: diagnostic.line,
+      column: diagnostic.column
+    });
+  }
+}
+
 // src/ir/ssa.ts
 function analyzeCFG(blocks) {
   const predecessors = computePredecessors(blocks);
@@ -19424,7 +19465,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
     const isTracked = ctx.trackedVars.has(baseName2);
     const isSignal = ctx.signalVars?.has(baseName2) ?? false;
     const aliasVars = ctx.aliasVars ?? (ctx.aliasVars = /* @__PURE__ */ new Set());
-    const dependsOnTracked2 = expressionUsesTracked(instr.value, ctx) || (ctx.memoVars?.has(baseName2) ?? false);
+    const dependsOnTracked = expressionUsesTracked(instr.value, ctx) || (ctx.memoVars?.has(baseName2) ?? false);
     const capturedTracked = ctx.externalTracked && ctx.externalTracked.has(baseName2) && !declaredVars.has(baseName2);
     const isShadowDeclaration = !!declKind && declaredVars.has(baseName2);
     const treatAsTracked = !isShadowDeclaration && isTracked;
@@ -19432,8 +19473,8 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
     const isStateCall2 = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && instr.value.callee.name === "$state";
     const inRegionMemo = ctx.inRegionMemo ?? false;
     const isFunctionValue = instr.value.kind === "ArrowFunction" || instr.value.kind === "FunctionExpression";
-    const isAccessorReturningCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["$memo", "createMemo", "useProp"].includes(instr.value.callee.name);
-    const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps", "prop"].includes(instr.value.callee.name);
+    const isAccessorReturningCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["$memo", "createMemo", "prop"].includes(instr.value.callee.name);
+    const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps"].includes(instr.value.callee.name);
     const isMemoReturningCall = isAccessorReturningCall || isReactiveObjectCall;
     const lowerAssignedValue = (forceAssigned = false) => lowerExpressionWithDeSSA(instr.value, ctx, forceAssigned || isFunctionValue);
     const buildMemoCall = (expr) => {
@@ -19455,10 +19496,10 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
       ctx.trackedVars.delete(baseName2);
     }
     if (declKind) {
-      const normalizedDecl = isStateCall2 || dependsOnTracked2 && !isDestructuringTemp ? "const" : declKind;
+      const normalizedDecl = isStateCall2 || dependsOnTracked && !isDestructuringTemp ? "const" : declKind;
       const needsMutable = ctx.mutatedVars?.has(baseName2) ?? false;
       const isExternalAlias = declKind === "const" && instr.value.kind === "Identifier" && !(ctx.scopes?.byName?.has(deSSAVarName(instr.value.name)) ?? false);
-      const fallbackDecl = !treatAsTracked && (!dependsOnTracked2 || isDestructuringTemp) ? declKind === "const" && (needsMutable || isExternalAlias) ? "let" : declKind : normalizedDecl;
+      const fallbackDecl = !treatAsTracked && (!dependsOnTracked || isDestructuringTemp) ? declKind === "const" && (needsMutable || isExternalAlias) ? "let" : declKind : normalizedDecl;
       declaredVars.add(baseName2);
       if (treatAsTracked && !isDestructuringTemp) {
         if (isStateCall2) {
@@ -19466,7 +19507,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
             t2.variableDeclarator(t2.identifier(baseName2), lowerAssignedValue(true))
           ]);
         }
-        if (dependsOnTracked2) {
+        if (dependsOnTracked) {
           if (instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name)) && !isDestructuringTemp) {
             aliasVars.add(baseName2);
           }
@@ -19493,7 +19534,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           ]);
         }
       }
-      if (dependsOnTracked2 && !isDestructuringTemp) {
+      if (dependsOnTracked && !isDestructuringTemp) {
         if (instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name)) && !isDestructuringTemp) {
           aliasVars.add(baseName2);
         }
@@ -19534,7 +19575,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
     if (aliasVars.has(baseName2) && !declaredVars.has(baseName2)) {
       throw new Error(`Alias reassignment is not supported for "${baseName2}"`);
     }
-    if (dependsOnTracked2 && !declKind && !isDestructuringTemp && !isTracked && !isSignal && instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name))) {
+    if (dependsOnTracked && !declKind && !isDestructuringTemp && !isTracked && !isSignal && instr.value.kind === "Identifier" && ctx.trackedVars.has(deSSAVarName(instr.value.name))) {
       const derivedExpr = lowerAssignedValue(true);
       aliasVars.add(baseName2);
       if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
@@ -19585,7 +19626,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
           t2.variableDeclarator(t2.identifier(baseName2), lowerAssignedValue(true))
         ]);
       }
-      if (dependsOnTracked2) {
+      if (dependsOnTracked) {
         const derivedExpr = lowerAssignedValue(true);
         if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
           return t2.variableDeclaration("const", [
@@ -19612,7 +19653,7 @@ function instructionToStatement(instr, t2, declaredVars, ctx, _buildMemoCall) {
         t2.variableDeclarator(t2.identifier(baseName2), lowerAssignedValue(true))
       ]);
     }
-    if (dependsOnTracked2) {
+    if (dependsOnTracked) {
       const derivedExpr = lowerAssignedValue(true);
       if (ctx.nonReactiveScopeDepth && ctx.nonReactiveScopeDepth > 0) {
         return t2.variableDeclaration("let", [
@@ -21067,7 +21108,7 @@ function computeReactiveAccessors(fn, ctx) {
             tracked.add(target);
             changed = true;
           }
-          const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps", "prop"].includes(instr.value.callee.name);
+          const isReactiveObjectCall = instr.value.kind === "CallExpression" && instr.value.callee.kind === "Identifier" && ["mergeProps"].includes(instr.value.callee.name);
           if (hasDataDep && !isSignal(target) && !isStore(target) && !isReactiveObjectCall) {
             memo.add(target);
           }
@@ -21690,8 +21731,8 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
           const shouldMemoProp = usesTracked && !t2.isIdentifier(valueExprRaw) && !t2.isMemberExpression(valueExprRaw) && !t2.isLiteral(valueExprRaw);
           const valueExpr = usesTracked && ctx.t.isExpression(valueExprRaw) ? (() => {
             if (shouldMemoProp) {
-              ctx.helpersUsed.add("useProp");
-              return t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
+              ctx.helpersUsed.add("prop");
+              return t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
                 t2.arrowFunctionExpression([], valueExprRaw)
               ]);
             }
@@ -22257,6 +22298,9 @@ function applyRegionMetadataToExpression(expr, ctx, regionOverride, options) {
 }
 function replaceIdentifiersWithOverrides(node, overrides, t2, parentKind, parentKey, skipCurrentNode = false) {
   const isCallTarget = parentKey === "callee" && (parentKind === "CallExpression" || parentKind === "OptionalCallExpression");
+  if (parentKind === "VariableDeclarator" && parentKey === "id") {
+    return;
+  }
   const collectParamNames = (params) => {
     const names = /* @__PURE__ */ new Set();
     const addName = (n) => {
@@ -23623,7 +23667,7 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
   if (isKeyed) {
     ctx.helpersUsed.add("keyedList");
   } else {
-    ctx.helpersUsed.add("list");
+    ctx.helpersUsed.add("keyedList");
     ctx.helpersUsed.add("createElement");
   }
   const prevHoistedTemplates = ctx.hoistedTemplates;
@@ -23664,6 +23708,17 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
       overrides[secondParam.name] = () => t2.callExpression(t2.identifier(secondParam.name), []);
     }
     if (Object.keys(overrides).length > 0) {
+      if (t2.isBlockStatement(callbackExpr.body)) {
+        for (const stmt of callbackExpr.body.body) {
+          if (!t2.isVariableDeclaration(stmt)) continue;
+          for (const decl of stmt.declarations) {
+            if (!t2.isIdentifier(decl.id) || !decl.init) continue;
+            const replacement = t2.cloneNode(decl.init, true);
+            replaceIdentifiersWithOverrides(replacement, overrides, t2, callbackExpr.type, "body");
+            overrides[decl.id.name] = () => t2.cloneNode(replacement, true);
+          }
+        }
+      }
       if (t2.isBlockStatement(callbackExpr.body)) {
         replaceIdentifiersWithOverrides(callbackExpr.body, overrides, t2, callbackExpr.type, "body");
       } else {
@@ -23742,14 +23797,22 @@ function emitListChild(parentId, markerId, expr, statements, ctx) {
     );
   } else {
     statements.push(...hoistedStatements);
+    const itemParamName = t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr) ? t2.isIdentifier(callbackExpr.params[0]) ? callbackExpr.params[0].name : "__item" : "__item";
+    const indexParamName = t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr) ? t2.isIdentifier(callbackExpr.params[1]) ? callbackExpr.params[1].name : "__index" : "__index";
+    const hasIndexParam = (t2.isArrowFunctionExpression(callbackExpr) || t2.isFunctionExpression(callbackExpr)) && callbackExpr.params.length >= 2;
+    const keyFn = t2.arrowFunctionExpression(
+      [t2.identifier(itemParamName), t2.identifier(indexParamName)],
+      t2.identifier(indexParamName)
+    );
     statements.push(
       t2.variableDeclaration("const", [
         t2.variableDeclarator(
           listId,
-          t2.callExpression(t2.identifier(RUNTIME_ALIASES.list), [
+          t2.callExpression(t2.identifier(RUNTIME_ALIASES.keyedList), [
             t2.arrowFunctionExpression([], arrayExpr),
+            keyFn,
             callbackExpr,
-            t2.identifier(RUNTIME_ALIASES.createElement)
+            t2.booleanLiteral(hasIndexParam)
           ])
         )
       ])
@@ -23869,8 +23932,8 @@ function buildPropsObject(attributes, ctx) {
           ]);
         })() : usesTracked && t2.isExpression(lowered) ? (() => {
           if (useMemoProp) {
-            ctx.helpersUsed.add("useProp");
-            return t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
+            ctx.helpersUsed.add("prop");
+            return t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
               t2.arrowFunctionExpression(
                 [],
                 trackedExpr ?? lowered
@@ -24392,61 +24455,100 @@ function lowerFunctionWithRegions(fn, ctx) {
       const stmts = [];
       const excludeKeys = [];
       let supported = true;
-      let usesUseProp = false;
+      let usesProp = false;
       let usesPropsRest = false;
-      for (const prop of pattern.properties) {
-        if (t2.isObjectProperty(prop) && !prop.computed) {
-          const keyName = t2.isIdentifier(prop.key) ? prop.key.name : t2.isStringLiteral(prop.key) ? prop.key.value : t2.isNumericLiteral(prop.key) ? String(prop.key.value) : null;
-          if (!keyName || !t2.isIdentifier(prop.value)) {
+      let warnedNested = false;
+      const memberExprForKey = (base, key) => t2.memberExpression(base, t2.identifier(key), false);
+      const buildDestructure = (objectPattern, baseExpr, allowRest) => {
+        for (const prop of objectPattern.properties) {
+          if (t2.isObjectProperty(prop) && !prop.computed) {
+            const keyName = t2.isIdentifier(prop.key) ? prop.key.name : t2.isStringLiteral(prop.key) ? prop.key.value : t2.isNumericLiteral(prop.key) ? String(prop.key.value) : null;
+            if (!keyName) {
+              reportDiagnostic(ctx, "FICT-P003" /* FICT_P003 */, prop);
+              supported = false;
+              warnedNested = true;
+              break;
+            }
+            if (allowRest) {
+              excludeKeys.push(t2.stringLiteral(keyName));
+            }
+            const member = memberExprForKey(baseExpr, keyName);
+            const value = prop.value;
+            if (t2.isIdentifier(value)) {
+              const shouldWrapProp = !calledIdentifiers.has(value.name);
+              if (shouldWrapProp) {
+                usesProp = true;
+                propsPlanAliases.add(value.name);
+              }
+              stmts.push(
+                t2.variableDeclaration("const", [
+                  t2.variableDeclarator(
+                    t2.identifier(value.name),
+                    shouldWrapProp ? t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
+                      t2.arrowFunctionExpression([], member)
+                    ]) : member
+                  )
+                ])
+              );
+              continue;
+            }
+            if (t2.isObjectPattern(value)) {
+              buildDestructure(value, member, false);
+              if (!supported) break;
+              continue;
+            }
+            if (t2.isAssignmentPattern(value) && t2.isIdentifier(value.left)) {
+              const shouldWrapProp = !calledIdentifiers.has(value.left.name);
+              if (shouldWrapProp) {
+                usesProp = true;
+                propsPlanAliases.add(value.left.name);
+              }
+              const baseInit = t2.logicalExpression("??", member, value.right);
+              const init = shouldWrapProp ? t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
+                t2.arrowFunctionExpression([], baseInit)
+              ]) : baseInit;
+              stmts.push(
+                t2.variableDeclaration("const", [
+                  t2.variableDeclarator(t2.identifier(value.left.name), init)
+                ])
+              );
+              continue;
+            }
             supported = false;
+            if (!warnedNested) {
+              reportDiagnostic(ctx, "FICT-P004" /* FICT_P004 */, prop);
+              warnedNested = true;
+            }
             break;
-          }
-          excludeKeys.push(t2.stringLiteral(keyName));
-          const member = t2.memberExpression(t2.identifier("__props"), t2.identifier(keyName), false);
-          if (!calledIdentifiers.has(prop.value.name)) {
-            usesUseProp = true;
-            propsPlanAliases.add(prop.value.name);
+          } else if (t2.isRestElement(prop) && allowRest && t2.isIdentifier(prop.argument)) {
+            usesPropsRest = true;
             stmts.push(
               t2.variableDeclaration("const", [
                 t2.variableDeclarator(
-                  t2.identifier(prop.value.name),
-                  t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
-                    t2.arrowFunctionExpression([], member)
+                  t2.identifier(prop.argument.name),
+                  t2.callExpression(t2.identifier(RUNTIME_ALIASES.propsRest), [
+                    baseExpr,
+                    t2.arrayExpression(excludeKeys)
                   ])
                 )
               ])
             );
+            continue;
           } else {
-            stmts.push(
-              t2.variableDeclaration("const", [
-                t2.variableDeclarator(t2.identifier(prop.value.name), member)
-              ])
-            );
+            supported = false;
+            if (!warnedNested) {
+              reportDiagnostic(ctx, "FICT-P004" /* FICT_P004 */, prop);
+              warnedNested = true;
+            }
+            break;
           }
-          continue;
-        }
-        if (t2.isRestElement(prop) && t2.isIdentifier(prop.argument)) {
-          usesPropsRest = true;
-          stmts.push(
-            t2.variableDeclaration("const", [
-              t2.variableDeclarator(
-                t2.identifier(prop.argument.name),
-                t2.callExpression(t2.identifier(RUNTIME_ALIASES.propsRest), [
-                  t2.identifier("__props"),
-                  t2.arrayExpression(excludeKeys)
-                ])
-              )
-            ])
-          );
-          continue;
         }
-        supported = false;
-        break;
-      }
+      };
+      buildDestructure(pattern, t2.identifier("__props"), true);
       if (supported) {
         propsDestructurePlan = {
           statements: stmts,
-          usesUseProp,
+          usesProp,
           usesPropsRest
         };
         propsPlanAliases.forEach((name) => {
@@ -24540,8 +24642,8 @@ function lowerFunctionWithRegions(fn, ctx) {
       finalParams = [t2.identifier("__props")];
       const pattern = rawParam.type === "AssignmentPattern" ? rawParam.left : rawParam;
       if (propsDestructurePlan) {
-        if (propsDestructurePlan.usesUseProp) {
-          ctx.helpersUsed.add("useProp");
+        if (propsDestructurePlan.usesProp) {
+          ctx.helpersUsed.add("prop");
         }
         if (propsDestructurePlan.usesPropsRest) {
           ctx.helpersUsed.add("propsRest");
@@ -24610,6 +24712,38 @@ function flattenRegions(regions) {
   });
 }
 
+// src/utils.ts
+function isStateCall(node, t2) {
+  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$state";
+}
+function isEffectCall(node, t2) {
+  return t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.callee.name === "$effect";
+}
+function getRootIdentifier(expr, t2) {
+  if (t2.isIdentifier(expr)) {
+    return expr;
+  }
+  if (t2.isMemberExpression(expr) && t2.isExpression(expr.object) && !t2.isOptionalMemberExpression(expr)) {
+    return getRootIdentifier(expr.object, t2);
+  }
+  if (t2.isOptionalMemberExpression(expr) && t2.isExpression(expr.object)) {
+    return getRootIdentifier(expr.object, t2);
+  }
+  if (t2.isCallExpression(expr) && t2.isExpression(expr.callee)) {
+    return getRootIdentifier(expr.callee, t2);
+  }
+  if (t2.isOptionalCallExpression(expr) && t2.isExpression(expr.callee)) {
+    return getRootIdentifier(expr.callee, t2);
+  }
+  if (t2.isTSAsExpression(expr) && t2.isExpression(expr.expression)) {
+    return getRootIdentifier(expr.expression, t2);
+  }
+  if (t2.isTSNonNullExpression(expr) && t2.isExpression(expr.expression)) {
+    return getRootIdentifier(expr.expression, t2);
+  }
+  return null;
+}
+
 // src/index.ts
 function stripMacroImports(path, t2) {
   path.traverse({
@@ -24997,8 +25131,10 @@ function createHIREntrypointVisitor(t2, options) {
         const fileName = path.hub?.file?.opts?.filename || "<unknown>";
         const comments = path.hub?.file?.ast?.comments || [];
         const suppressions = parseSuppressions(comments);
-        const warn = createWarningDispatcher(options.onWarn, suppressions);
-        const optionsWithWarnings = { ...options, onWarn: warn };
+        const dev = options.dev !== false;
+        const warn = dev ? createWarningDispatcher(options.onWarn, suppressions) : () => {
+        };
+        const optionsWithWarnings = dev ? { ...options, onWarn: warn } : { ...options, onWarn: void 0 };
         const isHookName2 = (name) => !!name && /^use[A-Z]/.test(name);
         const getFunctionName = (fnPath) => {
           return fnPath.isFunctionDeclaration() && fnPath.node.id ? fnPath.node.id.name : fnPath.isFunctionExpression() && fnPath.node.id ? fnPath.node.id.name : fnPath.parentPath.isVariableDeclarator() && t2.isIdentifier(fnPath.parentPath.node.id) && fnPath.parentPath.node.init === fnPath.node ? fnPath.parentPath.node.id.name : void 0;
@@ -25254,6 +25390,18 @@ function createHIREntrypointVisitor(t2, options) {
           },
           CallExpression(callPath) {
             if (isStateCall(callPath.node, t2)) {
+              const parentPath = callPath.parentPath;
+              const isVariableDeclarator = parentPath?.isVariableDeclarator() && parentPath.node.init === callPath.node;
+              if (!isVariableDeclarator) {
+                throw callPath.buildCodeFrameError(
+                  "$state() must be assigned directly to a variable (e.g. let count = $state(0)). For object state, consider using $store from fict/plus."
+                );
+              }
+              if (!t2.isIdentifier(parentPath.node.id)) {
+                throw callPath.buildCodeFrameError(
+                  "Destructuring $state is not supported. Use a simple identifier."
+                );
+              }
               const ownerComponent = callPath.getFunctionParent();
               if (!ownerComponent || !isComponentOrHookDefinition(ownerComponent)) {
                 throw callPath.buildCodeFrameError(
@@ -25446,7 +25594,9 @@ function createHIREntrypointVisitor(t2, options) {
             }
           });
         }
-        runWarningPass(path, stateVars, derivedVars, warn, fileName, t2);
+        if (dev) {
+          runWarningPass(path, stateVars, derivedVars, warn, fileName, t2);
+        }
         const fileAst = t2.file(path.node);
         const hir = buildHIR(fileAst);
         const lowered = lowerHIRWithRegions(hir, t2, optionsWithWarnings);
@@ -25466,7 +25616,8 @@ var createFictPlugin = (0, import_helper_plugin_utils.declare)(
     const t2 = api.types;
     const normalizedOptions = {
       ...options,
-      fineGrainedDom: options.fineGrainedDom ?? true
+      fineGrainedDom: options.fineGrainedDom ?? true,
+      dev: options.dev ?? (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test")
     };
     return {
       name: "fict-compiler-hir",