@fictjs/compiler 0.0.13 → 0.0.15

package/dist/index.js

@@ -14109,8 +14109,34 @@ var require_lib3 = __commonJS({
 // src/index.ts
 import { declare } from "@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",
@@ -14127,7 +14153,7 @@ var RUNTIME_HELPERS = {
   propGetter: "__fictProp",
   propsRest: "__fictPropsRest",
   mergeProps: "mergeProps",
-  useProp: "useProp",
+  prop: "prop",
   runInScope: "runInScope",
   createElement: "createElement",
   conditional: "createConditional",
@@ -14161,7 +14187,7 @@ var RUNTIME_ALIASES = {
   fragment: "Fragment",
   propGetter: "__fictProp",
   propsRest: "__fictPropsRest",
-  useProp: "useProp",
+  prop: "prop",
   mergeProps: "mergeProps",
   runInScope: "runInScope",
   createElement: "createElement",
@@ -14181,30 +14207,7 @@ var RUNTIME_ALIASES = {
   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",
@@ -15544,6 +15547,17 @@ function processStatement(stmt, bb, jumpTarget, ctx) {
 }
 function convertExpression(node) {
   const loc = getLoc(node);
+  const convertCallArguments = (args) => args.map((arg) => {
+    if (t.isSpreadElement(arg)) {
+      return {
+        kind: "SpreadElement",
+        argument: convertExpression(arg.argument),
+        loc: getLoc(arg)
+      };
+    }
+    if (t.isExpression(arg)) return convertExpression(arg);
+    return void 0;
+  }).filter(Boolean);
   if (t.isIdentifier(node)) return { kind: "Identifier", name: node.name, loc };
   if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node))
     return { kind: "Literal", value: node.value ?? null, loc };
@@ -15551,7 +15565,7 @@ function convertExpression(node) {
     const call = {
       kind: "CallExpression",
       callee: convertExpression(node.callee),
-      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
+      arguments: convertCallArguments(node.arguments),
       loc
     };
     return call;
@@ -15831,7 +15845,7 @@ function convertExpression(node) {
     return {
       kind: "NewExpression",
       callee: convertExpression(node.callee),
-      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
+      arguments: convertCallArguments(node.arguments),
       loc
     };
   }
@@ -15854,7 +15868,7 @@ function convertExpression(node) {
     return {
       kind: "OptionalCallExpression",
       callee: convertExpression(node.callee),
-      arguments: node.arguments.map((arg) => t.isExpression(arg) ? convertExpression(arg) : void 0).filter(Boolean),
+      arguments: convertCallArguments(node.arguments),
       optional: node.optional,
       loc
     };
@@ -16063,7 +16077,8 @@ 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 useProp.",
+  ["FICT-P004" /* FICT_P004 */]: "Nested props destructuring falls back to non-reactive binding; access props directly or use prop.",
+  ["FICT-P005" /* FICT_P005 */]: "Dynamic props spread may not stay reactive; consider explicit props or mergeProps(() => source).",
   ["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.",
@@ -16093,6 +16108,7 @@ var DiagnosticSeverities = {
   ["FICT-P002" /* FICT_P002 */]: "warning" /* Warning */,
   ["FICT-P003" /* FICT_P003 */]: "warning" /* Warning */,
   ["FICT-P004" /* FICT_P004 */]: "warning" /* Warning */,
+  ["FICT-P005" /* FICT_P005 */]: "warning" /* Warning */,
   ["FICT-S001" /* FICT_S001 */]: "error" /* Error */,
   ["FICT-S002" /* FICT_S002 */]: "warning" /* Warning */,
   ["FICT-E001" /* FICT_E001 */]: "warning" /* Warning */,
@@ -16145,6 +16161,215 @@ function reportDiagnostic(ctx, code, node, context) {
   }
 }
 
+// src/ir/props-plan.ts
+function buildPropsPlan(attributes, children, ctx, helpers) {
+  const { t: t2 } = ctx;
+  const prevPropsContext = ctx.inPropsContext;
+  ctx.inPropsContext = true;
+  try {
+    if (attributes.length === 0 && children.length === 0) return null;
+    const segments = [];
+    const flags = {
+      needsMergeProps: false,
+      hasLazySource: false
+    };
+    let bucket = [];
+    const toPropKey = (name) => /^[a-zA-Z_$][\w$]*$/.test(name) ? t2.identifier(name) : t2.stringLiteral(name);
+    const isAccessorName = (name) => (ctx.memoVars?.has(name) ?? false) || (ctx.signalVars?.has(name) ?? false) || (ctx.aliasVars?.has(name) ?? false);
+    const isZeroArgFunction = (expr) => (t2.isArrowFunctionExpression(expr) || t2.isFunctionExpression(expr)) && expr.params.length === 0;
+    const wrapAccessorSource = (node) => {
+      if (t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.arguments.length === 0) {
+        const baseName2 = helpers.deSSAVarName(node.callee.name);
+        if (isAccessorName(baseName2)) {
+          return t2.arrowFunctionExpression([], node);
+        }
+      }
+      if (t2.isIdentifier(node)) {
+        const baseName2 = helpers.deSSAVarName(node.name);
+        if (isAccessorName(baseName2)) {
+          return t2.arrowFunctionExpression([], t2.callExpression(t2.identifier(baseName2), []));
+        }
+      }
+      return node;
+    };
+    const isAccessorSource = (expr) => {
+      if (expr.kind === "Identifier") {
+        return isAccessorName(helpers.deSSAVarName(expr.name));
+      }
+      if (expr.kind === "CallExpression" || expr.kind === "OptionalCallExpression") {
+        if (expr.callee.kind === "Identifier" && expr.arguments.length === 0) {
+          return isAccessorName(helpers.deSSAVarName(expr.callee.name));
+        }
+      }
+      return false;
+    };
+    const isRuntimeMergeProps = () => !ctx.shadowedNames?.has(RUNTIME_ALIASES.mergeProps) && !ctx.localDeclaredNames?.has(RUNTIME_ALIASES.mergeProps) && (!ctx.moduleDeclaredNames?.has(RUNTIME_ALIASES.mergeProps) || (ctx.moduleRuntimeNames?.has(RUNTIME_ALIASES.mergeProps) ?? false));
+    const isMergePropsCall = (expr) => expr.kind === "CallExpression" && expr.callee.kind === "Identifier" && expr.callee.name === RUNTIME_ALIASES.mergeProps && isRuntimeMergeProps();
+    const isDynamicMemberSpread = (expr) => {
+      if (expr.kind !== "MemberExpression" && expr.kind !== "OptionalMemberExpression") return false;
+      if (expr.computed) return true;
+      if (expr.kind === "OptionalMemberExpression" && expr.optional) return true;
+      let current = expr;
+      while (current.kind === "MemberExpression" || current.kind === "OptionalMemberExpression") {
+        const obj = current.object;
+        if (obj.kind === "CallExpression" || obj.kind === "OptionalCallExpression" || obj.kind === "ConditionalExpression" || obj.kind === "LogicalExpression" || obj.kind === "SequenceExpression" || obj.kind === "AssignmentExpression" || obj.kind === "UpdateExpression" || obj.kind === "AwaitExpression" || obj.kind === "NewExpression" || obj.kind === "YieldExpression") {
+          return true;
+        }
+        if (obj.kind === "OptionalMemberExpression" && obj.optional) {
+          return true;
+        }
+        if (obj.kind !== "MemberExpression" && obj.kind !== "OptionalMemberExpression") {
+          return obj.kind !== "Identifier";
+        }
+        current = obj;
+      }
+      return false;
+    };
+    const isDynamicPropsSpread = (expr) => {
+      if (isAccessorSource(expr) || isMergePropsCall(expr)) return false;
+      if (expr.kind === "CallExpression" || expr.kind === "OptionalCallExpression" || expr.kind === "ConditionalExpression" || expr.kind === "LogicalExpression" || expr.kind === "SequenceExpression" || expr.kind === "AssignmentExpression" || expr.kind === "UpdateExpression" || expr.kind === "AwaitExpression" || expr.kind === "NewExpression" || expr.kind === "YieldExpression") {
+        return true;
+      }
+      if (expr.kind === "MemberExpression" || expr.kind === "OptionalMemberExpression") {
+        return isDynamicMemberSpread(expr);
+      }
+      if (expr.kind === "ObjectExpression") {
+        return expr.properties.some((p) => p.kind === "SpreadElement");
+      }
+      return false;
+    };
+    const flushBucket = () => {
+      if (bucket.length === 0) return;
+      segments.push({ kind: "object", properties: bucket });
+      bucket = [];
+    };
+    const pushSpread = (expr) => {
+      flags.needsMergeProps = true;
+      if (isZeroArgFunction(expr)) {
+        flags.hasLazySource = true;
+      }
+      segments.push({ kind: "spread", expr });
+    };
+    for (const attr of attributes) {
+      if (attr.isSpread && attr.spreadExpr) {
+        flushBucket();
+        if (isDynamicPropsSpread(attr.spreadExpr)) {
+          reportDiagnostic(ctx, "FICT-P005" /* FICT_P005 */, attr.spreadExpr);
+        }
+        let spreadExpr = helpers.lowerDomExpression(attr.spreadExpr, ctx);
+        if (t2.isCallExpression(spreadExpr) && t2.isIdentifier(spreadExpr.callee) && spreadExpr.callee.name === RUNTIME_ALIASES.mergeProps && isRuntimeMergeProps()) {
+          const callExpr = spreadExpr;
+          const rewrittenArgs = callExpr.arguments.map(
+            (arg) => t2.isExpression(arg) ? wrapAccessorSource(arg) : arg
+          );
+          if (rewrittenArgs.some((arg, idx) => arg !== callExpr.arguments[idx])) {
+            spreadExpr = t2.callExpression(
+              callExpr.callee,
+              rewrittenArgs
+            );
+          }
+          const flattenArgs = [];
+          let canFlatten = true;
+          for (const arg of rewrittenArgs) {
+            if (t2.isExpression(arg)) {
+              flattenArgs.push(arg);
+            } else {
+              canFlatten = false;
+              break;
+            }
+          }
+          if (canFlatten) {
+            for (const arg of flattenArgs) {
+              pushSpread(arg);
+            }
+            continue;
+          }
+        }
+        spreadExpr = wrapAccessorSource(spreadExpr);
+        pushSpread(spreadExpr);
+        continue;
+      }
+      if (attr.value) {
+        const isFunctionLike = attr.value.kind === "ArrowFunction" || attr.value.kind === "FunctionExpression";
+        const prevPropsCtx = ctx.inPropsContext;
+        if (isFunctionLike) {
+          ctx.inPropsContext = false;
+        }
+        const lowered = helpers.lowerDomExpression(attr.value, ctx);
+        if (isFunctionLike) {
+          ctx.inPropsContext = prevPropsCtx;
+        }
+        const baseIdent = attr.value.kind === "Identifier" ? helpers.deSSAVarName(attr.value.name) : void 0;
+        const isAccessorBase = baseIdent && ((ctx.memoVars?.has(baseIdent) ?? false) || (ctx.signalVars?.has(baseIdent) ?? false) || (ctx.aliasVars?.has(baseIdent) ?? false));
+        const isStoreBase = baseIdent ? ctx.storeVars?.has(baseIdent) ?? false : false;
+        const alreadyGetter = isFunctionLike || (baseIdent ? isStoreBase || (ctx.memoVars?.has(baseIdent) ?? false) || (ctx.aliasVars?.has(baseIdent) ?? false) : false);
+        const usesTracked = (!ctx.nonReactiveScopeDepth || ctx.nonReactiveScopeDepth === 0) && helpers.expressionUsesTracked(attr.value, ctx) && !alreadyGetter;
+        const trackedExpr = usesTracked ? helpers.lowerTrackedExpression(
+          attr.value,
+          ctx
+        ) : null;
+        const useMemoProp = usesTracked && trackedExpr && t2.isExpression(trackedExpr) && !t2.isIdentifier(trackedExpr) && !t2.isMemberExpression(trackedExpr) && !t2.isLiteral(trackedExpr);
+        const valueExpr = !isFunctionLike && isAccessorBase && baseIdent ? (() => {
+          ctx.helpersUsed.add("propGetter");
+          return t2.callExpression(t2.identifier(RUNTIME_ALIASES.propGetter), [
+            t2.arrowFunctionExpression([], t2.callExpression(t2.identifier(baseIdent), []))
+          ]);
+        })() : usesTracked && t2.isExpression(lowered) ? (() => {
+          if (useMemoProp) {
+            ctx.helpersUsed.add("prop");
+            return t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
+              t2.arrowFunctionExpression([], trackedExpr ?? lowered)
+            ]);
+          }
+          ctx.helpersUsed.add("propGetter");
+          return t2.callExpression(t2.identifier(RUNTIME_ALIASES.propGetter), [
+            t2.arrowFunctionExpression([], trackedExpr ?? lowered)
+          ]);
+        })() : lowered;
+        bucket.push(t2.objectProperty(toPropKey(attr.name), valueExpr));
+        continue;
+      }
+      bucket.push(t2.objectProperty(toPropKey(attr.name), t2.booleanLiteral(true)));
+    }
+    if (children.length === 1 && children[0]) {
+      bucket.push(t2.objectProperty(t2.identifier("children"), children[0]));
+    } else if (children.length > 1) {
+      bucket.push(t2.objectProperty(t2.identifier("children"), t2.arrayExpression(children)));
+    }
+    flushBucket();
+    if (segments.length === 0) return null;
+    return { segments, flags };
+  } finally {
+    ctx.inPropsContext = prevPropsContext;
+  }
+}
+function lowerPropsPlan(plan, ctx) {
+  const { t: t2 } = ctx;
+  const args = [];
+  for (const segment of plan.segments) {
+    if (segment.kind === "object") {
+      if (segment.properties.length === 0) continue;
+      args.push(t2.objectExpression(segment.properties));
+      continue;
+    }
+    args.push(segment.expr);
+  }
+  if (args.length === 0) return null;
+  if (!plan.flags.needsMergeProps) {
+    return args[0] ?? null;
+  }
+  if (args.length === 1 && !plan.flags.hasLazySource) {
+    return args[0];
+  }
+  ctx.helpersUsed.add("mergeProps");
+  return t2.callExpression(t2.identifier(RUNTIME_ALIASES.mergeProps), args);
+}
+function buildPropsExpression(attributes, children, ctx, helpers) {
+  const plan = buildPropsPlan(attributes, children, ctx, helpers);
+  if (!plan) return null;
+  return lowerPropsPlan(plan, ctx);
+}
+
 // src/ir/ssa.ts
 function analyzeCFG(blocks) {
   const predecessors = computePredecessors(blocks);
@@ -16642,6 +16867,9 @@ function collectExprReads(expr, into, paths, bound = /* @__PURE__ */ new Set(),
       expr.arguments?.forEach((a) => collectExprReads(a, into, paths, bound));
       return;
     }
+    case "SpreadElement":
+      collectExprReads(expr.argument, into, paths, bound);
+      return;
     case "MemberExpression":
     case "OptionalMemberExpression": {
       const depPath = extractDependencyPath(expr);
@@ -18136,11 +18364,15 @@ function containsJSXExpr(expr) {
     case "ArrayExpression":
       return expr.elements?.some((el) => containsJSXExpr(el)) ?? false;
     case "ObjectExpression":
-      return expr.properties?.some((p) => containsJSXExpr(p.value)) ?? false;
+      return expr.properties?.some(
+        (p) => p.kind === "SpreadElement" ? containsJSXExpr(p.argument) : containsJSXExpr(p.value)
+      ) ?? false;
     case "ConditionalExpression":
       return containsJSXExpr(expr.consequent) || containsJSXExpr(expr.alternate);
     case "ArrowFunction":
       return containsJSXExpr(expr.body);
+    case "SpreadElement":
+      return containsJSXExpr(expr.argument);
     default:
       return false;
   }
@@ -18170,6 +18402,8 @@ function expressionUsesTracked(expr, ctx) {
       });
     case "TemplateLiteral":
       return expr.expressions.some((e) => expressionUsesTracked(e, ctx));
+    case "SpreadElement":
+      return expressionUsesTracked(expr.argument, ctx);
     default:
       return false;
   }
@@ -19458,8 +19692,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) => {
@@ -20216,6 +20450,9 @@ function collectCalledIdentifiers(fn) {
 function createCodegenContext(t2) {
   return {
     t: t2,
+    moduleDeclaredNames: /* @__PURE__ */ new Set(),
+    moduleRuntimeNames: /* @__PURE__ */ new Set(),
+    localDeclaredNames: /* @__PURE__ */ new Set(),
     helpersUsed: /* @__PURE__ */ new Set(),
     tempCounter: 0,
     trackedVars: /* @__PURE__ */ new Set(),
@@ -21093,7 +21330,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);
           }
@@ -21360,8 +21597,7 @@ function lowerTerminator(block, ctx) {
       return applyLoc([]);
   }
 }
-function attachHelperImports(ctx, body, t2) {
-  if (ctx.helpersUsed.size === 0) return body;
+function collectDeclaredNames(body, t2) {
   const declared = /* @__PURE__ */ new Set();
   const addPatternNames = (pattern) => {
     if (t2.isIdentifier(pattern)) {
@@ -21435,6 +21671,78 @@ function attachHelperImports(ctx, body, t2) {
       declared.add(stmt.declaration.name);
     }
   }
+  return declared;
+}
+function collectRuntimeImportNames(body, t2) {
+  const runtimeModules = /* @__PURE__ */ new Set([RUNTIME_MODULE, "@fictjs/runtime", "fict"]);
+  const imported = /* @__PURE__ */ new Set();
+  for (const stmt of body) {
+    if (!t2.isImportDeclaration(stmt)) continue;
+    if (!runtimeModules.has(stmt.source.value)) continue;
+    for (const spec of stmt.specifiers) {
+      imported.add(spec.local.name);
+    }
+  }
+  return imported;
+}
+function collectLocalDeclaredNames(params, blocks, t2) {
+  const declared = /* @__PURE__ */ new Set();
+  const addPatternNames = (pattern) => {
+    if (t2.isIdentifier(pattern)) {
+      declared.add(deSSAVarName(pattern.name));
+      return;
+    }
+    if (t2.isAssignmentPattern(pattern)) {
+      addPatternNames(pattern.left);
+      return;
+    }
+    if (t2.isRestElement(pattern)) {
+      addPatternNames(pattern.argument);
+      return;
+    }
+    if (t2.isObjectPattern(pattern)) {
+      for (const prop of pattern.properties) {
+        if (t2.isRestElement(prop)) {
+          addPatternNames(prop.argument);
+        } else if (t2.isObjectProperty(prop)) {
+          addPatternNames(prop.value);
+        }
+      }
+      return;
+    }
+    if (t2.isArrayPattern(pattern)) {
+      for (const el of pattern.elements) {
+        if (!el) continue;
+        if (t2.isPatternLike(el)) addPatternNames(el);
+      }
+    }
+  };
+  params.forEach((param) => declared.add(deSSAVarName(param.name)));
+  if (!blocks) return declared;
+  for (const block of blocks) {
+    for (const instr of block.instructions) {
+      if (instr.kind !== "Assign") continue;
+      const target = deSSAVarName(instr.target.name);
+      const isFunctionDecl = instr.value.kind === "FunctionExpression" && !!instr.value.name && deSSAVarName(instr.value.name) === target;
+      if (instr.declarationKind || isFunctionDecl) {
+        declared.add(target);
+      }
+    }
+    const term = block.terminator;
+    if (term.kind === "ForOf" || term.kind === "ForIn") {
+      declared.add(deSSAVarName(term.variable));
+      if (term.pattern) {
+        addPatternNames(term.pattern);
+      }
+    } else if (term.kind === "Try" && term.catchParam) {
+      declared.add(deSSAVarName(term.catchParam));
+    }
+  }
+  return declared;
+}
+function attachHelperImports(ctx, body, t2) {
+  if (ctx.helpersUsed.size === 0) return body;
+  const declared = collectDeclaredNames(body, t2);
   const specifiers = [];
   for (const name of ctx.helpersUsed) {
     const alias = RUNTIME_ALIASES[name];
@@ -21504,11 +21812,21 @@ function lowerExpression(expr, ctx, isAssigned = false) {
 function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
   const { t: t2 } = ctx;
   const mapParams = (params) => params.map((p) => t2.identifier(deSSAVarName(p.name)));
-  const withFunctionScope = (paramNames, fn) => {
+  const lowerArgsAsExpressions = (args) => args.map(
+    (arg) => arg.kind === "SpreadElement" ? lowerExpression(arg.argument, ctx) : lowerExpression(arg, ctx)
+  );
+  const lowerCallArguments = (args, mapArg) => args.map((arg, idx) => {
+    if (arg.kind === "SpreadElement") {
+      return t2.spreadElement(lowerExpression(arg.argument, ctx));
+    }
+    return mapArg ? mapArg(arg, idx) : lowerExpression(arg, ctx);
+  });
+  const withFunctionScope = (paramNames, fn, localDeclared) => {
     const prevTracked = ctx.trackedVars;
     const prevAlias = ctx.aliasVars;
     const prevExternal = ctx.externalTracked;
     const prevShadowed = ctx.shadowedNames;
+    const prevLocalDeclared = ctx.localDeclaredNames;
     const scoped = new Set(ctx.trackedVars);
     paramNames.forEach((n) => scoped.delete(deSSAVarName(n)));
     ctx.trackedVars = scoped;
@@ -21517,11 +21835,19 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     const shadowed = new Set(prevShadowed ?? []);
     paramNames.forEach((n) => shadowed.add(deSSAVarName(n)));
     ctx.shadowedNames = shadowed;
+    const localNames = new Set(prevLocalDeclared ?? []);
+    if (localDeclared) {
+      for (const name of localDeclared) {
+        localNames.add(deSSAVarName(name));
+      }
+    }
+    ctx.localDeclaredNames = localNames;
     const result = fn();
     ctx.trackedVars = prevTracked;
     ctx.aliasVars = prevAlias;
     ctx.externalTracked = prevExternal;
     ctx.shadowedNames = prevShadowed;
+    ctx.localDeclaredNames = prevLocalDeclared;
     return result;
   };
   const lowerBlocksToStatements = (blocks) => {
@@ -21583,7 +21909,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
         ctx.needsCtx = true;
         return t2.callExpression(t2.identifier(RUNTIME_ALIASES.useSignal), [
           t2.identifier("__fictCtx"),
-          ...expr.arguments.map((a) => lowerExpression(a, ctx))
+          ...lowerCallArguments(expr.arguments)
         ]);
       }
       if (expr.callee.kind === "Identifier" && expr.callee.name === "$effect") {
@@ -21591,14 +21917,15 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
         ctx.needsCtx = true;
         return t2.callExpression(t2.identifier(RUNTIME_ALIASES.useEffect), [
           t2.identifier("__fictCtx"),
-          ...expr.arguments.map(
+          ...lowerCallArguments(
+            expr.arguments,
             (arg) => arg.kind === "ArrowFunction" || arg.kind === "FunctionExpression" ? withNonReactiveScope(ctx, () => lowerExpression(arg, ctx)) : lowerExpression(arg, ctx)
           )
         ]);
       }
       if (expr.callee.kind === "Identifier" && expr.callee.name === "__forOf") {
         ctx.needsForOfHelper = true;
-        const [iterable, cb] = expr.arguments.map((a) => lowerExpression(a, ctx));
+        const [iterable, cb] = lowerArgsAsExpressions(expr.arguments);
         return t2.callExpression(t2.identifier("__fictForOf"), [
           iterable ?? t2.identifier("undefined"),
           cb ?? t2.arrowFunctionExpression([], t2.identifier("undefined"))
@@ -21606,7 +21933,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
       }
       if (expr.callee.kind === "Identifier" && expr.callee.name === "__forIn") {
         ctx.needsForInHelper = true;
-        const [obj, cb] = expr.arguments.map((a) => lowerExpression(a, ctx));
+        const [obj, cb] = lowerArgsAsExpressions(expr.arguments);
         return t2.callExpression(t2.identifier("__fictForIn"), [
           obj ?? t2.identifier("undefined"),
           cb ?? t2.arrowFunctionExpression([], t2.identifier("undefined"))
@@ -21614,12 +21941,12 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
       }
       if (expr.callee.kind === "Identifier" && expr.callee.name === "__fictPropsRest") {
         ctx.helpersUsed.add("propsRest");
-        const args = expr.arguments.map((a) => lowerExpression(a, ctx));
+        const args = lowerCallArguments(expr.arguments);
         return t2.callExpression(t2.identifier(RUNTIME_ALIASES.propsRest), args);
       }
       if (expr.callee.kind === "Identifier" && expr.callee.name === "mergeProps") {
         ctx.helpersUsed.add("mergeProps");
-        const args = expr.arguments.map((a) => lowerExpression(a, ctx));
+        const args = lowerCallArguments(expr.arguments);
         return t2.callExpression(t2.identifier(RUNTIME_ALIASES.mergeProps), args);
       }
       const isIIFE = (expr.callee.kind === "ArrowFunction" || expr.callee.kind === "FunctionExpression") && expr.arguments.length === 0 && expr.callee.params.length === 0;
@@ -21627,7 +21954,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
       const calleeIsMemoAccessor = !!calleeName && ctx.memoVars?.has(calleeName);
       const calleeIsSignalLike = !!calleeName && (ctx.signalVars?.has(calleeName) || ctx.storeVars?.has(calleeName));
       if (calleeIsMemoAccessor && !calleeIsSignalLike && expr.arguments.length > 0) {
-        const loweredArgs2 = expr.arguments.map((a) => lowerExpression(a, ctx));
+        const loweredArgs2 = lowerCallArguments(expr.arguments);
         return t2.callExpression(t2.callExpression(t2.identifier(calleeName), []), loweredArgs2);
       }
       const lowerCallee = () => isIIFE ? withNonReactiveScope(ctx, () => lowerExpression(expr.callee, ctx)) : lowerExpression(expr.callee, ctx);
@@ -21636,7 +21963,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
       ) || expr.callee.property.kind === "Literal" && ["map", "reduce", "forEach", "filter", "flatMap", "some", "every", "find"].includes(
         String(expr.callee.property.value)
       ));
-      const loweredArgs = expr.arguments.map((a, idx) => {
+      const loweredArgs = lowerCallArguments(expr.arguments, (a, idx) => {
         if (idx === 0 && isIteratingMethod && (a.kind === "ArrowFunction" || a.kind === "FunctionExpression")) {
           return withNoMemoAndDynamicHooks(ctx, () => lowerExpression(a, ctx));
         }
@@ -21716,8 +22043,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)
               ]);
             }
@@ -21742,67 +22069,81 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     case "ArrowFunction": {
       const paramIds = mapParams(expr.params);
       const shadowed = new Set(expr.params.map((p) => deSSAVarName(p.name)));
+      const localDeclared = collectLocalDeclaredNames(
+        expr.params,
+        Array.isArray(expr.body) ? expr.body : null,
+        t2
+      );
       return withNonReactiveScope(
         ctx,
-        () => withFunctionScope(shadowed, () => {
-          let fn;
-          if (expr.isExpression && !Array.isArray(expr.body)) {
-            const { result: bodyExpr, cacheDeclarations } = withGetterCache(
-              ctx,
-              () => lowerTrackedExpression(expr.body, ctx)
-            );
-            if (cacheDeclarations.length > 0) {
+        () => withFunctionScope(
+          shadowed,
+          () => {
+            let fn;
+            if (expr.isExpression && !Array.isArray(expr.body)) {
+              const { result: bodyExpr, cacheDeclarations } = withGetterCache(
+                ctx,
+                () => lowerTrackedExpression(expr.body, ctx)
+              );
+              if (cacheDeclarations.length > 0) {
+                fn = t2.arrowFunctionExpression(
+                  paramIds,
+                  t2.blockStatement([...cacheDeclarations, t2.returnStatement(bodyExpr)])
+                );
+              } else {
+                fn = t2.arrowFunctionExpression(paramIds, bodyExpr);
+              }
+            } else if (Array.isArray(expr.body)) {
+              const { result: stmts, cacheDeclarations } = withGetterCache(
+                ctx,
+                () => lowerStructuredBlocks(expr.body, expr.params, paramIds)
+              );
               fn = t2.arrowFunctionExpression(
                 paramIds,
-                t2.blockStatement([...cacheDeclarations, t2.returnStatement(bodyExpr)])
+                t2.blockStatement([...cacheDeclarations, ...stmts])
               );
             } else {
-              fn = t2.arrowFunctionExpression(paramIds, bodyExpr);
+              fn = t2.arrowFunctionExpression(paramIds, t2.blockStatement([]));
             }
-          } else if (Array.isArray(expr.body)) {
-            const { result: stmts, cacheDeclarations } = withGetterCache(
-              ctx,
-              () => lowerStructuredBlocks(expr.body, expr.params, paramIds)
-            );
-            fn = t2.arrowFunctionExpression(
-              paramIds,
-              t2.blockStatement([...cacheDeclarations, ...stmts])
-            );
-          } else {
-            fn = t2.arrowFunctionExpression(paramIds, t2.blockStatement([]));
-          }
-          fn.async = expr.isAsync ?? false;
-          return fn;
-        })
+            fn.async = expr.isAsync ?? false;
+            return fn;
+          },
+          localDeclared
+        )
       );
     }
     case "FunctionExpression": {
       const paramIds = mapParams(expr.params);
       const shadowed = new Set(expr.params.map((p) => deSSAVarName(p.name)));
+      const localDeclared = collectLocalDeclaredNames(expr.params, expr.body, t2);
       return withNonReactiveScope(
         ctx,
-        () => withFunctionScope(shadowed, () => {
-          let fn;
-          if (Array.isArray(expr.body)) {
-            const { result: stmts, cacheDeclarations } = withGetterCache(
-              ctx,
-              () => lowerStructuredBlocks(expr.body, expr.params, paramIds)
-            );
-            fn = t2.functionExpression(
-              expr.name ? t2.identifier(deSSAVarName(expr.name)) : null,
-              paramIds,
-              t2.blockStatement([...cacheDeclarations, ...stmts])
-            );
-          } else {
-            fn = t2.functionExpression(
-              expr.name ? t2.identifier(deSSAVarName(expr.name)) : null,
-              paramIds,
-              t2.blockStatement([])
-            );
-          }
-          fn.async = expr.isAsync ?? false;
-          return fn;
-        })
+        () => withFunctionScope(
+          shadowed,
+          () => {
+            let fn;
+            if (Array.isArray(expr.body)) {
+              const { result: stmts, cacheDeclarations } = withGetterCache(
+                ctx,
+                () => lowerStructuredBlocks(expr.body, expr.params, paramIds)
+              );
+              fn = t2.functionExpression(
+                expr.name ? t2.identifier(deSSAVarName(expr.name)) : null,
+                paramIds,
+                t2.blockStatement([...cacheDeclarations, ...stmts])
+              );
+            } else {
+              fn = t2.functionExpression(
+                expr.name ? t2.identifier(deSSAVarName(expr.name)) : null,
+                paramIds,
+                t2.blockStatement([])
+              );
+            }
+            fn.async = expr.isAsync ?? false;
+            return fn;
+          },
+          localDeclared
+        )
       );
     }
     case "AssignmentExpression":
@@ -21936,10 +22277,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     case "AwaitExpression":
       return t2.awaitExpression(lowerExpression(expr.argument, ctx));
     case "NewExpression":
-      return t2.newExpression(
-        lowerExpression(expr.callee, ctx),
-        expr.arguments.map((a) => lowerExpression(a, ctx))
-      );
+      return t2.newExpression(lowerExpression(expr.callee, ctx), lowerCallArguments(expr.arguments));
     case "SequenceExpression":
       return t2.sequenceExpression(expr.expressions.map((e) => lowerExpression(e, ctx)));
     case "YieldExpression":
@@ -21950,7 +22288,7 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
     case "OptionalCallExpression":
       return t2.optionalCallExpression(
         lowerExpression(expr.callee, ctx),
-        expr.arguments.map((a) => lowerExpression(a, ctx)),
+        lowerCallArguments(expr.arguments),
         expr.optional
       );
     case "TaggedTemplateExpression":
@@ -22082,26 +22420,17 @@ function lowerJSXElement(jsx, ctx) {
       ]);
     }
     ctx.helpersUsed.add("createElement");
-    const propsObj = buildPropsObject(jsx.attributes, ctx);
     const children = jsx.children.map((c) => lowerJSXChild(c, ctx));
+    const propsExpr = buildPropsExpression(jsx.attributes, children, ctx, {
+      lowerDomExpression,
+      lowerTrackedExpression,
+      expressionUsesTracked,
+      deSSAVarName
+    });
     const componentRef = typeof jsx.tagName === "string" ? t2.identifier(jsx.tagName) : lowerExpression(jsx.tagName, ctx);
-    const propsWithChildren = [];
-    if (propsObj && t2.isObjectExpression(propsObj)) {
-      propsWithChildren.push(...propsObj.properties);
-    }
-    if (children.length === 1 && children[0]) {
-      propsWithChildren.push(t2.objectProperty(t2.identifier("children"), children[0]));
-    } else if (children.length > 1) {
-      propsWithChildren.push(
-        t2.objectProperty(t2.identifier("children"), t2.arrayExpression(children))
-      );
-    }
     return t2.objectExpression([
       t2.objectProperty(t2.identifier("type"), componentRef),
-      t2.objectProperty(
-        t2.identifier("props"),
-        propsWithChildren.length > 0 ? t2.objectExpression(propsWithChildren) : t2.nullLiteral()
-      )
+      t2.objectProperty(t2.identifier("props"), propsExpr ?? t2.nullLiteral())
     ]);
   }
   const useFineGrainedDom = !ctx.noMemo;
@@ -23854,98 +24183,6 @@ function lowerJSXChild(child, ctx) {
     return applyRegionMetadataToExpression(lowerExpression(child.value, ctx), ctx);
   }
 }
-function buildPropsObject(attributes, ctx) {
-  const { t: t2 } = ctx;
-  const prevPropsContext = ctx.inPropsContext;
-  ctx.inPropsContext = true;
-  try {
-    if (attributes.length === 0) return null;
-    const properties = [];
-    const spreads = [];
-    const toPropKey = (name) => /^[a-zA-Z_$][\w$]*$/.test(name) ? t2.identifier(name) : t2.stringLiteral(name);
-    const isAccessorName = (name) => (ctx.memoVars?.has(name) ?? false) || (ctx.signalVars?.has(name) ?? false) || (ctx.aliasVars?.has(name) ?? false);
-    const wrapAccessorSource = (node) => {
-      if (t2.isCallExpression(node) && t2.isIdentifier(node.callee) && node.arguments.length === 0) {
-        const baseName2 = deSSAVarName(node.callee.name);
-        if (isAccessorName(baseName2)) {
-          return t2.arrowFunctionExpression([], node);
-        }
-      }
-      if (t2.isIdentifier(node)) {
-        const baseName2 = deSSAVarName(node.name);
-        if (isAccessorName(baseName2)) {
-          return t2.arrowFunctionExpression([], t2.callExpression(t2.identifier(baseName2), []));
-        }
-      }
-      return node;
-    };
-    for (const attr of attributes) {
-      if (attr.isSpread && attr.spreadExpr) {
-        let spreadExpr = lowerDomExpression(attr.spreadExpr, ctx);
-        if (t2.isCallExpression(spreadExpr)) {
-          const callExpr = spreadExpr;
-          const rewrittenArgs = callExpr.arguments.map(
-            (arg) => t2.isExpression(arg) ? wrapAccessorSource(arg) : arg
-          );
-          if (rewrittenArgs.some((arg, idx) => arg !== callExpr.arguments[idx])) {
-            spreadExpr = t2.callExpression(callExpr.callee, rewrittenArgs);
-          }
-        }
-        spreadExpr = wrapAccessorSource(spreadExpr);
-        spreads.push(t2.spreadElement(spreadExpr));
-      } else if (attr.value) {
-        const isFunctionLike = attr.value.kind === "ArrowFunction" || attr.value.kind === "FunctionExpression";
-        const prevPropsCtx = ctx.inPropsContext;
-        if (isFunctionLike) {
-          ctx.inPropsContext = false;
-        }
-        const lowered = lowerDomExpression(attr.value, ctx);
-        if (isFunctionLike) {
-          ctx.inPropsContext = prevPropsCtx;
-        }
-        const baseIdent = attr.value.kind === "Identifier" ? deSSAVarName(attr.value.name) : void 0;
-        const isAccessorBase = baseIdent && ((ctx.memoVars?.has(baseIdent) ?? false) || (ctx.signalVars?.has(baseIdent) ?? false) || (ctx.aliasVars?.has(baseIdent) ?? false));
-        const isStoreBase = baseIdent ? ctx.storeVars?.has(baseIdent) ?? false : false;
-        const alreadyGetter = isFunctionLike || (baseIdent ? isStoreBase || (ctx.memoVars?.has(baseIdent) ?? false) || (ctx.aliasVars?.has(baseIdent) ?? false) : false);
-        const usesTracked = (!ctx.nonReactiveScopeDepth || ctx.nonReactiveScopeDepth === 0) && expressionUsesTracked(attr.value, ctx) && !alreadyGetter;
-        const trackedExpr = usesTracked ? lowerTrackedExpression(attr.value, ctx) : null;
-        const useMemoProp = usesTracked && trackedExpr && t2.isExpression(trackedExpr) && !t2.isIdentifier(trackedExpr) && !t2.isMemberExpression(trackedExpr) && !t2.isLiteral(trackedExpr);
-        const valueExpr = !isFunctionLike && isAccessorBase && baseIdent ? (() => {
-          ctx.helpersUsed.add("propGetter");
-          return t2.callExpression(t2.identifier(RUNTIME_ALIASES.propGetter), [
-            t2.arrowFunctionExpression([], t2.callExpression(t2.identifier(baseIdent), []))
-          ]);
-        })() : usesTracked && t2.isExpression(lowered) ? (() => {
-          if (useMemoProp) {
-            ctx.helpersUsed.add("useProp");
-            return t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
-              t2.arrowFunctionExpression(
-                [],
-                trackedExpr ?? lowered
-              )
-            ]);
-          }
-          ctx.helpersUsed.add("propGetter");
-          return t2.callExpression(t2.identifier(RUNTIME_ALIASES.propGetter), [
-            t2.arrowFunctionExpression(
-              [],
-              trackedExpr ?? lowered
-            )
-          ]);
-        })() : lowered;
-        properties.push(t2.objectProperty(toPropKey(attr.name), valueExpr));
-      } else {
-        properties.push(t2.objectProperty(toPropKey(attr.name), t2.booleanLiteral(true)));
-      }
-    }
-    if (spreads.length > 0) {
-      return t2.objectExpression([...spreads, ...properties]);
-    }
-    return t2.objectExpression(properties);
-  } finally {
-    ctx.inPropsContext = prevPropsContext;
-  }
-}
 function isDOMProperty(name) {
   return ["value", "checked", "selected", "disabled", "readOnly", "multiple", "muted"].includes(
     name
@@ -23962,6 +24199,8 @@ function lowerHIRWithRegions(program, t2, options) {
   let topLevelCtxInjected = false;
   const emittedFunctionNames = /* @__PURE__ */ new Set();
   const originalBody = program.originalBody ?? [];
+  ctx.moduleDeclaredNames = collectDeclaredNames(originalBody, t2);
+  ctx.moduleRuntimeNames = collectRuntimeImportNames(originalBody, t2);
   for (const stmt of originalBody) {
     if (t2.isVariableDeclaration(stmt)) {
       for (const decl of stmt.declarations) {
@@ -24359,6 +24598,12 @@ function lowerFunctionWithRegions(fn, ctx) {
   const functionShadowed = new Set(prevShadowed ?? []);
   shadowedParams.forEach((n) => functionShadowed.add(n));
   ctx.shadowedNames = functionShadowed;
+  const prevLocalDeclared = ctx.localDeclaredNames;
+  const localDeclared = new Set(prevLocalDeclared ?? []);
+  for (const name of collectLocalDeclaredNames(fn.params, fn.blocks, t2)) {
+    localDeclared.add(name);
+  }
+  ctx.localDeclaredNames = localDeclared;
   const prevExternalTracked = ctx.externalTracked;
   const inheritedTracked = new Set(ctx.trackedVars);
   ctx.externalTracked = inheritedTracked;
@@ -24440,16 +24685,75 @@ function lowerFunctionWithRegions(fn, ctx) {
       const stmts = [];
       const excludeKeys = [];
       let supported = true;
-      let usesUseProp = false;
+      let usesProp = false;
       let usesPropsRest = false;
       let warnedNested = false;
+      const reportedPatternNodes = /* @__PURE__ */ new Set();
+      const reportPatternDiagnostic = (node, code) => {
+        if (reportedPatternNodes.has(node)) return;
+        reportedPatternNodes.add(node);
+        reportDiagnostic(ctx, code, node);
+      };
+      const reportPropsPatternIssues = (objectPattern, allowRest) => {
+        for (const prop of objectPattern.properties) {
+          if (t2.isObjectProperty(prop)) {
+            if (prop.computed) {
+              reportPatternDiagnostic(prop, "FICT-P003" /* FICT_P003 */);
+              continue;
+            }
+            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) {
+              reportPatternDiagnostic(prop, "FICT-P003" /* FICT_P003 */);
+              continue;
+            }
+            const value = prop.value;
+            if (t2.isIdentifier(value)) {
+              continue;
+            }
+            if (t2.isObjectPattern(value)) {
+              reportPropsPatternIssues(value, false);
+              continue;
+            }
+            if (t2.isAssignmentPattern(value)) {
+              if (t2.isIdentifier(value.left)) {
+                continue;
+              }
+              reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
+              continue;
+            }
+            if (t2.isArrayPattern(value)) {
+              const hasRest = value.elements.some((el) => t2.isRestElement(el));
+              reportPatternDiagnostic(
+                value,
+                hasRest ? "FICT-P002" /* FICT_P002 */ : "FICT-P001" /* FICT_P001 */
+              );
+              continue;
+            }
+            reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
+            continue;
+          }
+          if (t2.isRestElement(prop)) {
+            if (!allowRest || !t2.isIdentifier(prop.argument)) {
+              reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
+            }
+            continue;
+          }
+          reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
+        }
+      };
       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) {
+          if (t2.isObjectProperty(prop)) {
+            if (prop.computed) {
+              reportPatternDiagnostic(prop, "FICT-P003" /* FICT_P003 */);
+              supported = false;
+              warnedNested = true;
+              break;
+            }
             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);
+              reportPatternDiagnostic(prop, "FICT-P003" /* FICT_P003 */);
               supported = false;
               warnedNested = true;
               break;
@@ -24460,16 +24764,16 @@ function lowerFunctionWithRegions(fn, ctx) {
             const member = memberExprForKey(baseExpr, keyName);
             const value = prop.value;
             if (t2.isIdentifier(value)) {
-              const shouldUseProp = !calledIdentifiers.has(value.name);
-              if (shouldUseProp) {
-                usesUseProp = true;
+              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),
-                    shouldUseProp ? t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
+                    shouldWrapProp ? t2.callExpression(t2.identifier(RUNTIME_ALIASES.prop), [
                       t2.arrowFunctionExpression([], member)
                     ]) : member
                   )
@@ -24482,26 +24786,44 @@ function lowerFunctionWithRegions(fn, ctx) {
               if (!supported) break;
               continue;
             }
-            if (t2.isAssignmentPattern(value) && t2.isIdentifier(value.left)) {
-              const shouldUseProp = !calledIdentifiers.has(value.left.name);
-              if (shouldUseProp) {
-                usesUseProp = true;
-                propsPlanAliases.add(value.left.name);
+            if (t2.isAssignmentPattern(value)) {
+              if (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;
               }
-              const baseInit = t2.logicalExpression("??", member, value.right);
-              const init = shouldUseProp ? t2.callExpression(t2.identifier(RUNTIME_ALIASES.useProp), [
-                t2.arrowFunctionExpression([], baseInit)
-              ]) : baseInit;
-              stmts.push(
-                t2.variableDeclaration("const", [
-                  t2.variableDeclarator(t2.identifier(value.left.name), init)
-                ])
+              supported = false;
+              if (!warnedNested) {
+                reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
+                warnedNested = true;
+              }
+              break;
+            }
+            if (t2.isArrayPattern(value)) {
+              const hasRest = value.elements.some((el) => t2.isRestElement(el));
+              reportPatternDiagnostic(
+                value,
+                hasRest ? "FICT-P002" /* FICT_P002 */ : "FICT-P001" /* FICT_P001 */
               );
-              continue;
+              supported = false;
+              warnedNested = true;
+              break;
             }
             supported = false;
             if (!warnedNested) {
-              reportDiagnostic(ctx, "FICT-P004" /* FICT_P004 */, prop);
+              reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
               warnedNested = true;
             }
             break;
@@ -24522,18 +24844,19 @@ function lowerFunctionWithRegions(fn, ctx) {
           } else {
             supported = false;
             if (!warnedNested) {
-              reportDiagnostic(ctx, "FICT-P004" /* FICT_P004 */, prop);
+              reportPatternDiagnostic(prop, "FICT-P004" /* FICT_P004 */);
               warnedNested = true;
             }
             break;
           }
         }
       };
+      reportPropsPatternIssues(pattern, true);
       buildDestructure(pattern, t2.identifier("__props"), true);
       if (supported) {
         propsDestructurePlan = {
           statements: stmts,
-          usesUseProp,
+          usesProp,
           usesPropsRest
         };
         propsPlanAliases.forEach((name) => {
@@ -24575,6 +24898,7 @@ function lowerFunctionWithRegions(fn, ctx) {
   if (!hasJSX && !hasTrackedValues) {
     ctx.needsCtx = prevNeedsCtx;
     ctx.shadowedNames = prevShadowed;
+    ctx.localDeclaredNames = prevLocalDeclared;
     ctx.trackedVars = prevTracked;
     ctx.externalTracked = prevExternalTracked;
     ctx.signalVars = prevSignalVars;
@@ -24627,8 +24951,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");
@@ -24657,6 +24981,7 @@ function lowerFunctionWithRegions(fn, ctx) {
   );
   ctx.needsCtx = prevNeedsCtx;
   ctx.shadowedNames = prevShadowed;
+  ctx.localDeclaredNames = prevLocalDeclared;
   ctx.trackedVars = prevTracked;
   ctx.externalTracked = prevExternalTracked;
   ctx.signalVars = prevSignalVars;
@@ -25116,8 +25441,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;
@@ -25373,6 +25700,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(
@@ -25565,7 +25904,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);
@@ -25585,7 +25926,8 @@ var createFictPlugin = 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",