@fictjs/compiler 0.2.2 → 0.2.3

package/dist/index.js

@@ -179,7 +179,7 @@ var require_generated = __commonJS({
     exports.isExpression = isExpression2;
     exports.isExpressionStatement = isExpressionStatement2;
     exports.isExpressionWrapper = isExpressionWrapper;
-    exports.isFile = isFile;
+    exports.isFile = isFile2;
     exports.isFlow = isFlow;
     exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
     exports.isFlowDeclaration = isFlowDeclaration;
@@ -489,7 +489,7 @@ var require_generated = __commonJS({
       if (node.type !== "ExpressionStatement") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
     }
-    function isFile(node, opts) {
+    function isFile2(node, opts) {
       if (!node) return false;
       if (node.type !== "File") return false;
       return opts == null || (0, _shallowEqual.default)(node, opts);
@@ -7322,7 +7322,7 @@ var require_lowercase = __commonJS({
     exports.restElement = restElement;
     exports.restProperty = RestProperty;
     exports.returnStatement = returnStatement2;
-    exports.sequenceExpression = sequenceExpression;
+    exports.sequenceExpression = sequenceExpression2;
     exports.spreadElement = spreadElement;
     exports.spreadProperty = SpreadProperty;
     exports.staticBlock = staticBlock;
@@ -7876,7 +7876,7 @@ var require_lowercase = __commonJS({
       validate(defs.argument, node, "argument", argument, 1);
       return node;
     }
-    function sequenceExpression(expressions) {
+    function sequenceExpression2(expressions) {
       const node = {
         type: "SequenceExpression",
         expressions
@@ -11970,7 +11970,7 @@ var require_cloneNode = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.default = cloneNode;
+    exports.default = cloneNode2;
     var _index = require_definitions();
     var _index2 = require_generated();
     var {
@@ -11990,7 +11990,7 @@ var require_cloneNode = __commonJS({
       }
       return cloneIfNode(obj, deep, withoutLoc, commentsCache);
     }
-    function cloneNode(node, deep = true, withoutLoc = false) {
+    function cloneNode2(node, deep = true, withoutLoc = false) {
       return cloneNodeInternal(node, deep, withoutLoc, /* @__PURE__ */ new Map());
     }
     function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
@@ -14308,6 +14308,7 @@ function debugWarn(flag, message, data) {
 var t = __toESM(require_lib3(), 1);
 import { transformFromAstSync } from "@babel/core";
 import transformDestructuring from "@babel/plugin-transform-destructuring";
+import traverseModule from "@babel/traverse";
 
 // src/ir/hir.ts
 var HIRError = class extends Error {
@@ -14393,9 +14394,9 @@ function extractDependencyPath(expr) {
   }
   return void 0;
 }
-function pathToString(path) {
-  let result = path.base;
-  for (const seg of path.segments) {
+function pathToString(path2) {
+  let result = path2.base;
+  for (const seg of path2.segments) {
     if (seg.optional) {
       result += "?.";
     } else {
@@ -14420,42 +14421,56 @@ var resolveDestructuringPlugin = () => {
   const mod = transformDestructuring;
   return mod?.default ?? mod;
 };
-var createAssignmentDestructuringPlugin = () => {
-  const pluginFactory = resolveDestructuringPlugin();
-  if (typeof pluginFactory !== "function") {
-    throw new Error("Expected @babel/plugin-transform-destructuring to export a function");
-  }
-  const plugin = pluginFactory(
-    {
-      assertVersion() {
-      },
-      assumption() {
-        return void 0;
-      },
-      types: t
-    },
-    {}
-  );
-  return {
-    visitor: {
-      AssignmentExpression(path, state) {
-        if (!t.isObjectPattern(path.node.left) && !t.isArrayPattern(path.node.left)) return;
-        const visitor = plugin.visitor?.AssignmentExpression;
-        if (!visitor) return;
-        visitor.call(this, path, state);
+var resolveTraverse = () => {
+  const mod = traverseModule;
+  return mod?.default ?? mod;
+};
+var OBJECT_REST_HELPERS = /* @__PURE__ */ new Set(["_objectWithoutProperties", "_objectWithoutPropertiesLoose"]);
+var OBJECT_DESTRUCTURING_EMPTY_HELPER = "_objectDestructuringEmpty";
+var EXTENDS_HELPER = "_extends";
+var isSameIdentifier = (left, right) => {
+  return t.isIdentifier(left) && t.isIdentifier(right) && left.name === right.name;
+};
+var rewriteObjectRestHelpers = (ast) => {
+  const traverse = resolveTraverse();
+  traverse(ast, {
+    CallExpression(path2) {
+      const { callee, arguments: args } = path2.node;
+      if (t.isIdentifier(callee) && OBJECT_REST_HELPERS.has(callee.name)) {
+        path2.node.callee = t.identifier("__fictPropsRest");
+        return;
+      }
+      if (t.isIdentifier(callee) && callee.name === EXTENDS_HELPER && args.length === 2 && t.isObjectExpression(args[0]) && args[0].properties.length === 0 && t.isSequenceExpression(args[1]) && args[1].expressions.length === 2) {
+        const [checkExpr, sourceExpr] = args[1].expressions;
+        if (t.isCallExpression(checkExpr) && t.isIdentifier(checkExpr.callee) && checkExpr.callee.name === OBJECT_DESTRUCTURING_EMPTY_HELPER && checkExpr.arguments.length === 1) {
+          const [checkArg] = checkExpr.arguments;
+          if (checkArg && isSameIdentifier(checkArg, sourceExpr)) {
+            const restCall = t.callExpression(t.identifier("__fictPropsRest"), [
+              t.cloneNode(sourceExpr, true),
+              t.arrayExpression([])
+            ]);
+            path2.replaceWith(t.sequenceExpression([checkExpr, restCall]));
+          }
+        }
       }
     }
-  };
+  });
 };
 var expandDestructuringAssignments = (ast) => {
+  const pluginFactory = resolveDestructuringPlugin();
+  if (typeof pluginFactory !== "function") {
+    throw new Error("Expected @babel/plugin-transform-destructuring to export a function");
+  }
   const result = transformFromAstSync(ast, void 0, {
     configFile: false,
     babelrc: false,
     ast: true,
     code: false,
-    plugins: [createAssignmentDestructuringPlugin()]
+    plugins: [pluginFactory]
   });
-  return result?.ast ?? ast;
+  const expanded = result?.ast ?? ast;
+  rewriteObjectRestHelpers(expanded);
+  return expanded;
 };
 var reportUnsupportedExpression = (node, overrideMessage) => {
   const loc = getLoc(node);
@@ -16365,6 +16380,70 @@ function shouldMemoizeRegion(region) {
   return false;
 }
 
+// src/module-metadata.ts
+import path from "path";
+import { existsSync, statSync } from "fs";
+var globalMetadata = /* @__PURE__ */ new Map();
+var MODULE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
+function normalizeFileName(fileName) {
+  return path.resolve(fileName);
+}
+function getMetadataStore(options) {
+  return options?.moduleMetadata ?? globalMetadata;
+}
+function isFile(pathName) {
+  try {
+    return statSync(pathName).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveImportSource(source, importer, store) {
+  if (!importer) return void 0;
+  const isAbsolute = path.isAbsolute(source);
+  if (!isAbsolute && !source.startsWith(".")) return void 0;
+  const base = isAbsolute ? source : path.resolve(path.dirname(importer), source);
+  const normalized = normalizeFileName(base);
+  if (store.has(normalized)) return normalized;
+  if (existsSync(normalized) && isFile(normalized)) return normalized;
+  const ext = path.extname(normalized);
+  if (!ext) {
+    for (const suffix of MODULE_EXTENSIONS) {
+      const candidate = `${normalized}${suffix}`;
+      if (store.has(candidate)) return candidate;
+      if (existsSync(candidate) && isFile(candidate)) return candidate;
+    }
+  }
+  for (const suffix of MODULE_EXTENSIONS) {
+    const candidate = path.join(normalized, `index${suffix}`);
+    if (store.has(candidate)) return candidate;
+    if (existsSync(candidate) && isFile(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolveModuleMetadata(source, importer, options) {
+  if (options?.resolveModuleMetadata) {
+    const resolved = options.resolveModuleMetadata(source, importer);
+    if (resolved) return resolved;
+  }
+  const store = getMetadataStore(options);
+  const resolvedKey = resolveImportSource(source, importer, store);
+  if (resolvedKey) {
+    return store.get(resolvedKey);
+  }
+  if (store.has(source)) return store.get(source);
+  return void 0;
+}
+function setModuleMetadata(fileName, metadata, options) {
+  if (!fileName) return;
+  const store = getMetadataStore(options);
+  store.set(normalizeFileName(fileName), metadata);
+}
+function clearModuleMetadata(options) {
+  const store = getMetadataStore(options);
+  store.clear();
+}
+
 // src/validation.ts
 var DiagnosticMessages = {
   ["FICT-P001" /* FICT_P001 */]: "Props destructuring falls back to non-reactive binding.",
@@ -16557,6 +16636,23 @@ function buildPropsPlan(attributes, children, ctx, helpers) {
       }
       return false;
     };
+    const getBaseIdentifier2 = (expr) => {
+      if (expr.kind === "Identifier") return expr.name;
+      if (expr.kind === "MemberExpression" || expr.kind === "OptionalMemberExpression") {
+        return getBaseIdentifier2(expr.object);
+      }
+      return null;
+    };
+    const isDynamicStoreMember = (expr) => {
+      if (expr.kind !== "MemberExpression" && expr.kind !== "OptionalMemberExpression") return false;
+      if (!expr.computed) return false;
+      if (expr.property.kind === "Literal" && (typeof expr.property.value === "string" || typeof expr.property.value === "number")) {
+        return false;
+      }
+      const base = getBaseIdentifier2(expr.object);
+      if (!base) return false;
+      return ctx.storeVars?.has(helpers.deSSAVarName(base)) ?? false;
+    };
     const flushBucket = () => {
       if (bucket.length === 0) return;
       segments.push({ kind: "object", properties: bucket });
@@ -16628,13 +16724,15 @@ function buildPropsPlan(attributes, children, ctx, helpers) {
           ctx
         ) : null;
         const useMemoProp = usesTracked && trackedExpr && t4.isExpression(trackedExpr) && !t4.isIdentifier(trackedExpr) && !t4.isMemberExpression(trackedExpr) && !t4.isLiteral(trackedExpr);
+        const forceMemoProp = usesTracked && isDynamicStoreMember(attr.value);
+        const shouldMemoProp = useMemoProp || forceMemoProp;
         const valueExpr = !isFunctionLike && isAccessorBase && baseIdent ? (() => {
           ctx.helpersUsed.add("propGetter");
           return t4.callExpression(t4.identifier(RUNTIME_ALIASES.propGetter), [
             t4.arrowFunctionExpression([], t4.callExpression(t4.identifier(baseIdent), []))
           ]);
         })() : usesTracked && t4.isExpression(lowered) ? (() => {
-          if (useMemoProp) {
+          if (shouldMemoProp) {
             ctx.helpersUsed.add("prop");
             return t4.callExpression(t4.identifier(RUNTIME_ALIASES.prop), [
               t4.arrowFunctionExpression([], trackedExpr ?? lowered)
@@ -16827,7 +16925,13 @@ function rewriteExprWithMap(expr, rewrites) {
       return {
         ...expr,
         object: rewriteExprWithMap(expr.object, rewrites),
-        property: rewriteExprWithMap(expr.property, rewrites)
+        property: expr.computed ? rewriteExprWithMap(expr.property, rewrites) : expr.property
+      };
+    case "OptionalMemberExpression":
+      return {
+        ...expr,
+        object: rewriteExprWithMap(expr.object, rewrites),
+        property: expr.computed ? rewriteExprWithMap(expr.property, rewrites) : expr.property
       };
     case "BinaryExpression":
     case "LogicalExpression":
@@ -16850,11 +16954,12 @@ function rewriteExprWithMap(expr, rewrites) {
     case "ObjectExpression":
       return {
         ...expr,
-        properties: expr.properties.map((p) => ({
-          ...p,
-          key: rewriteExprWithMap(p.key, rewrites),
-          value: rewriteExprWithMap(p.value, rewrites)
-        }))
+        properties: expr.properties.map((p) => {
+          if (p.kind === "SpreadElement") {
+            return { ...p, argument: rewriteExprWithMap(p.argument, rewrites) };
+          }
+          return { ...p, value: rewriteExprWithMap(p.value, rewrites) };
+        })
       };
     case "ImportExpression":
       return {
@@ -16968,7 +17073,17 @@ function toSSA(fn) {
           arguments: expr.arguments.map((a) => renameExpr(a))
         };
       case "MemberExpression":
-        return { ...expr, object: renameExpr(expr.object), property: renameExpr(expr.property) };
+        return {
+          ...expr,
+          object: renameExpr(expr.object),
+          property: expr.computed ? renameExpr(expr.property) : expr.property
+        };
+      case "OptionalMemberExpression":
+        return {
+          ...expr,
+          object: renameExpr(expr.object),
+          property: expr.computed ? renameExpr(expr.property) : expr.property
+        };
       case "BinaryExpression":
       case "LogicalExpression":
         return { ...expr, left: renameExpr(expr.left), right: renameExpr(expr.right) };
@@ -16986,11 +17101,12 @@ function toSSA(fn) {
       case "ObjectExpression":
         return {
           ...expr,
-          properties: expr.properties.map((p) => ({
-            ...p,
-            key: renameExpr(p.key),
-            value: renameExpr(p.value)
-          }))
+          properties: expr.properties.map((p) => {
+            if (p.kind === "SpreadElement") {
+              return { ...p, argument: renameExpr(p.argument) };
+            }
+            return { ...p, value: renameExpr(p.value) };
+          })
         };
       default:
         return expr;
@@ -17485,8 +17601,8 @@ function mergeOverlappingScopes(scopes, _byName) {
         scope.blocks.forEach((b) => merged.blocks.add(b));
         scope.dependencies.forEach((d) => merged.dependencies.add(d));
         for (const [base, paths] of scope.dependencyPaths) {
-          for (const path of paths) {
-            addPath(merged.dependencyPaths, base, path);
+          for (const path2 of paths) {
+            addPath(merged.dependencyPaths, base, path2);
           }
         }
         merged.hasExternalEffect = merged.hasExternalEffect || scope.hasExternalEffect;
@@ -17580,12 +17696,12 @@ function collectExprReads(expr, into, paths, bound = /* @__PURE__ */ new Set(),
       if (bound.has(baseName(expr.name))) return;
       into.add(expr.name);
       if (paths) {
-        const path = {
+        const path2 = {
           base: expr.name,
           segments: [],
           hasOptional: false
         };
-        addPath(paths, expr.name, path);
+        addPath(paths, expr.name, path2);
       }
       return;
     case "CallExpression": {
@@ -17741,11 +17857,11 @@ function collectExprReads(expr, into, paths, bound = /* @__PURE__ */ new Set(),
       return;
   }
 }
-function addPath(paths, base, path) {
+function addPath(paths, base, path2) {
   const existing = paths.get(base) ?? [];
-  const pathStr = pathToString(path);
+  const pathStr = pathToString(path2);
   if (!existing.some((p) => pathToString(p) === pathStr)) {
-    existing.push(path);
+    existing.push(path2);
     paths.set(base, existing);
   }
 }
@@ -17764,11 +17880,11 @@ function analyzeOptionalChainDependencies(scope) {
     } else {
       let hasRequiredPath = false;
       let hasOptionalOnlyPath = false;
-      for (const path of paths) {
-        if (!path.hasOptional) {
+      for (const path2 of paths) {
+        if (!path2.hasOptional) {
           hasRequiredPath = true;
         } else {
-          const firstOptionalIndex = path.segments.findIndex((s) => s.optional);
+          const firstOptionalIndex = path2.segments.findIndex((s) => s.optional);
           if (firstOptionalIndex === 0) {
             hasOptionalOnlyPath = true;
           } else if (firstOptionalIndex > 0) {
@@ -18519,12 +18635,23 @@ function createPropsShape() {
   };
 }
 function cloneKeyContext(ctx) {
-  return new Map(ctx);
+  const cloneMap = (map) => {
+    const next = /* @__PURE__ */ new Map();
+    for (const [key, value] of map.entries()) {
+      next.set(key, new Set(value));
+    }
+    return next;
+  };
+  return {
+    values: cloneMap(ctx.values),
+    keySets: cloneMap(ctx.keySets)
+  };
 }
 function clearPatternBindings(pattern, ctx) {
   if (!pattern || typeof pattern !== "object") return;
   if (t2.isIdentifier(pattern)) {
-    ctx.delete(pattern.name);
+    ctx.values.delete(pattern.name);
+    ctx.keySets.delete(pattern.name);
     return;
   }
   if (t2.isRestElement(pattern)) {
@@ -18551,19 +18678,106 @@ function clearPatternBindings(pattern, ctx) {
     }
   }
 }
-function resolveNarrowedKey(expr, ctx) {
+function resolveNarrowedKeys(expr, ctx) {
   if (expr.kind === "Literal") {
     if (typeof expr.value === "string" || typeof expr.value === "number") {
-      return expr.value;
+      return /* @__PURE__ */ new Set([expr.value]);
     }
     return null;
   }
   if (expr.kind === "Identifier") {
-    return ctx.get(expr.name) ?? null;
+    const value = ctx.values.get(expr.name);
+    return value ? new Set(value) : null;
+  }
+  if (expr.kind === "ConditionalExpression") {
+    const consequent = resolveNarrowedKeys(expr.consequent, ctx);
+    const alternate = resolveNarrowedKeys(expr.alternate, ctx);
+    if (consequent && alternate) {
+      return /* @__PURE__ */ new Set([...consequent, ...alternate]);
+    }
+    return null;
+  }
+  if (expr.kind === "SequenceExpression" && expr.expressions.length > 0) {
+    const last = expr.expressions[expr.expressions.length - 1];
+    return resolveNarrowedKeys(last, ctx);
+  }
+  if (expr.kind === "MemberExpression" || expr.kind === "OptionalMemberExpression") {
+    if (expr.computed && expr.object.kind === "Identifier") {
+      const keySet = ctx.keySets.get(expr.object.name);
+      if (keySet && keySet.size > 0) {
+        return new Set(keySet);
+      }
+    }
+  }
+  return null;
+}
+function resolveKeySet(expr, ctx) {
+  if (expr.kind === "Identifier") {
+    const set = ctx.keySets.get(expr.name);
+    return set ? new Set(set) : null;
+  }
+  if (expr.kind === "ArrayExpression") {
+    const values = [];
+    for (const el of expr.elements) {
+      if (!el) return null;
+      if (el.kind !== "Literal") return null;
+      if (typeof el.value !== "string" && typeof el.value !== "number") return null;
+      values.push(el.value);
+    }
+    return values.length > 0 ? new Set(values) : null;
+  }
+  if (expr.kind === "CallExpression") {
+    if (expr.callee.kind === "MemberExpression") {
+      const object = expr.callee.object;
+      const property = expr.callee.property;
+      if (object.kind === "Identifier" && object.name === "Object" && !expr.callee.computed && property.kind === "Identifier" && property.name === "keys" && expr.arguments.length === 1) {
+        const arg = expr.arguments[0];
+        if (arg.kind === "ObjectExpression") {
+          const values = [];
+          for (const prop of arg.properties) {
+            if (prop.kind !== "Property") return null;
+            if (prop.key.kind === "Identifier") {
+              values.push(prop.key.name);
+            } else if (prop.key.kind === "Literal") {
+              if (typeof prop.key.value !== "string" && typeof prop.key.value !== "number") {
+                return null;
+              }
+              values.push(prop.key.value);
+            } else {
+              return null;
+            }
+          }
+          return values.length > 0 ? new Set(values) : null;
+        }
+      }
+    }
+  }
+  if (expr.kind === "ConditionalExpression") {
+    const consequent = resolveKeySet(expr.consequent, ctx);
+    const alternate = resolveKeySet(expr.alternate, ctx);
+    if (consequent && alternate) {
+      return /* @__PURE__ */ new Set([...consequent, ...alternate]);
+    }
+    return null;
+  }
+  if (expr.kind === "SequenceExpression" && expr.expressions.length > 0) {
+    const last = expr.expressions[expr.expressions.length - 1];
+    return resolveKeySet(last, ctx);
   }
   return null;
 }
 function extractEqualityNarrowing(expr) {
+  if (expr.kind === "LogicalExpression" && expr.operator === "||") {
+    const left = extractEqualityNarrowing(expr.left);
+    const right = extractEqualityNarrowing(expr.right);
+    if (left && right && left.kind === "eq" && right.kind === "eq" && left.name === right.name) {
+      return {
+        name: left.name,
+        values: /* @__PURE__ */ new Set([...left.values, ...right.values]),
+        kind: "eq"
+      };
+    }
+  }
   if (expr.kind !== "BinaryExpression") return null;
   const isEq = expr.operator === "===";
   const isNeq = expr.operator === "!==";
@@ -18578,17 +18792,55 @@ function extractEqualityNarrowing(expr) {
   if (expr.left.kind === "Identifier") {
     const value = literalValue(expr.right);
     if (value !== null) {
-      return { name: expr.left.name, value, kind: isEq ? "eq" : "neq" };
+      return { name: expr.left.name, values: /* @__PURE__ */ new Set([value]), kind: isEq ? "eq" : "neq" };
     }
   }
   if (expr.right.kind === "Identifier") {
     const value = literalValue(expr.left);
     if (value !== null) {
-      return { name: expr.right.name, value, kind: isEq ? "eq" : "neq" };
+      return { name: expr.right.name, values: /* @__PURE__ */ new Set([value]), kind: isEq ? "eq" : "neq" };
     }
   }
   return null;
 }
+function applyNarrowing(ctx, name, values) {
+  const existing = ctx.values.get(name);
+  if (!existing) {
+    ctx.values.set(name, new Set(values));
+    return;
+  }
+  const intersection = /* @__PURE__ */ new Set();
+  for (const value of existing) {
+    if (values.has(value)) intersection.add(value);
+  }
+  if (intersection.size > 0) {
+    ctx.values.set(name, intersection);
+  } else {
+    ctx.values.delete(name);
+  }
+}
+function applyKeyAssignment(ctx, name, expr) {
+  ctx.values.delete(name);
+  ctx.keySets.delete(name);
+  let assignedKeys = null;
+  let keySet = null;
+  if (expr.kind === "Identifier") {
+    assignedKeys = resolveNarrowedKeys(expr, ctx);
+    keySet = resolveKeySet(expr, ctx);
+    if (ctx.keySets.has(expr.name)) {
+      ctx.keySets.delete(expr.name);
+    }
+  } else {
+    assignedKeys = resolveNarrowedKeys(expr, ctx);
+    keySet = resolveKeySet(expr, ctx);
+  }
+  if (assignedKeys && assignedKeys.size > 0) {
+    ctx.values.set(name, new Set(assignedKeys));
+  }
+  if (keySet && keySet.size > 0) {
+    ctx.keySets.set(name, new Set(keySet));
+  }
+}
 function mergeShapes(a, b) {
   return {
     knownKeys: /* @__PURE__ */ new Set([...a.knownKeys, ...b.knownKeys]),
@@ -18610,7 +18862,7 @@ function analyzeObjectShapes(fn) {
       shapes.set(param.name, createUnknownShape({ kind: "param", name: param.name }));
     }
   }
-  const baseCtx = /* @__PURE__ */ new Map();
+  const baseCtx = { values: /* @__PURE__ */ new Map(), keySets: /* @__PURE__ */ new Map() };
   let structured = null;
   try {
     structured = structurizeCFG(fn, {
@@ -18697,9 +18949,9 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
       const alternateCtx = cloneKeyContext(ctx);
       if (narrowing) {
         if (narrowing.kind === "eq") {
-          consequentCtx.set(narrowing.name, narrowing.value);
+          applyNarrowing(consequentCtx, narrowing.name, narrowing.values);
         } else {
-          alternateCtx.set(narrowing.name, narrowing.value);
+          applyNarrowing(alternateCtx, narrowing.name, narrowing.values);
         }
       }
       analyzeStructuredNode(node.consequent, shapes, propertyReads, consequentCtx);
@@ -18714,7 +18966,7 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
       for (const caseNode of node.cases) {
         const caseCtx = cloneKeyContext(ctx);
         if (discriminant && caseNode.test?.kind === "Literal" && (typeof caseNode.test.value === "string" || typeof caseNode.test.value === "number")) {
-          caseCtx.set(discriminant, caseNode.test.value);
+          applyNarrowing(caseCtx, discriminant, /* @__PURE__ */ new Set([caseNode.test.value]));
         }
         analyzeStructuredNode(caseNode.body, shapes, propertyReads, caseCtx);
       }
@@ -18745,7 +18997,8 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
       analyzeExpression(node.iterable, shapes, propertyReads, ctx);
       {
         const bodyCtx = cloneKeyContext(ctx);
-        bodyCtx.delete(node.variable);
+        bodyCtx.values.delete(node.variable);
+        bodyCtx.keySets.delete(node.variable);
         if (node.pattern) {
           clearPatternBindings(node.pattern, bodyCtx);
         }
@@ -18756,7 +19009,8 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
       analyzeExpression(node.object, shapes, propertyReads, ctx);
       {
         const bodyCtx = cloneKeyContext(ctx);
-        bodyCtx.delete(node.variable);
+        bodyCtx.values.delete(node.variable);
+        bodyCtx.keySets.delete(node.variable);
         if (node.pattern) {
           clearPatternBindings(node.pattern, bodyCtx);
         }
@@ -18768,7 +19022,8 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
       if (node.handler) {
         const handlerCtx = cloneKeyContext(ctx);
         if (node.handler.param) {
-          handlerCtx.delete(node.handler.param);
+          handlerCtx.values.delete(node.handler.param);
+          handlerCtx.keySets.delete(node.handler.param);
         }
         analyzeStructuredNode(node.handler.body, shapes, propertyReads, handlerCtx);
       }
@@ -18794,9 +19049,7 @@ function analyzeStructuredNode(node, shapes, propertyReads, ctx) {
 }
 function analyzeInstruction(instr, shapes, propertyReads, ctx) {
   if (instr.kind === "Assign") {
-    if (ctx.has(instr.target.name)) {
-      ctx.delete(instr.target.name);
-    }
+    applyKeyAssignment(ctx, instr.target.name, instr.value);
     const valueShape = analyzeExpression(instr.value, shapes, propertyReads, ctx);
     if (valueShape) {
       const existing = shapes.get(instr.target.name);
@@ -18853,12 +19106,14 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
         const reads = propertyReads.get(base) ?? /* @__PURE__ */ new Set();
         const baseShape = shapes.get(base);
         if (directMember.computed) {
-          const resolved = resolveNarrowedKey(directMember.property, ctx);
-          if (resolved !== null) {
-            const key = String(resolved);
-            reads.add(key);
-            if (baseShape) {
-              baseShape.knownKeys.add(key);
+          const resolved = resolveNarrowedKeys(directMember.property, ctx);
+          if (resolved && resolved.size > 0) {
+            for (const value of resolved) {
+              const key = String(value);
+              reads.add(key);
+              if (baseShape) {
+                baseShape.knownKeys.add(key);
+              }
             }
           } else if (baseShape) {
             baseShape.dynamicAccess = true;
@@ -18880,6 +19135,34 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
       return null;
     }
     case "CallExpression": {
+      if (expr.callee.kind === "MemberExpression") {
+        if (expr.callee.object.kind === "Identifier") {
+          const baseName2 = expr.callee.object.name;
+          const propName = !expr.callee.computed && expr.callee.property.kind === "Identifier" ? expr.callee.property.name : expr.callee.property.kind === "Literal" && typeof expr.callee.property.value === "string" ? expr.callee.property.value : null;
+          if (propName && ctx.keySets.has(baseName2) && [
+            "push",
+            "pop",
+            "shift",
+            "unshift",
+            "splice",
+            "sort",
+            "reverse",
+            "copyWithin",
+            "fill"
+          ].includes(propName)) {
+            ctx.keySets.delete(baseName2);
+          }
+        }
+      }
+      for (const arg of expr.arguments) {
+        if (arg.kind === "Identifier" && ctx.keySets.has(arg.name)) {
+          ctx.keySets.delete(arg.name);
+        } else if (arg.kind === "SpreadElement" && arg.argument.kind === "Identifier") {
+          if (ctx.keySets.has(arg.argument.name)) {
+            ctx.keySets.delete(arg.argument.name);
+          }
+        }
+      }
       for (const arg of expr.arguments) {
         markEscaping(arg, shapes);
       }
@@ -18931,9 +19214,7 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
     }
     case "AssignmentExpression": {
       if (expr.left.kind === "Identifier") {
-        if (ctx.has(expr.left.name)) {
-          ctx.delete(expr.left.name);
-        }
+        applyKeyAssignment(ctx, expr.left.name, expr.right);
       }
       if (expr.left.kind === "MemberExpression") {
         const base = getBaseIdentifier(expr.left.object);
@@ -18945,14 +19226,19 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
             } else if (expr.left.property.kind === "Literal" && typeof expr.left.property.value === "string") {
               shape.mutableKeys.add(expr.left.property.value);
             } else {
-              const resolved = resolveNarrowedKey(expr.left.property, ctx);
-              if (resolved !== null) {
-                shape.mutableKeys.add(String(resolved));
+              const resolved = resolveNarrowedKeys(expr.left.property, ctx);
+              if (resolved && resolved.size > 0) {
+                for (const value of resolved) {
+                  shape.mutableKeys.add(String(value));
+                }
               } else {
                 shape.dynamicAccess = true;
               }
             }
           }
+          if (ctx.keySets.has(base)) {
+            ctx.keySets.delete(base);
+          }
         }
       }
       analyzeExpression(expr.right, shapes, propertyReads, ctx);
@@ -18960,8 +19246,13 @@ function analyzeExpression(expr, shapes, propertyReads, ctx) {
     }
     case "UpdateExpression": {
       if (expr.argument.kind === "Identifier") {
-        if (ctx.has(expr.argument.name)) {
-          ctx.delete(expr.argument.name);
+        ctx.values.delete(expr.argument.name);
+        ctx.keySets.delete(expr.argument.name);
+      }
+      if (expr.argument.kind === "MemberExpression") {
+        const base = getBaseIdentifier(expr.argument.object);
+        if (base) {
+          ctx.keySets.delete(base);
         }
       }
       analyzeExpression(expr.argument, shapes, propertyReads, ctx);
@@ -19393,7 +19684,11 @@ function expressionUsesTracked(expr, ctx) {
       return ctx.trackedVars.has(deSSAVarName(expr.name)) || (ctx.externalTracked?.has(deSSAVarName(expr.name)) ?? false) || (ctx.memoVars?.has(deSSAVarName(expr.name)) ?? false) || (ctx.aliasVars?.has(deSSAVarName(expr.name)) ?? false);
     case "MemberExpression":
     case "OptionalMemberExpression":
-      return expressionUsesTracked(expr.object, ctx);
+      if (expressionUsesTracked(expr.object, ctx)) return true;
+      if (expr.computed && expr.property.kind !== "Literal") {
+        return expressionUsesTracked(expr.property, ctx);
+      }
+      return false;
     case "CallExpression":
     case "OptionalCallExpression":
       if (expressionUsesTracked(expr.callee, ctx)) return true;
@@ -21201,6 +21496,24 @@ function setNodeLoc(node, loc) {
   node.loc = cloneLoc(loc) ?? null;
   return node;
 }
+function serializeHookReturnInfo(info) {
+  const objectProps = info.objectProps ? Object.fromEntries(info.objectProps.entries()) : void 0;
+  const arrayProps = info.arrayProps ? Object.fromEntries(Array.from(info.arrayProps.entries()).map(([k, v]) => [String(k), v])) : void 0;
+  return {
+    objectProps,
+    arrayProps,
+    directAccessor: info.directAccessor
+  };
+}
+function deserializeHookReturnInfo(info) {
+  const objectProps = info.objectProps ? new Map(Object.entries(info.objectProps)) : void 0;
+  const arrayProps = info.arrayProps ? new Map(Object.entries(info.arrayProps).map(([k, v]) => [Number.parseInt(k, 10), v])) : void 0;
+  return {
+    objectProps,
+    arrayProps,
+    directAccessor: info.directAccessor
+  };
+}
 function propagateHookResultAlias(targetBase, value, ctx) {
   const mapSource = (source) => {
     const hookName = ctx.hookResultVarMap?.get(source);
@@ -21224,6 +21537,15 @@ function propagateHookResultAlias(targetBase, value, ctx) {
       mapSource(deSSAVarName(firstArg.name));
     }
   }
+  if (value.kind === "SequenceExpression" && value.expressions.length > 0) {
+    const last = value.expressions[value.expressions.length - 1];
+    if (last && last.kind === "CallExpression" && last.callee.kind === "Identifier" && last.callee.name === "__fictPropsRest") {
+      const firstArg = last.arguments[0];
+      if (firstArg && firstArg.kind === "Identifier") {
+        mapSource(deSSAVarName(firstArg.name));
+      }
+    }
+  }
 }
 function applyRegionToContext(ctx, region) {
   const prevRegion = ctx.currentRegion;
@@ -21530,6 +21852,7 @@ function createCodegenContext(t4) {
     aliasVars: /* @__PURE__ */ new Set(),
     externalTracked: /* @__PURE__ */ new Set(),
     storeVars: /* @__PURE__ */ new Set(),
+    importedNamespaces: /* @__PURE__ */ new Map(),
     signalVars: /* @__PURE__ */ new Set(),
     functionVars: /* @__PURE__ */ new Set(),
     memoVars: /* @__PURE__ */ new Set(),
@@ -22477,6 +22800,12 @@ function extractKeyFromMapCallback(callback) {
   if (!jsx) return void 0;
   return extractKeyFromAttributes(jsx.attributes);
 }
+function buildOutputParams(fn, t4) {
+  if (fn.rawParams && fn.rawParams.length > 0) {
+    return fn.rawParams.map((param) => t4.cloneNode(param, true));
+  }
+  return fn.params.map((p) => t4.identifier(deSSAVarName(p.name)));
+}
 function lowerTrackedExpression(expr, ctx) {
   const regionOverride = ctx.inReturn && ctx.currentFnIsHook ? null : ctx.currentRegion ?? (ctx.trackedVars.size ? {
     id: -1,
@@ -22770,6 +23099,171 @@ function collectRuntimeImportNames(body, t4) {
   }
   return imported;
 }
+function addImportedReactiveBinding(name, kind, ctx) {
+  const base = deSSAVarName(name);
+  if (kind === "signal") {
+    ctx.signalVars?.add(base);
+  } else if (kind === "store") {
+    ctx.storeVars?.add(base);
+  } else if (kind === "memo") {
+    ctx.memoVars?.add(base);
+  }
+  ctx.trackedVars.add(base);
+}
+function applyImportedReactiveMetadata(body, ctx, t4, options) {
+  const importer = options?.filename;
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const stmt of body) {
+    if (!t4.isImportDeclaration(stmt)) continue;
+    const meta = resolveModuleMetadata(stmt.source.value, importer, options);
+    if (!meta) continue;
+    for (const spec of stmt.specifiers) {
+      if (t4.isImportSpecifier(spec)) {
+        const importedName = t4.isIdentifier(spec.imported) ? spec.imported.name : String(spec.imported.value);
+        const localName = spec.local.name;
+        const kind = meta.exports[importedName];
+        if (kind) {
+          addImportedReactiveBinding(localName, kind, ctx);
+        }
+        const hookInfo = meta.hooks?.[importedName];
+        if (hookInfo) {
+          ctx.hookReturnInfo = ctx.hookReturnInfo ?? /* @__PURE__ */ new Map();
+          ctx.hookReturnInfo.set(localName, deserializeHookReturnInfo(hookInfo));
+        }
+        continue;
+      }
+      if (t4.isImportDefaultSpecifier(spec)) {
+        const localName = spec.local.name;
+        const kind = meta.exports.default;
+        if (kind) {
+          addImportedReactiveBinding(localName, kind, ctx);
+        }
+        const hookInfo = meta.hooks?.default;
+        if (hookInfo) {
+          ctx.hookReturnInfo = ctx.hookReturnInfo ?? /* @__PURE__ */ new Map();
+          ctx.hookReturnInfo.set(localName, deserializeHookReturnInfo(hookInfo));
+        }
+        continue;
+      }
+      if (t4.isImportNamespaceSpecifier(spec)) {
+        namespaces.set(spec.local.name, meta);
+      }
+    }
+  }
+  if (namespaces.size > 0) {
+    ctx.importedNamespaces = namespaces;
+  }
+}
+function classifyReactiveExport(name, ctx) {
+  const base = deSSAVarName(name);
+  if (ctx.storeVars?.has(base)) return "store";
+  if (ctx.signalVars?.has(base)) return "signal";
+  if (ctx.aliasVars?.has(base)) return "signal";
+  if (ctx.memoVars?.has(base)) return "memo";
+  return null;
+}
+function buildModuleReactiveMetadata(body, ctx, t4, options, stateMacroNames, memoMacroNames) {
+  const metadata = { exports: {} };
+  const hookExports = {};
+  const addExport = (exportName, localName) => {
+    const kind = classifyReactiveExport(localName, ctx);
+    if (kind) {
+      metadata.exports[exportName] = kind;
+    }
+    const hookInfo = getHookReturnInfo(localName, ctx);
+    if (hookInfo) {
+      hookExports[exportName] = serializeHookReturnInfo(hookInfo);
+    }
+  };
+  const addExportFromSource = (source, importedName, exportName) => {
+    const sourceMeta = resolveModuleMetadata(source, options?.filename, options);
+    if (!sourceMeta) return;
+    const kind = sourceMeta.exports[importedName];
+    if (kind) {
+      metadata.exports[exportName] = kind;
+    }
+    const hookInfo = sourceMeta.hooks?.[importedName];
+    if (hookInfo) {
+      hookExports[exportName] = hookInfo;
+    }
+  };
+  const addDefaultExportKind = (kind) => {
+    if (kind) {
+      metadata.exports.default = kind;
+    }
+  };
+  for (const stmt of body) {
+    if (t4.isExportNamedDeclaration(stmt)) {
+      if (stmt.source && stmt.specifiers.length > 0) {
+        for (const spec of stmt.specifiers) {
+          if (!t4.isExportSpecifier(spec)) continue;
+          const importedName = spec.local.name;
+          const exportName = t4.isIdentifier(spec.exported) ? spec.exported.name : t4.isStringLiteral(spec.exported) ? spec.exported.value : String(spec.exported);
+          addExportFromSource(stmt.source.value, importedName, exportName);
+        }
+        continue;
+      }
+      if (stmt.declaration) {
+        const decl = stmt.declaration;
+        if (t4.isFunctionDeclaration(decl) && decl.id) {
+          addExport(decl.id.name, decl.id.name);
+        } else if (t4.isClassDeclaration(decl) && decl.id) {
+          addExport(decl.id.name, decl.id.name);
+        } else if (t4.isVariableDeclaration(decl)) {
+          for (const v of decl.declarations) {
+            if (t4.isIdentifier(v.id)) {
+              addExport(v.id.name, v.id.name);
+            }
+          }
+        }
+      } else {
+        for (const spec of stmt.specifiers) {
+          if (!t4.isExportSpecifier(spec)) continue;
+          const localName = spec.local.name;
+          const exportName = t4.isIdentifier(spec.exported) ? spec.exported.name : t4.isStringLiteral(spec.exported) ? spec.exported.value : String(spec.exported);
+          addExport(exportName, localName);
+        }
+      }
+      continue;
+    }
+    if (t4.isExportAllDeclaration(stmt)) {
+      const sourceMeta = resolveModuleMetadata(stmt.source.value, options?.filename, options);
+      if (!sourceMeta) continue;
+      for (const [exportName, kind] of Object.entries(sourceMeta.exports)) {
+        if (exportName === "default") continue;
+        metadata.exports[exportName] = kind;
+      }
+      if (sourceMeta.hooks) {
+        for (const [exportName, info] of Object.entries(sourceMeta.hooks)) {
+          if (exportName === "default") continue;
+          hookExports[exportName] = info;
+        }
+      }
+      continue;
+    }
+    if (t4.isExportDefaultDeclaration(stmt)) {
+      const decl = stmt.declaration;
+      if (t4.isIdentifier(decl)) {
+        addExport("default", decl.name);
+      } else if (t4.isFunctionDeclaration(decl) && decl.id) {
+        addExport("default", decl.id.name);
+      } else if (t4.isClassDeclaration(decl) && decl.id) {
+        addExport("default", decl.id.name);
+      } else if (t4.isCallExpression(decl) && t4.isIdentifier(decl.callee)) {
+        const callee = decl.callee.name;
+        if (stateMacroNames.has(callee) || callee === "$store") {
+          addDefaultExportKind(callee === "$store" ? "store" : "signal");
+        } else if (memoMacroNames.has(callee)) {
+          addDefaultExportKind("memo");
+        }
+      }
+    }
+  }
+  if (Object.keys(hookExports).length > 0) {
+    metadata.hooks = hookExports;
+  }
+  return metadata;
+}
 function collectLocalDeclaredNames(params, blocks, t4) {
   const declared = /* @__PURE__ */ new Set();
   const addPatternNames = (pattern) => {
@@ -23078,6 +23572,24 @@ function lowerExpressionImpl(expr, ctx, _isAssigned = false) {
       if (matchesListKeyPattern(expr, ctx)) {
         return t4.identifier(ctx.listKeyParamName);
       }
+      if (expr.object.kind === "Identifier") {
+        const nsMeta = ctx.importedNamespaces?.get(deSSAVarName(expr.object.name));
+        if (nsMeta) {
+          const propName = getStaticPropName(expr.property, expr.computed);
+          if (typeof propName === "string") {
+            const kind = nsMeta.exports[propName];
+            if (kind === "signal" || kind === "memo") {
+              const member = t4.memberExpression(
+                t4.identifier(deSSAVarName(expr.object.name)),
+                expr.computed ? t4.stringLiteral(propName) : t4.identifier(propName),
+                expr.computed,
+                expr.optional
+              );
+              return t4.callExpression(member, []);
+            }
+          }
+        }
+      }
       if (expr.object.kind === "Identifier" && ctx.hookResultVarMap?.has(deSSAVarName(expr.object.name))) {
         const hookName = ctx.hookResultVarMap.get(deSSAVarName(expr.object.name));
         const info = getHookReturnInfo(hookName, ctx);
@@ -23569,8 +24081,8 @@ function collectExpressionDependencies(expr, deps) {
     return;
   }
   if (expr.kind === "MemberExpression") {
-    const path = getMemberDependencyPath(expr);
-    if (path) deps.add(path);
+    const path2 = getMemberDependencyPath(expr);
+    if (path2) deps.add(path2);
     collectExpressionDependencies(expr.object, deps);
     if (expr.computed && expr.property.kind !== "Literal") {
       collectExpressionDependencies(expr.property, deps);
@@ -23755,9 +24267,9 @@ function replaceIdentifiersWithOverrides(node, overrides, t4, parentKind, parent
   if (!skipCurrentNode && (t4.isMemberExpression(node) || t4.isOptionalMemberExpression(node))) {
     const propertyNode = node.property;
     const isDynamicComputed = (node.computed ?? false) && !t4.isStringLiteral(propertyNode) && !t4.isNumericLiteral(propertyNode);
-    const path = getDependencyPathFromNode(node, t4);
-    const normalized = path ? normalizeDependencyKey2(path) : null;
-    const override = normalized && overrides[normalized] || (path ? overrides[path] : void 0);
+    const path2 = getDependencyPathFromNode(node, t4);
+    const normalized = path2 ? normalizeDependencyKey2(path2) : null;
+    const override = normalized && overrides[normalized] || (path2 ? overrides[path2] : void 0);
     if (override && !isCallTarget && !isDynamicComputed) {
       const replacement = override();
       Object.assign(node, replacement);
@@ -24488,11 +25000,11 @@ function lowerIntrinsicElement(jsx, ctx) {
   }
   return t4.callExpression(t4.arrowFunctionExpression([], body), []);
 }
-function resolveHIRBindingPath(path, cache, statements, ctx) {
-  const key = path.join(",");
+function resolveHIRBindingPath(path2, cache, statements, ctx) {
+  const key = path2.join(",");
   if (cache.has(key)) return cache.get(key);
   const { t: t4 } = ctx;
-  const ancestorPath = [...path];
+  const ancestorPath = [...path2];
   let ancestorId;
   let relativePath = [];
   while (ancestorPath.length > 0) {
@@ -24500,13 +25012,13 @@ function resolveHIRBindingPath(path, cache, statements, ctx) {
     const ancestorKey = ancestorPath.join(",");
     if (cache.has(ancestorKey)) {
       ancestorId = cache.get(ancestorKey);
-      relativePath = path.slice(ancestorPath.length);
+      relativePath = path2.slice(ancestorPath.length);
       break;
     }
   }
   if (!ancestorId) {
     ancestorId = cache.get("");
-    relativePath = path;
+    relativePath = path2;
   }
   let currentExpr = ancestorId;
   for (const index of relativePath) {
@@ -25315,6 +25827,7 @@ function lowerHIRWithRegions(program, t4, options, macroAliases) {
   const originalBody = program.originalBody ?? [];
   ctx.moduleDeclaredNames = collectDeclaredNames(originalBody, t4);
   ctx.moduleRuntimeNames = collectRuntimeImportNames(originalBody, t4);
+  applyImportedReactiveMetadata(originalBody, ctx, t4, options);
   const stateMacroNames = /* @__PURE__ */ new Set(["$state", ...macroAliases?.state ?? []]);
   const memoMacroNames = new Set(macroAliases?.memo ?? ctx.memoMacroNames ?? []);
   if (!memoMacroNames.has("$memo")) memoMacroNames.add("$memo");
@@ -25554,6 +26067,15 @@ function lowerHIRWithRegions(program, t4, options, macroAliases) {
     ctx.helpersUsed.add("popContext");
     body.push(t4.expressionStatement(t4.callExpression(t4.identifier(RUNTIME_ALIASES.popContext), [])));
   }
+  const moduleMeta = buildModuleReactiveMetadata(
+    originalBody,
+    ctx,
+    t4,
+    options,
+    stateMacroNames,
+    memoMacroNames
+  );
+  setModuleMetadata(options?.filename, moduleMeta, options);
   return t4.file(t4.program(attachHelperImports(ctx, body, t4)));
 }
 function lowerTopLevelStatementBlock(statements, ctx, t4, name = "__module_segment", existingAliases) {
@@ -26034,7 +26556,7 @@ function lowerFunctionWithRegions(fn, ctx) {
     if (!hasComplexControlFlow && !isAsync) {
       const pureDeclaredVars = /* @__PURE__ */ new Set();
       const pureStatements = lowerStructuredNodeWithoutRegions(structured, t4, ctx, pureDeclaredVars);
-      const params2 = fn.params.map((p) => t4.identifier(deSSAVarName(p.name)));
+      const params2 = buildOutputParams(fn, t4);
       const funcDecl2 = setNodeLoc(
         t4.functionDeclaration(
           t4.identifier(fn.name ?? "fn"),
@@ -26109,13 +26631,31 @@ function lowerFunctionWithRegions(fn, ctx) {
       )
     );
   }
-  let finalParams = fn.params.map((p) => t4.identifier(deSSAVarName(p.name)));
+  let finalParams = buildOutputParams(fn, t4);
   const propsDestructuring = [];
   if (isComponent && fn.rawParams && fn.rawParams.length === 1) {
     const rawParam = fn.rawParams[0];
     if (rawParam && (rawParam.type === "ObjectPattern" || rawParam.type === "AssignmentPattern" && rawParam.left?.type === "ObjectPattern")) {
-      finalParams = [t4.identifier("__props")];
       const pattern = rawParam.type === "AssignmentPattern" ? rawParam.left : rawParam;
+      const defaultExpr = rawParam.type === "AssignmentPattern" ? rawParam.right : null;
+      if (defaultExpr) {
+        const propsParamName = "__propsParam";
+        finalParams = [t4.identifier(propsParamName)];
+        propsDestructuring.push(
+          t4.variableDeclaration("const", [
+            t4.variableDeclarator(
+              t4.identifier("__props"),
+              t4.conditionalExpression(
+                t4.binaryExpression("===", t4.identifier(propsParamName), t4.identifier("undefined")),
+                t4.cloneNode(defaultExpr, true),
+                t4.identifier(propsParamName)
+              )
+            )
+          ])
+        );
+      } else {
+        finalParams = [t4.identifier("__props")];
+      }
       if (propsDestructurePlan) {
         if (propsDestructurePlan.usesProp) {
           ctx.helpersUsed.add("prop");
@@ -26273,7 +26813,7 @@ function optimizeHIR(program, options = {}) {
         originalBody: []
       });
       const ssaFn = ssaProgram.functions[0];
-      return ssaFn ? optimizeSSAFunction(ssaFn) : fn;
+      return ssaFn ? optimizeSSAFunction(ssaFn, options) : fn;
     }
     if (isReactiveOptimizationCandidate(fn)) {
       return optimizeReactiveFunction(fn, exportedNames, options);
@@ -26285,9 +26825,9 @@ function optimizeHIR(program, options = {}) {
     functions
   };
 }
-function optimizeSSAFunction(fn) {
+function optimizeSSAFunction(fn, options) {
   let current = fn;
-  current = propagateConstants(current);
+  current = propagateConstants(current, options);
   const purity = buildPurityContext(current);
   current = eliminateCommonSubexpressions(current, purity);
   current = inlineSingleUse(current, purity);
@@ -26912,7 +27452,9 @@ function optimizeReactiveFunction(fn, exportedNames, options) {
   const reactive = buildReactiveContext(fn);
   const purity = buildPurityContext(fn);
   const hookLike = isHookLikeFunction(fn);
-  const transformedBlocks = fn.blocks.map((block) => optimizeReactiveBlock(block, reactive, purity));
+  const transformedBlocks = fn.blocks.map(
+    (block) => optimizeReactiveBlock(block, reactive, purity, options)
+  );
   let transformed = { ...fn, blocks: transformedBlocks };
   if (isCrossBlockConstPropagationEnabled()) {
     transformed = propagateCrossBlockConstants(transformed, reactive, purity, scopeResult);
@@ -26947,7 +27489,7 @@ function optimizeReactiveFunction(fn, exportedNames, options) {
   });
   return { ...transformed, blocks };
 }
-function optimizeReactiveBlock(block, reactive, purity) {
+function optimizeReactiveBlock(block, reactive, purity, options) {
   const constants = /* @__PURE__ */ new Map();
   const constObjects = /* @__PURE__ */ new Map();
   const constArrays = /* @__PURE__ */ new Map();
@@ -26985,7 +27527,7 @@ function optimizeReactiveBlock(block, reactive, purity) {
         constArrays.delete(name);
       }
       const dependsOnReactiveValue = expressionDependsOnReactive(instr.value, reactive);
-      let value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, constObjects, constArrays);
+      let value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, options, constObjects, constArrays);
       const allowCSE = isCompilerGeneratedName(target) && (!declKind || declKind === "const");
       if (allowCSE && isPureExpression(value, purity) && !isExplicitMemoCall(value, purity) && !dependsOnReactiveValue && isCSESafeExpression(value, purity)) {
         const deps = collectExpressionIdentifiers2(value, true);
@@ -27033,7 +27575,7 @@ function optimizeReactiveBlock(block, reactive, purity) {
         constArrays.delete(name);
       }
       const dependsOnReactiveValue = expressionDependsOnReactive(instr.value, reactive);
-      const value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, constObjects, constArrays);
+      const value = dependsOnReactiveValue ? instr.value : foldExpressionWithConstants(instr.value, constants, options, constObjects, constArrays);
       instructions.push(value === instr.value ? instr : { ...instr, value });
       continue;
     }
@@ -27042,6 +27584,7 @@ function optimizeReactiveBlock(block, reactive, purity) {
   const terminator = foldTerminatorWithConstants(
     block.terminator,
     constants,
+    options,
     reactive,
     constObjects,
     constArrays
@@ -27973,7 +28516,7 @@ function blocksContainImpureMarkers(blocks) {
   }
   return false;
 }
-function propagateConstants(fn) {
+function propagateConstants(fn, options) {
   const constants = computeConstantMap(fn);
   if (constants.size === 0) return fn;
   const blocks = fn.blocks.map((block) => ({
@@ -27981,12 +28524,12 @@ function propagateConstants(fn) {
     instructions: block.instructions.map((instr) => {
       if (instr.kind === "Assign") {
         const replaced = replaceIdentifiersWithConstants(instr.value, constants);
-        const folded = foldExpression(replaced, constants);
+        const folded = foldExpression(replaced, constants, options);
         return { ...instr, value: folded };
       }
       if (instr.kind === "Expression") {
         const replaced = replaceIdentifiersWithConstants(instr.value, constants);
-        const folded = foldExpression(replaced, constants);
+        const folded = foldExpression(replaced, constants, options);
         return { ...instr, value: folded };
       }
       if (instr.kind === "Phi") {
@@ -28386,15 +28929,18 @@ function evaluateBinary(operator, left, right) {
     return UNKNOWN_CONST;
   }
 }
-function foldExpression(expr, constants) {
+function foldExpression(expr, constants, options) {
   const value = evaluateConstant(expr, constants);
   if (value === UNKNOWN_CONST) {
-    return simplifyAlgebraically(expr, constants);
+    return simplifyAlgebraically(expr, constants, options);
   }
   return { kind: "Literal", value, loc: expr.loc };
 }
-function simplifyAlgebraically(expr, constants) {
-  const simplified = simplifyChildren(expr, constants);
+function simplifyAlgebraically(expr, constants, options) {
+  const simplified = simplifyChildren(expr, constants, options);
+  if (options.optimizeLevel === "safe") {
+    return simplified;
+  }
   if (simplified.kind === "BinaryExpression") {
     const { operator, left, right, loc } = simplified;
     switch (operator) {
@@ -28473,37 +29019,37 @@ function simplifyAlgebraically(expr, constants) {
   }
   return simplified;
 }
-function simplifyChildren(expr, constants) {
+function simplifyChildren(expr, constants, options) {
   switch (expr.kind) {
     case "BinaryExpression":
       return {
         ...expr,
-        left: simplifyAlgebraically(expr.left, constants),
-        right: simplifyAlgebraically(expr.right, constants)
+        left: simplifyAlgebraically(expr.left, constants, options),
+        right: simplifyAlgebraically(expr.right, constants, options)
       };
     case "LogicalExpression":
       return {
         ...expr,
-        left: simplifyAlgebraically(expr.left, constants),
-        right: simplifyAlgebraically(expr.right, constants)
+        left: simplifyAlgebraically(expr.left, constants, options),
+        right: simplifyAlgebraically(expr.right, constants, options)
       };
     case "UnaryExpression":
       return {
         ...expr,
-        argument: simplifyAlgebraically(expr.argument, constants)
+        argument: simplifyAlgebraically(expr.argument, constants, options)
       };
     case "ConditionalExpression":
       return {
         ...expr,
-        test: simplifyAlgebraically(expr.test, constants),
-        consequent: simplifyAlgebraically(expr.consequent, constants),
-        alternate: simplifyAlgebraically(expr.alternate, constants)
+        test: simplifyAlgebraically(expr.test, constants, options),
+        consequent: simplifyAlgebraically(expr.consequent, constants, options),
+        alternate: simplifyAlgebraically(expr.alternate, constants, options)
       };
     case "ArrayExpression":
       return {
         ...expr,
         elements: expr.elements.map(
-          (el) => el ? simplifyAlgebraically(el, constants) : el
+          (el) => el ? simplifyAlgebraically(el, constants, options) : el
         )
       };
     case "ObjectExpression":
@@ -28513,13 +29059,13 @@ function simplifyChildren(expr, constants) {
           if (prop.kind === "Property") {
             return {
               ...prop,
-              value: simplifyAlgebraically(prop.value, constants)
+              value: simplifyAlgebraically(prop.value, constants, options)
             };
           }
           if (prop.kind === "SpreadElement") {
             return {
               ...prop,
-              argument: simplifyAlgebraically(prop.argument, constants)
+              argument: simplifyAlgebraically(prop.argument, constants, options)
             };
           }
           return prop;
@@ -28529,35 +29075,35 @@ function simplifyChildren(expr, constants) {
     case "OptionalCallExpression":
       return {
         ...expr,
-        arguments: expr.arguments.map((arg) => simplifyAlgebraically(arg, constants))
+        arguments: expr.arguments.map((arg) => simplifyAlgebraically(arg, constants, options))
       };
     case "ImportExpression":
       return {
         ...expr,
-        source: simplifyAlgebraically(expr.source, constants)
+        source: simplifyAlgebraically(expr.source, constants, options)
       };
     case "MemberExpression":
     case "OptionalMemberExpression":
       return {
         ...expr,
-        object: simplifyAlgebraically(expr.object, constants),
-        property: expr.computed ? simplifyAlgebraically(expr.property, constants) : expr.property
+        object: simplifyAlgebraically(expr.object, constants, options),
+        property: expr.computed ? simplifyAlgebraically(expr.property, constants, options) : expr.property
       };
     default:
       return expr;
   }
 }
-function foldExpressionWithConstants(expr, constants, constObjects, constArrays) {
+function foldExpressionWithConstants(expr, constants, options, constObjects, constArrays) {
   const replaced = replaceIdentifiersWithConstants(expr, constants);
   if (!constObjects && !constArrays) {
-    return foldExpression(replaced, constants);
+    return foldExpression(replaced, constants, options);
   }
   const memberReplaced = replaceConstMemberExpressions(
     replaced,
     constObjects ?? /* @__PURE__ */ new Map(),
     constArrays ?? /* @__PURE__ */ new Map()
   );
-  return foldExpression(memberReplaced, constants);
+  return foldExpression(memberReplaced, constants, options);
 }
 function replaceIdentifiersWithConstants(expr, constants, context = {}) {
   switch (expr.kind) {
@@ -28719,10 +29265,10 @@ function replaceConstantsInTerminator(term, constants) {
       return term;
   }
 }
-function foldTerminatorWithConstants(term, constants, reactive, constObjects, constArrays) {
+function foldTerminatorWithConstants(term, constants, options, reactive, constObjects, constArrays) {
   const fold = (expr) => {
     if (reactive && expressionDependsOnReactive(expr, reactive)) return expr;
-    return foldExpressionWithConstants(expr, constants, constObjects, constArrays);
+    return foldExpressionWithConstants(expr, constants, options, constObjects, constArrays);
   };
   switch (term.kind) {
     case "Return":
@@ -28839,11 +29385,14 @@ function hasSideEffectsBetween(instructions, start, end, purity) {
 function eliminateDeadCode(fn, purity) {
   const depsByVar = buildDependencyGraph(fn);
   const live = computeLiveVariables(fn, depsByVar, purity);
+  const baseLive = /* @__PURE__ */ new Set();
+  live.forEach((name) => baseLive.add(getSSABaseName(name)));
   const blocks = fn.blocks.map((block) => {
     const instructions = block.instructions.filter((instr) => {
       if (instr.kind === "Assign") {
         const name = instr.target.name;
         if (live.has(name)) return true;
+        if (instr.declarationKind && baseLive.has(getSSABaseName(name))) return true;
         return !isPureExpression(instr.value, purity) || isExplicitMemoCall(instr.value, purity);
       }
       if (instr.kind === "Phi") {
@@ -29855,8 +30404,8 @@ function getRootIdentifier(expr, t4) {
 }
 
 // src/index.ts
-function stripMacroImports(path, t4) {
-  path.traverse({
+function stripMacroImports(path2, t4) {
+  path2.traverse({
     ImportDeclaration(importPath) {
       if (importPath.node.source.value !== "fict" && importPath.node.source.value !== "fict/slim")
         return;
@@ -29874,19 +30423,19 @@ function stripMacroImports(path, t4) {
     }
   });
 }
-function isInsideLoop(path) {
-  return !!path.findParent(
+function isInsideLoop(path2) {
+  return !!path2.findParent(
     (p) => p.isForStatement?.() || p.isWhileStatement?.() || p.isDoWhileStatement?.() || p.isForInStatement?.() || p.isForOfStatement?.()
   );
 }
-function isInsideConditional(path) {
-  return !!path.findParent(
+function isInsideConditional(path2) {
+  return !!path2.findParent(
     (p) => p.isIfStatement?.() || p.isConditionalExpression?.() || p.isSwitchCase?.()
   );
 }
-function isInsideNestedFunction(path) {
+function isInsideNestedFunction(path2) {
   let depth = 0;
-  let current = path;
+  let current = path2;
   while (current) {
     if (current.isFunction?.()) {
       depth++;
@@ -29896,8 +30445,8 @@ function isInsideNestedFunction(path) {
   }
   return false;
 }
-function isInsideJSX(path) {
-  return !!path.findParent((p) => p.isJSXElement?.() || p.isJSXFragment?.());
+function isInsideJSX(path2) {
+  return !!path2.findParent((p) => p.isJSXElement?.() || p.isJSXFragment?.());
 }
 function parseSuppressionCodes(raw) {
   if (!raw) return void 0;
@@ -29926,12 +30475,42 @@ function shouldSuppressWarning(suppressions, code, line) {
     return entry.codes.has(code);
   });
 }
-function createWarningDispatcher(onWarn, suppressions) {
-  if (!onWarn) return () => {
+function hasErrorEscalation(options) {
+  if (options.warningsAsErrors === true) return true;
+  if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.length > 0) return true;
+  if (options.warningLevels) {
+    return Object.values(options.warningLevels).some((level) => level === "error");
+  }
+  return false;
+}
+function resolveWarningLevel(code, options) {
+  const override = options.warningLevels?.[code];
+  if (override) return override;
+  if (options.warningsAsErrors === true) return "error";
+  if (Array.isArray(options.warningsAsErrors) && options.warningsAsErrors.includes(code)) {
+    return "error";
+  }
+  return "warn";
+}
+function formatWarningAsError(warning) {
+  const location = warning.line > 0 ? `${warning.fileName}:${warning.line}:${warning.column}` : warning.fileName;
+  return `Fict warning treated as error (${warning.code}): ${warning.message}
+  at ${location}`;
+}
+function createWarningDispatcher(onWarn, suppressions, options, dev) {
+  const hasEscalation = hasErrorEscalation(options);
+  if (!dev && !hasEscalation) return () => {
   };
   return (warning) => {
     if (shouldSuppressWarning(suppressions, warning.code, warning.line)) return;
-    onWarn(warning);
+    const level = resolveWarningLevel(warning.code, options);
+    if (level === "off") return;
+    if (level === "error") {
+      throw new Error(formatWarningAsError(warning));
+    }
+    if (dev && onWarn) {
+      onWarn(warning);
+    }
   };
 }
 function emitWarning(node, code, message, warn, fileName) {
@@ -30031,13 +30610,13 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
   };
   const reactiveNames = /* @__PURE__ */ new Set([...stateVars, ...derivedVars]);
   programPath.traverse({
-    AssignmentExpression(path) {
-      const { left } = path.node;
+    AssignmentExpression(path2) {
+      const { left } = path2.node;
       if (t4.isIdentifier(left)) return;
       if (t4.isMemberExpression(left) || t4.isOptionalMemberExpression(left)) {
         if (isStateRoot(left.object)) {
           emitWarning(
-            path.node,
+            path2.node,
             "FICT-M",
             "Direct mutation of nested property detected; use immutable update or $store helpers",
             warn,
@@ -30045,7 +30624,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
           );
           if (isDynamicPropertyAccess(left, t4)) {
             emitWarning(
-              path.node,
+              path2.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
               warn,
@@ -30055,12 +30634,12 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         }
       }
     },
-    UpdateExpression(path) {
-      const arg = path.node.argument;
+    UpdateExpression(path2) {
+      const arg = path2.node.argument;
       if (t4.isMemberExpression(arg) || t4.isOptionalMemberExpression(arg)) {
         if (isStateRoot(arg.object)) {
           emitWarning(
-            path.node,
+            path2.node,
             "FICT-M",
             "Direct mutation of nested property detected; use immutable update or $store helpers",
             warn,
@@ -30068,7 +30647,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
           );
           if (isDynamicPropertyAccess(arg, t4)) {
             emitWarning(
-              path.node,
+              path2.node,
               "FICT-H",
               "Dynamic property access widens dependency tracking",
               warn,
@@ -30078,13 +30657,13 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         }
       }
     },
-    MemberExpression(path) {
-      if (!path.node.computed) return;
-      if (path.parentPath.isAssignmentExpression({ left: path.node })) return;
-      if (path.parentPath.isUpdateExpression({ argument: path.node })) return;
-      if (isDynamicPropertyAccess(path.node, t4) && isStateRoot(path.node.object)) {
+    MemberExpression(path2) {
+      if (!path2.node.computed) return;
+      if (path2.parentPath.isAssignmentExpression({ left: path2.node })) return;
+      if (path2.parentPath.isUpdateExpression({ argument: path2.node })) return;
+      if (isDynamicPropertyAccess(path2.node, t4) && isStateRoot(path2.node.object)) {
         emitWarning(
-          path.node,
+          path2.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
           warn,
@@ -30092,12 +30671,12 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         );
       }
     },
-    Function(path) {
+    Function(path2) {
       const captured = /* @__PURE__ */ new Set();
-      path.traverse(
+      path2.traverse(
         {
           Function(inner) {
-            if (inner === path) return;
+            if (inner === path2) return;
             inner.skip();
           },
           Identifier(idPath) {
@@ -30105,7 +30684,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
             if (!reactiveNames.has(name)) return;
             const binding = idPath.scope.getBinding(name);
             if (!binding) return;
-            if (binding.scope === idPath.scope || binding.scope === path.scope) return;
+            if (binding.scope === idPath.scope || binding.scope === path2.scope) return;
             captured.add(name);
           }
         },
@@ -30113,7 +30692,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       );
       if (captured.size > 0) {
         emitWarning(
-          path.node,
+          path2.node,
           "FICT-R005",
           `Function captures reactive variable(s): ${Array.from(captured).join(", ")}. Pass them as parameters or memoize explicitly to avoid hidden dependencies.`,
           warn,
@@ -30121,9 +30700,9 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         );
       }
     },
-    CallExpression(path) {
-      if (t4.isIdentifier(path.node.callee, { name: "$effect" })) {
-        const argPath = path.get("arguments.0");
+    CallExpression(path2) {
+      if (t4.isIdentifier(path2.node.callee, { name: "$effect" })) {
+        const argPath = path2.get("arguments.0");
         if (argPath?.isFunctionExpression() || argPath?.isArrowFunctionExpression()) {
           let hasReactiveDependency = false;
           argPath.traverse({
@@ -30144,7 +30723,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
           });
           if (!hasReactiveDependency) {
             emitWarning(
-              path.node,
+              path2.node,
               "FICT-E001",
               "Effect has no reactive reads; it will run once. Consider removing $effect or adding dependencies.",
               warn,
@@ -30154,7 +30733,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         }
         return;
       }
-      const callee = path.node.callee;
+      const callee = path2.node.callee;
       let calleeName = "";
       if (t4.isIdentifier(callee)) {
         calleeName = callee.name;
@@ -30166,7 +30745,7 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
       }
       const isSafe = calleeName && SAFE_FUNCTIONS.has(calleeName);
       if (isSafe) return;
-      for (const arg of path.node.arguments) {
+      for (const arg of path2.node.arguments) {
         if (!t4.isExpression(arg)) continue;
         if (isStateRoot(arg)) {
           emitWarning(
@@ -30180,13 +30759,13 @@ function runWarningPass(programPath, stateVars, derivedVars, warn, fileName, t4)
         }
       }
     },
-    OptionalMemberExpression(path) {
-      if (!path.node.computed) return;
-      if (path.parentPath.isAssignmentExpression({ left: path.node })) return;
-      if (path.parentPath.isUpdateExpression({ argument: path.node })) return;
-      if (isDynamicPropertyAccess(path.node, t4) && isStateRoot(path.node.object)) {
+    OptionalMemberExpression(path2) {
+      if (!path2.node.computed) return;
+      if (path2.parentPath.isAssignmentExpression({ left: path2.node })) return;
+      if (path2.parentPath.isUpdateExpression({ argument: path2.node })) return;
+      if (isDynamicPropertyAccess(path2.node, t4) && isStateRoot(path2.node.object)) {
         emitWarning(
-          path.node,
+          path2.node,
           "FICT-H",
           "Dynamic property access widens dependency tracking",
           warn,
@@ -30237,14 +30816,17 @@ function createHIREntrypointVisitor(t4, options) {
   };
   return {
     Program: {
-      exit(path) {
-        const fileName = path.hub?.file?.opts?.filename || "<unknown>";
-        const comments = path.hub?.file?.ast?.comments || [];
+      exit(path2) {
+        const fileName = path2.hub?.file?.opts?.filename || "<unknown>";
+        const comments = path2.hub?.file?.ast?.comments || [];
         const suppressions = parseSuppressions(comments);
         const dev = options.dev !== false;
-        const warn = dev ? createWarningDispatcher(options.onWarn, suppressions) : () => {
+        const warn = createWarningDispatcher(options.onWarn, suppressions, options, dev);
+        const optionsWithWarnings = {
+          ...options,
+          onWarn: warn,
+          filename: fileName
         };
-        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() && t4.isIdentifier(fnPath.parentPath.node.id) && fnPath.parentPath.node.init === fnPath.node ? fnPath.parentPath.node.id.name : void 0;
@@ -30345,7 +30927,7 @@ function createHIREntrypointVisitor(t4, options) {
           };
           return checkNode(fn.body);
         };
-        path.traverse({
+        path2.traverse({
           FunctionDeclaration(fnPath) {
             const name = fnPath.node.id?.name;
             if (!isComponentName2(name)) return;
@@ -30382,7 +30964,7 @@ function createHIREntrypointVisitor(t4, options) {
         const stateMacroNames = /* @__PURE__ */ new Set(["$state"]);
         const effectMacroNames = /* @__PURE__ */ new Set(["$effect"]);
         const memoMacroNames = /* @__PURE__ */ new Set(["$memo", "createMemo"]);
-        path.traverse({
+        path2.traverse({
           ImportDeclaration(importPath) {
             if (importPath.node.source.value !== "fict" && importPath.node.source.value !== "fict/slim")
               return;
@@ -30402,7 +30984,7 @@ function createHIREntrypointVisitor(t4, options) {
             }
           }
         });
-        path.traverse({
+        path2.traverse({
           JSXExpressionContainer(exprPath) {
             const expr = exprPath.node.expression;
             if (!t4.isCallExpression(expr)) return;
@@ -30447,7 +31029,7 @@ function createHIREntrypointVisitor(t4, options) {
         const stateVars = /* @__PURE__ */ new Set();
         const derivedVars = /* @__PURE__ */ new Set();
         const destructuredAliases = /* @__PURE__ */ new Set();
-        path.traverse({
+        path2.traverse({
           VariableDeclarator(varPath) {
             const init = varPath.node.init;
             if (!init) return;
@@ -30696,7 +31278,7 @@ or extract the nested logic into a custom hook (useXxx).`
           return usesState;
         };
         debugLog("alias", "state vars", Array.from(stateVars));
-        path.traverse({
+        path2.traverse({
           Function: {
             enter() {
               aliasStack.push(/* @__PURE__ */ new Set());
@@ -30754,7 +31336,7 @@ or extract the nested logic into a custom hook (useXxx).`
           }
         });
         if (derivedVars.size > 0) {
-          path.traverse({
+          path2.traverse({
             AssignmentExpression(assignPath) {
               const { left } = assignPath.node;
               if (t4.isIdentifier(left) && derivedVars.has(left.name)) {
@@ -30775,7 +31357,7 @@ or extract the nested logic into a custom hook (useXxx).`
           });
         }
         if (destructuredAliases.size > 0) {
-          path.traverse({
+          path2.traverse({
             AssignmentExpression(assignPath) {
               const { left } = assignPath.node;
               if (t4.isIdentifier(left) && destructuredAliases.has(left.name)) {
@@ -30803,10 +31385,11 @@ or extract the nested logic into a custom hook (useXxx).`
             }
           });
         }
-        if (dev) {
-          runWarningPass(path, stateVars, derivedVars, warn, fileName, t4);
+        const shouldRunWarnings = dev || hasErrorEscalation(options);
+        if (shouldRunWarnings) {
+          runWarningPass(path2, stateVars, derivedVars, warn, fileName, t4);
         }
-        const fileAst = t4.file(path.node);
+        const fileAst = t4.file(path2.node);
         const hir = buildHIR(
           fileAst,
           {
@@ -30821,19 +31404,20 @@ or extract the nested logic into a custom hook (useXxx).`
         );
         const optimized = optionsWithWarnings.optimize ? optimizeHIR(hir, {
           memoMacroNames,
-          inlineDerivedMemos: optionsWithWarnings.inlineDerivedMemos ?? true
+          inlineDerivedMemos: optionsWithWarnings.inlineDerivedMemos ?? true,
+          optimizeLevel: optionsWithWarnings.optimizeLevel ?? "safe"
         }) : hir;
         const lowered = lowerHIRWithRegions(optimized, t4, optionsWithWarnings, {
           state: stateMacroNames,
           effect: effectMacroNames,
           memo: memoMacroNames
         });
-        path.node.body = lowered.program.body;
-        path.node.directives = lowered.program.directives;
+        path2.node.body = lowered.program.body;
+        path2.node.directives = lowered.program.directives;
         if (!process.env.FICT_SKIP_SCOPE_CRAWL) {
-          path.scope.crawl();
+          path2.scope.crawl();
         }
-        stripMacroImports(path, t4);
+        stripMacroImports(path2, t4);
       }
     }
   };
@@ -30846,6 +31430,7 @@ var createFictPlugin = declare(
       ...options,
       fineGrainedDom: options.fineGrainedDom ?? true,
       optimize: options.optimize ?? true,
+      optimizeLevel: options.optimizeLevel ?? "safe",
       inlineDerivedMemos: options.inlineDerivedMemos ?? true,
       dev: options.dev ?? (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test")
     };
@@ -30857,6 +31442,9 @@ var createFictPlugin = declare(
 );
 var index_default = createFictPlugin;
 export {
+  clearModuleMetadata,
   createFictPlugin,
-  index_default as default
+  index_default as default,
+  resolveModuleMetadata,
+  setModuleMetadata
 };