sinwan-compiler 0.3.1 → 1.0.0

package/dist/chunk-fadpxq9v.js

@@ -1,2428 +0,0 @@
-// @bun
-// src/cli.ts
-import * as path3 from "path";
-
-// src/analyze.ts
-import { parse } from "@babel/parser";
-import * as t3 from "@babel/types";
-import _traverse3 from "@babel/traverse";
-import * as fs from "fs";
-import * as path2 from "path";
-
-// src/reactive-wrap.ts
-import * as t from "@babel/types";
-import _traverse from "@babel/traverse";
-import * as path from "path";
-var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?? _traverse;
-var REACTIVE_SOURCE_MODULES = {
-  "sinwan/store": new Set(["createMutable", "createStore"]),
-  "sinwan/reactivity": new Set(["signal", "computed"]),
-  "sinwan/react": new Set(["useState"]),
-  "sinwan/hook": new Set(["useFetch"])
-};
-var COMPONENT_FACTORY_MODULES = {
-  sinwan: new Set(["cc"]),
-  "sinwan/component": new Set(["cc"])
-};
-var BUILTIN_REACTIVE_PROPS = new Map([
-  ["For", { reactiveProps: new Set(["each"]) }],
-  ["Show", { reactiveProps: new Set(["when"]) }],
-  ["Switch", { reactiveProps: new Set(["when"]) }],
-  ["Match", { reactiveProps: new Set(["when"]) }],
-  ["Index", { reactiveProps: new Set(["each"]) }],
-  ["Key", { reactiveProps: new Set(["when"]) }],
-  ["Dynamic", { reactiveProps: new Set(["component"]) }],
-  ["Visible", { reactiveProps: new Set(["when", "style"]) }],
-  ["Portal", { reactiveProps: new Set(["mount"]) }],
-  ["Virtual", { reactiveProps: new Set(["each"]) }],
-  ["Activity", { reactiveProps: new Set(["mode"]) }]
-]);
-function isBuiltinReactiveProp(componentName, attrName) {
-  const entry = BUILTIN_REACTIVE_PROPS.get(componentName);
-  if (!entry)
-    return false;
-  return entry.reactiveProps.has(attrName);
-}
-function isReactiveContainerPassThrough(expr, scope) {
-  let node = expr;
-  while (t.isTSNonNullExpression(node)) {
-    node = node.expression;
-  }
-  if (!t.isIdentifier(node))
-    return false;
-  const binding = scope.bindings.get(node.name);
-  if (!binding)
-    return false;
-  return binding.kind === "mutable" || binding.kind === "prop";
-}
-function trackReactiveImports2(ast) {
-  const names = {
-    createMutable: new Set,
-    createStore: new Set,
-    signal: new Set,
-    computed: new Set,
-    useState: new Set,
-    useFetch: new Set,
-    cc: new Set
-  };
-  traverse(ast, {
-    ImportDeclaration(path) {
-      const source = path.node.source.value;
-      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
-      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
-      if (!reactiveAllowed && !componentAllowed)
-        return;
-      for (const spec of path.node.specifiers) {
-        if (!t.isImportSpecifier(spec))
-          continue;
-        const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-        if (reactiveAllowed?.has(imported)) {
-          const local = spec.local.name;
-          names[imported].add(local);
-        } else if (componentAllowed?.has(imported)) {
-          names.cc.add(spec.local.name);
-        }
-      }
-    }
-  });
-  return names;
-}
-function isReactiveSourceCall(expr, names) {
-  if (!t.isCallExpression(expr))
-    return null;
-  const callee = expr.callee;
-  if (!t.isIdentifier(callee))
-    return null;
-  if (names.createMutable.has(callee.name)) {
-    return { kind: "mutable", isArray: false };
-  }
-  if (names.createStore.has(callee.name)) {
-    return { kind: "mutable", isArray: true };
-  }
-  if (names.signal.has(callee.name)) {
-    return { kind: "signal", isArray: false };
-  }
-  if (names.computed.has(callee.name)) {
-    return { kind: "computed", isArray: false };
-  }
-  if (names.useState.has(callee.name)) {
-    return { kind: "getter", isArray: true };
-  }
-  return null;
-}
-var USEFETCH_CHAIN_METHODS = new Set([
-  "json",
-  "text",
-  "blob",
-  "arrayBuffer",
-  "formData",
-  "get",
-  "put",
-  "post",
-  "delete",
-  "patch",
-  "head",
-  "options"
-]);
-function isUseFetchCall(expr, names) {
-  if (!t.isCallExpression(expr))
-    return false;
-  const callee = expr.callee;
-  if (t.isIdentifier(callee)) {
-    return names.useFetch.has(callee.name);
-  }
-  if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property) && USEFETCH_CHAIN_METHODS.has(callee.property.name)) {
-    return isUseFetchCall(callee.object, names);
-  }
-  return false;
-}
-function trackLocalScopeBindings(path, names, scope) {
-  path.traverse({
-    VariableDeclarator(p) {
-      const id = p.node.id;
-      const init = p.node.init;
-      if (!init)
-        return;
-      if (t.isIdentifier(id) && t.isCallExpression(init) && t.isIdentifier(init.callee) && (init.callee.name === "_$createLiveRest" || init.callee.name === "createLiveRest")) {
-        scope.bindings.set(id.name, { kind: "prop" });
-        return;
-      }
-      const source = isReactiveSourceCall(init, names);
-      if (source) {
-        if (source.isArray) {
-          if (t.isArrayPattern(id) && id.elements[0]) {
-            const first = id.elements[0];
-            if (t.isIdentifier(first)) {
-              scope.bindings.set(first.name, { kind: source.kind });
-            }
-          }
-          return;
-        }
-        if (t.isIdentifier(id)) {
-          if (source.kind === "mutable") {
-            scope.bindings.set(id.name, {
-              kind: "mutable",
-              root: id.name,
-              path: []
-            });
-          } else {
-            scope.bindings.set(id.name, { kind: source.kind });
-          }
-        }
-        return;
-      }
-      if (isUseFetchCall(init, names)) {
-        if (t.isObjectPattern(id)) {
-          for (const prop of id.properties) {
-            if (t.isObjectProperty(prop) && !prop.computed && t.isIdentifier(prop.value)) {
-              scope.bindings.set(prop.value.name, {
-                kind: "signal"
-              });
-            }
-          }
-        } else if (t.isIdentifier(id)) {
-          scope.bindings.set(id.name, { kind: "signalObject" });
-        }
-        return;
-      }
-    }
-  });
-  path.traverse({
-    VariableDeclarator(p) {
-      const id = p.node.id;
-      const init = p.node.init;
-      if (!init || !t.isIdentifier(init))
-        return;
-      const initBinding = scope.bindings.get(init.name);
-      if (!initBinding || initBinding.kind !== "mutable")
-        return;
-      if (t.isObjectPattern(id)) {
-        for (const prop of id.properties) {
-          if (!t.isObjectProperty(prop))
-            continue;
-          const key = prop.key;
-          const value = prop.value;
-          if (!t.isIdentifier(key) || !t.isIdentifier(value))
-            continue;
-          scope.bindings.set(value.name, {
-            kind: "mutable",
-            root: initBinding.root,
-            path: [...initBinding.path, key.name]
-          });
-        }
-      }
-    }
-  });
-  path.traverse({
-    "FunctionDeclaration|VariableDeclarator"(p) {
-      const node = p.node;
-      let fn = null;
-      let name = null;
-      if (t.isFunctionDeclaration(node)) {
-        fn = node;
-        name = node.id?.name ?? null;
-      } else if (t.isVariableDeclarator(node)) {
-        const init = node.init;
-        if (init && (t.isArrowFunctionExpression(init) || t.isFunctionExpression(init))) {
-          fn = init;
-        }
-        if (t.isIdentifier(node.id)) {
-          name = node.id.name;
-        }
-      }
-      if (!fn || !name || scope.bindings.has(name))
-        return;
-      const body = fn.body;
-      if (body && containsReactiveRead(body, scope)) {
-        scope.bindings.set(name, { kind: "getter" });
-      } else {
-        scope.bindings.set(name, { kind: "function" });
-      }
-    }
-  });
-}
-function trackPropBindings(scope, params, reactiveProps) {
-  if (!params || reactiveProps.size === 0)
-    return;
-  if (t.isIdentifier(params)) {
-    scope.bindings.set(params.name, { kind: "prop" });
-  } else if (t.isObjectPattern(params)) {
-    for (const prop of params.properties) {
-      if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-        const key = prop.key;
-        if (t.isIdentifier(key) && reactiveProps.has(key.name)) {
-          scope.bindings.set(prop.value.name, { kind: "prop" });
-        }
-      }
-    }
-  }
-}
-function getAllPropNames2(params) {
-  if (!params)
-    return new Set;
-  if (t.isIdentifier(params))
-    return new Set(["*"]);
-  if (t.isObjectPattern(params)) {
-    const names = new Set;
-    for (const prop of params.properties) {
-      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
-        names.add(prop.key.name);
-      }
-    }
-    names.add("children");
-    return names;
-  }
-  return new Set;
-}
-function resolveLocalObjectLiteral(fn, name) {
-  const body = fn.body;
-  if (!t.isBlockStatement(body))
-    return null;
-  for (const stmt of body.body) {
-    if (!t.isVariableDeclaration(stmt))
-      continue;
-    for (const decl of stmt.declarations) {
-      if (!t.isIdentifier(decl.id) || decl.id.name !== name)
-        continue;
-      const init = decl.init;
-      if (!t.isObjectExpression(init))
-        continue;
-      return init;
-    }
-  }
-  return null;
-}
-function analyzeObjectLiteralSpread(spread, fullScope, calleeReactive) {
-  for (const prop of spread.properties) {
-    if (t.isObjectProperty(prop) && !prop.computed) {
-      const key = prop.key;
-      const name = t.isIdentifier(key) ? key.name : t.isStringLiteral(key) ? key.value : null;
-      if (name && containsReactiveValue2(prop.value, fullScope)) {
-        calleeReactive.add(name);
-      }
-    }
-  }
-}
-function isMemberLike(node) {
-  return t.isMemberExpression(node) || t.isOptionalMemberExpression(node);
-}
-function isFunctionLike(node) {
-  return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
-}
-function isCallLike(node) {
-  return t.isCallExpression(node) || t.isOptionalCallExpression(node);
-}
-var COMPILER_BINDING_CALLEES = new Set([
-  "_$bindText",
-  "_$bindAttr",
-  "_$bindStyle",
-  "_$bindClass",
-  "_$unwrap"
-]);
-function isCompilerBindingCall(node) {
-  const callee = node.callee;
-  return t.isIdentifier(callee) && COMPILER_BINDING_CALLEES.has(callee.name);
-}
-function visitCallCalleeAndArgs(node, visitExpr) {
-  if (isCompilerBindingCall(node))
-    return;
-  visitExpr(node.callee, true);
-  for (const arg of node.arguments) {
-    if (t.isSpreadElement(arg)) {
-      visitExpr(arg.argument, true);
-      continue;
-    }
-    visitExpr(arg, true);
-  }
-}
-function isSignalValuePath(path) {
-  return path[0] === "value" || path.length >= 2 && path[1] === "value";
-}
-function getMemberExpressionRootAndPath(node) {
-  const path = [];
-  let current = node;
-  while (true) {
-    if (t.isTSNonNullExpression(current)) {
-      current = current.expression;
-      continue;
-    }
-    if (isMemberLike(current)) {
-      if (current.computed)
-        return null;
-      if (!t.isIdentifier(current.property))
-        return null;
-      path.push(current.property.name);
-      current = current.object;
-      continue;
-    }
-    break;
-  }
-  if (t.isIdentifier(current)) {
-    return { root: current.name, path: path.reverse() };
-  }
-  return null;
-}
-function isReactiveRead(node, scope) {
-  if (t.isTSNonNullExpression(node)) {
-    return isReactiveRead(node.expression, scope);
-  }
-  if (t.isIdentifier(node)) {
-    const binding = scope.bindings.get(node.name);
-    if (!binding)
-      return false;
-    if (binding.kind === "prop") {
-      return true;
-    }
-    if (binding.kind === "mutable" && binding.path.length > 0) {
-      return true;
-    }
-    return false;
-  }
-  if (!isMemberLike(node))
-    return false;
-  const rootPath = getMemberExpressionRootAndPath(node);
-  if (!rootPath)
-    return false;
-  const binding = scope.bindings.get(rootPath.root);
-  if (!binding) {
-    return isSignalValuePath(rootPath.path);
-  }
-  if (binding.kind === "prop") {
-    return true;
-  }
-  if (binding.kind === "mutable") {
-    return true;
-  }
-  if (binding.kind === "signal" || binding.kind === "computed") {
-    return rootPath.path[0] === "value";
-  }
-  if (binding.kind === "signalObject") {
-    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
-  }
-  return false;
-}
-function isGetterCall(node, scope) {
-  const callee = node.callee;
-  if (t.isIdentifier(callee)) {
-    const binding = scope.bindings.get(callee.name);
-    if (binding?.kind === "getter")
-      return true;
-    if (binding)
-      return false;
-    return node.arguments.length === 0;
-  }
-  if (isMemberLike(callee) && !callee.computed && t.isIdentifier(callee.property)) {
-    if (node.arguments.length !== 0)
-      return false;
-    const rootPath = getMemberExpressionRootAndPath(callee);
-    if (!rootPath)
-      return false;
-    const binding = scope.bindings.get(rootPath.root);
-    if (binding?.kind === "mutable" || binding?.kind === "function" || binding?.kind === "signal" || binding?.kind === "computed" || binding?.kind === "prop" || binding?.kind === "getter" || binding?.kind === "signalObject") {
-      return false;
-    }
-    return true;
-  }
-  return false;
-}
-function isReactiveValue2(node, scope) {
-  if (t.isTSNonNullExpression(node)) {
-    return isReactiveValue2(node.expression, scope);
-  }
-  if (t.isIdentifier(node)) {
-    const binding = scope.bindings.get(node.name);
-    if (!binding)
-      return false;
-    return binding.kind === "prop" || binding.kind === "signal" || binding.kind === "computed" || binding.kind === "mutable";
-  }
-  if (!isMemberLike(node))
-    return false;
-  const rootPath = getMemberExpressionRootAndPath(node);
-  if (!rootPath)
-    return false;
-  const binding = scope.bindings.get(rootPath.root);
-  if (!binding) {
-    return isSignalValuePath(rootPath.path);
-  }
-  if (binding.kind === "prop" || binding.kind === "mutable") {
-    return true;
-  }
-  if (binding.kind === "signal" || binding.kind === "computed") {
-    return rootPath.path[0] === "value";
-  }
-  if (binding.kind === "signalObject") {
-    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
-  }
-  return false;
-}
-function containsReactiveValue2(expr, scope) {
-  let found = false;
-  function visit(node) {
-    if (found)
-      return;
-    if (!node || typeof node !== "object")
-      return;
-    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
-      if (isReactiveValue2(node, scope)) {
-        found = true;
-        return;
-      }
-    }
-    if (isCallLike(node) && isGetterCall(node, scope)) {
-      found = true;
-      return;
-    }
-    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)) {
-      return;
-    }
-    for (const key of Object.keys(node)) {
-      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
-        continue;
-      const value = node[key];
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item && typeof item === "object")
-            visit(item);
-        }
-      } else if (value && typeof value === "object") {
-        visit(value);
-      }
-    }
-  }
-  visit(expr);
-  return found;
-}
-function containsReactiveRead(expr, scope) {
-  let found = false;
-  function visit(node, enterFunction) {
-    if (found)
-      return;
-    if (!node || typeof node !== "object")
-      return;
-    if (isFunctionLike(node)) {
-      if (!enterFunction)
-        return;
-      for (const param of node.params) {
-        visit(param, false);
-      }
-      visit(node.body, false);
-      return;
-    }
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-      return;
-    }
-    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
-      if (isReactiveRead(node, scope)) {
-        found = true;
-        return;
-      }
-    }
-    if (isCallLike(node) && isGetterCall(node, scope)) {
-      found = true;
-      return;
-    }
-    if (isCallLike(node)) {
-      visitCallCalleeAndArgs(node, visit);
-      return;
-    }
-    for (const key of Object.keys(node)) {
-      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
-        continue;
-      const value = node[key];
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item && typeof item === "object")
-            visit(item, false);
-        }
-      } else if (value && typeof value === "object") {
-        visit(value, false);
-      }
-    }
-  }
-  visit(expr, false);
-  return found;
-}
-function getComponentExpressionInfo(exprPath) {
-  const parent = exprPath.parentPath;
-  if (!parent) {
-    return { isComponent: false, componentName: null, attributeName: null };
-  }
-  let elementPath = null;
-  let attributeName = null;
-  if (parent.isJSXAttribute && parent.isJSXAttribute()) {
-    const attrName = parent.node.name;
-    if (t.isJSXIdentifier(attrName)) {
-      attributeName = attrName.name;
-    }
-    const openingElementPath = parent.parentPath;
-    elementPath = openingElementPath?.parentPath;
-  } else if (parent.isJSXElement && parent.isJSXElement()) {
-    elementPath = parent;
-  }
-  if (!elementPath || !elementPath.isJSXElement || !elementPath.isJSXElement()) {
-    return { isComponent: false, componentName: null, attributeName: null };
-  }
-  const name = elementPath.node.openingElement.name;
-  let firstChar = null;
-  let componentName = null;
-  if (t.isJSXIdentifier(name)) {
-    componentName = name.name;
-    firstChar = name.name?.[0] ?? null;
-  } else if (t.isJSXMemberExpression(name)) {
-    let current = name;
-    while (t.isJSXMemberExpression(current)) {
-      current = current.object;
-    }
-    if (t.isJSXIdentifier(current)) {
-      componentName = current.name;
-      firstChar = current.name?.[0] ?? null;
-    }
-  }
-  if (!firstChar || firstChar !== firstChar.toUpperCase() || !/[A-Z]/.test(firstChar)) {
-    return { isComponent: false, componentName: null, attributeName };
-  }
-  return { isComponent: true, componentName, attributeName };
-}
-function isReactiveComponentProp(componentName, attributeName, componentNames, reactiveProps, importedReactiveProps) {
-  if (isBuiltinReactiveProp(componentName, attributeName)) {
-    return true;
-  }
-  const componentFn = componentNames.get(componentName);
-  if (componentFn) {
-    const props = reactiveProps.get(componentFn);
-    if (!props)
-      return false;
-    return props.has(attributeName);
-  }
-  const importedProps = importedReactiveProps.get(componentName);
-  if (!importedProps)
-    return false;
-  return importedProps.has(attributeName);
-}
-function shouldWrap(expr, scope) {
-  if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr))
-    return false;
-  if (t.isJSXEmptyExpression(expr))
-    return false;
-  return containsReactiveRead(expr, scope);
-}
-var RESOLVE_HELPER = "_$unwrap";
-function transformPropMemberAccess(expr, scope) {
-  let changed = false;
-  function resolveRoot(rootName) {
-    return t.callExpression(t.identifier(RESOLVE_HELPER), [
-      t.identifier(rootName)
-    ]);
-  }
-  function replaceMemberRoot(node, rootName) {
-    let current = node;
-    let parent = null;
-    while (true) {
-      if (t.isTSNonNullExpression(current)) {
-        current = current.expression;
-        continue;
-      }
-      if (!isMemberLike(current))
-        break;
-      parent = current;
-      current = current.object;
-    }
-    if (parent && t.isIdentifier(current) && current.name === rootName) {
-      parent.object = resolveRoot(rootName);
-    }
-  }
-  function visit(node, enterFunction) {
-    if (!node || typeof node !== "object")
-      return;
-    if (isFunctionLike(node)) {
-      if (!enterFunction)
-        return;
-      for (const param of node.params) {
-        visit(param, false);
-      }
-      visit(node.body, false);
-      return;
-    }
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-      return;
-    }
-    if (isMemberLike(node)) {
-      const rootPath = getMemberExpressionRootAndPath(node);
-      if (rootPath) {
-        const binding = scope.bindings.get(rootPath.root);
-        if (binding && binding.kind === "prop") {
-          replaceMemberRoot(node, rootPath.root);
-          changed = true;
-          return;
-        }
-      }
-      return;
-    }
-    if (isCallLike(node)) {
-      visitCallCalleeAndArgs(node, visit);
-      return;
-    }
-    for (const key of Object.keys(node)) {
-      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
-        continue;
-      const value = node[key];
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item && typeof item === "object")
-            visit(item, false);
-        }
-      } else if (value && typeof value === "object") {
-        visit(value, false);
-      }
-    }
-  }
-  visit(expr, false);
-  return changed;
-}
-function wrapExpression(expr) {
-  return t.arrowFunctionExpression([], expr);
-}
-function isPropRoot(expr, scope) {
-  if (t.isIdentifier(expr)) {
-    return scope.bindings.get(expr.name)?.kind === "prop";
-  }
-  if (t.isCallExpression(expr) && t.isIdentifier(expr.callee, { name: "_$unwrap" }) && expr.arguments.length === 1 && t.isIdentifier(expr.arguments[0])) {
-    return scope.bindings.get(expr.arguments[0].name)?.kind === "prop";
-  }
-  return false;
-}
-function isChildrenPropRead(expr, scope) {
-  if (t.isIdentifier(expr, { name: "children" }))
-    return true;
-  if (!isMemberLike(expr) || expr.computed)
-    return false;
-  if (!t.isIdentifier(expr.property, { name: "children" }))
-    return false;
-  return isPropRoot(expr.object, scope);
-}
-function createBindingDescriptor(expr, exprPath, options, scope, childrenGetter) {
-  if (!options.explicitBindings) {
-    return wrapExpression(expr);
-  }
-  const parent = exprPath.parentPath;
-  if (parent && parent.isJSXAttribute && parent.isJSXAttribute()) {
-    const compInfo = getComponentExpressionInfo(exprPath);
-    if (compInfo.isComponent) {
-      return wrapExpression(expr);
-    }
-    const attrName = parent.node.name.name;
-    if (attrName === "style") {
-      return t.callExpression(t.identifier("_$bindStyle"), [
-        wrapExpression(expr)
-      ]);
-    }
-    if (attrName === "class") {
-      return t.callExpression(t.identifier("_$bindClass"), [
-        wrapExpression(expr)
-      ]);
-    }
-    return t.callExpression(t.identifier("_$bindAttr"), [
-      t.stringLiteral(attrName),
-      wrapExpression(expr)
-    ]);
-  }
-  const compInfo = getComponentExpressionInfo(exprPath);
-  if (isChildrenPropRead(expr, scope) || childrenGetter || compInfo.isComponent && compInfo.attributeName === null) {
-    return wrapExpression(expr);
-  }
-  return t.callExpression(t.identifier("_$bindText"), [wrapExpression(expr)]);
-}
-function collectComponentFunctions2(ast, ccNames) {
-  const functions = new Set;
-  const names = new Map;
-  const exported = new Set;
-  if (ccNames.size === 0)
-    return { functions, names, exported };
-  traverse(ast, {
-    CallExpression(path) {
-      const callee = path.node.callee;
-      if (!t.isIdentifier(callee) || !ccNames.has(callee.name))
-        return;
-      const firstArg = path.node.arguments[0];
-      if (!firstArg || !t.isFunction(firstArg))
-        return;
-      const componentFn = firstArg;
-      functions.add(componentFn);
-      const parent = path.parentPath;
-      if (parent && parent.isVariableDeclarator && parent.isVariableDeclarator()) {
-        const id = parent.node.id;
-        if (t.isIdentifier(id)) {
-          names.set(id.name, componentFn);
-        }
-      }
-    }
-  });
-  traverse(ast, {
-    ExportNamedDeclaration(path) {
-      const declaration = path.node.declaration;
-      if (!t.isVariableDeclaration(declaration))
-        return;
-      for (const decl of declaration.declarations) {
-        const init = decl.init;
-        if (!init || !t.isCallExpression(init))
-          continue;
-        const callee = init.callee;
-        if (!t.isIdentifier(callee) || !ccNames.has(callee.name))
-          continue;
-        const firstArg = init.arguments[0];
-        if (!firstArg || !t.isFunction(firstArg))
-          continue;
-        exported.add(firstArg);
-      }
-    },
-    ExportDefaultDeclaration(path) {
-      const decl = path.node.declaration;
-      if (t.isIdentifier(decl)) {
-        const componentFn = names.get(decl.name);
-        if (componentFn) {
-          exported.add(componentFn);
-        }
-      } else if (t.isCallExpression(decl)) {
-        const callee = decl.callee;
-        if (t.isIdentifier(callee) && ccNames.has(callee.name)) {
-          const firstArg = decl.arguments[0];
-          if (firstArg && t.isFunction(firstArg)) {
-            exported.add(firstArg);
-          }
-        }
-      }
-    }
-  });
-  return { functions, names, exported };
-}
-function computeLocalScopes2(ast, names) {
-  const scopes = new Map;
-  traverse(ast, {
-    Function(path) {
-      const scope = { bindings: new Map };
-      trackLocalScopeBindings(path, names, scope);
-      scopes.set(path.node, scope);
-    }
-  });
-  return scopes;
-}
-function collectComponentCallGraph2(ast, componentNames) {
-  const callGraph = new Map;
-  if (componentNames.size === 0)
-    return callGraph;
-  traverse(ast, {
-    JSXElement(path) {
-      const name = path.node.openingElement.name;
-      if (!t.isJSXIdentifier(name))
-        return;
-      const callee = componentNames.get(name.name);
-      if (!callee)
-        return;
-      const callerPath = path.findParent((p) => p.isFunction());
-      const callerFn = callerPath ? callerPath.node : null;
-      if (!callerFn)
-        return;
-      const props = [];
-      const spreads = [];
-      for (const attr of path.node.openingElement.attributes) {
-        if (t.isJSXSpreadAttribute(attr)) {
-          if (attr.argument) {
-            spreads.push(attr.argument);
-          }
-          continue;
-        }
-        if (t.isJSXAttribute(attr)) {
-          const attrName = attr.name.name;
-          if (!attrName)
-            continue;
-          if (t.isJSXExpressionContainer(attr.value)) {
-            const expr = attr.value.expression;
-            if (!expr || t.isJSXEmptyExpression(expr))
-              continue;
-            props.push({ name: attrName, value: expr });
-          }
-        }
-      }
-      const childExprs = [];
-      for (const child of path.node.children) {
-        if (t.isJSXExpressionContainer(child)) {
-          const expr = child.expression;
-          if (!expr || t.isJSXEmptyExpression(expr))
-            continue;
-          childExprs.push(expr);
-        }
-      }
-      if (childExprs.length === 1) {
-        props.push({ name: "children", value: childExprs[0] });
-      } else if (childExprs.length > 1) {
-        props.push({ name: "children", value: t.arrayExpression(childExprs) });
-      }
-      const sites = callGraph.get(callerFn) ?? [];
-      sites.push({ callee, props, spreads });
-      callGraph.set(callerFn, sites);
-    }
-  });
-  return callGraph;
-}
-function buildFullScope2(localScopes, fn, reactiveProps) {
-  const localScope = localScopes.get(fn);
-  if (!localScope)
-    return null;
-  const fullScope = { bindings: new Map(localScope.bindings) };
-  trackPropBindings(fullScope, fn.params[0], reactiveProps);
-  return fullScope;
-}
-function propagateReactiveProps2(localScopes, callGraph, componentFunctions) {
-  const reactiveProps = new Map;
-  for (const [callerFn, sites] of callGraph) {
-    const localScope = localScopes.get(callerFn);
-    if (!localScope)
-      continue;
-    for (const site of sites) {
-      const calleeReactive = reactiveProps.get(site.callee) ?? new Set;
-      for (const prop of site.props) {
-        if (containsReactiveValue2(prop.value, localScope)) {
-          calleeReactive.add(prop.name);
-        }
-      }
-      reactiveProps.set(site.callee, calleeReactive);
-    }
-  }
-  const worklist = new Set(componentFunctions);
-  while (worklist.size > 0) {
-    const callerFn = worklist.values().next().value;
-    worklist.delete(callerFn);
-    const callerReactive = reactiveProps.get(callerFn) ?? new Set;
-    const fullScope = buildFullScope2(localScopes, callerFn, callerReactive);
-    if (!fullScope)
-      continue;
-    const sites = callGraph.get(callerFn) ?? [];
-    for (const site of sites) {
-      const calleeReactive = reactiveProps.get(site.callee) ?? new Set;
-      const initialSize = calleeReactive.size;
-      for (const prop of site.props) {
-        if (containsReactiveValue2(prop.value, fullScope)) {
-          calleeReactive.add(prop.name);
-        }
-      }
-      for (const spread of site.spreads) {
-        const resolved = t.isObjectExpression(spread) ? spread : t.isIdentifier(spread) ? resolveLocalObjectLiteral(callerFn, spread.name) : null;
-        if (resolved) {
-          analyzeObjectLiteralSpread(resolved, fullScope, calleeReactive);
-        } else {
-          const allCalleeProps = getAllPropNames2(site.callee.params[0]);
-          for (const propName of allCalleeProps) {
-            calleeReactive.add(propName);
-          }
-        }
-      }
-      if (calleeReactive.size > initialSize) {
-        reactiveProps.set(site.callee, calleeReactive);
-        worklist.add(site.callee);
-      }
-    }
-  }
-  return reactiveProps;
-}
-function wrapReactiveExpressions2(ast, options = {}) {
-  let metadata = null;
-  if (options.analyzeMetadata) {
-    metadata = options.analyzeMetadata;
-  } else if (options.analyze && options.filename) {
-    try {
-      metadata = loadMetadata2(options.analyze);
-    } catch {
-      metadata = null;
-    }
-  }
-  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
-  const resolveImport = options.resolveImport;
-  const names = {
-    createMutable: new Set,
-    createStore: new Set,
-    signal: new Set,
-    computed: new Set,
-    useState: new Set,
-    useFetch: new Set,
-    cc: new Set
-  };
-  const componentFunctions = new Set;
-  const componentNames = new Map;
-  const exported = new Set;
-  const localScopes = new Map;
-  const callGraph = new Map;
-  const rawCallGraph = new Map;
-  const importedReactiveProps = new Map;
-  const exportNameByFn = new Map;
-  let hasUnwrapImport = false;
-  traverse(ast, {
-    ImportDeclaration(p) {
-      const source = p.node.source.value;
-      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
-      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
-      if (reactiveAllowed || componentAllowed) {
-        for (const spec of p.node.specifiers) {
-          if (!t.isImportSpecifier(spec))
-            continue;
-          const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-          if (reactiveAllowed?.has(imported)) {
-            names[imported].add(spec.local.name);
-          } else if (componentAllowed?.has(imported)) {
-            names.cc.add(spec.local.name);
-          }
-        }
-      }
-      if (source === "sinwan/reactivity") {
-        for (const spec of p.node.specifiers) {
-          if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported) && spec.imported.name === "unwrap" && spec.local.name === RESOLVE_HELPER) {
-            hasUnwrapImport = true;
-          }
-        }
-      }
-      if (metadata && absoluteFilename && resolveImport && source.startsWith(".")) {
-        const resolved = resolveImport(source, absoluteFilename);
-        if (resolved) {
-          const fileProps = metadata.get(resolved);
-          if (fileProps) {
-            for (const spec of p.node.specifiers) {
-              if (!t.isImportSpecifier(spec))
-                continue;
-              const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-              if (!imported || !/^[A-Z]/.test(imported))
-                continue;
-              const props = fileProps.get(imported);
-              if (props && props.size > 0) {
-                importedReactiveProps.set(spec.local.name, new Set(props));
-              }
-            }
-          }
-        }
-      }
-    },
-    CallExpression(p) {
-      const callee = p.node.callee;
-      if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
-        return;
-      const firstArg = p.node.arguments[0];
-      if (!firstArg || !t.isFunction(firstArg))
-        return;
-      const componentFn = firstArg;
-      componentFunctions.add(componentFn);
-      const parent = p.parentPath;
-      if (parent && parent.isVariableDeclarator && parent.isVariableDeclarator()) {
-        const id = parent.node.id;
-        if (t.isIdentifier(id)) {
-          componentNames.set(id.name, componentFn);
-        }
-      }
-    },
-    ExportNamedDeclaration(p) {
-      const declaration = p.node.declaration;
-      if (!t.isVariableDeclaration(declaration))
-        return;
-      for (const decl of declaration.declarations) {
-        const init = decl.init;
-        if (!init || !t.isCallExpression(init))
-          continue;
-        const callee = init.callee;
-        if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
-          continue;
-        const firstArg = init.arguments[0];
-        if (!firstArg || !t.isFunction(firstArg))
-          continue;
-        exported.add(firstArg);
-      }
-    },
-    ExportDefaultDeclaration(p) {
-      const decl = p.node.declaration;
-      if (t.isIdentifier(decl)) {
-        const fn = componentNames.get(decl.name);
-        if (fn) {
-          exported.add(fn);
-          exportNameByFn.set(fn, "default");
-        }
-      } else if (t.isCallExpression(decl)) {
-        const callee = decl.callee;
-        if (t.isIdentifier(callee) && names.cc.has(callee.name)) {
-          const firstArg = decl.arguments[0];
-          if (firstArg && t.isFunction(firstArg)) {
-            exported.add(firstArg);
-            exportNameByFn.set(firstArg, "default");
-          }
-        }
-      }
-    },
-    Function(p) {
-      const scope = { bindings: new Map };
-      trackLocalScopeBindings(p, names, scope);
-      localScopes.set(p.node, scope);
-    },
-    JSXElement(p) {
-      const name = p.node.openingElement.name;
-      if (!t.isJSXIdentifier(name))
-        return;
-      const callerPath = p.findParent((pp) => pp.isFunction());
-      const callerFn = callerPath ? callerPath.node : null;
-      if (!callerFn)
-        return;
-      const props = [];
-      const spreads = [];
-      for (const attr of p.node.openingElement.attributes) {
-        if (t.isJSXSpreadAttribute(attr)) {
-          if (attr.argument) {
-            spreads.push(attr.argument);
-          }
-          continue;
-        }
-        if (t.isJSXAttribute(attr)) {
-          const attrName = attr.name.name;
-          if (!attrName)
-            continue;
-          if (t.isJSXExpressionContainer(attr.value)) {
-            const expr = attr.value.expression;
-            if (!expr || t.isJSXEmptyExpression(expr))
-              continue;
-            props.push({ name: attrName, value: expr });
-          }
-        }
-      }
-      const childExprs = [];
-      for (const child of p.node.children) {
-        if (t.isJSXExpressionContainer(child)) {
-          const expr = child.expression;
-          if (!expr || t.isJSXEmptyExpression(expr))
-            continue;
-          childExprs.push(expr);
-        }
-      }
-      if (childExprs.length === 1) {
-        props.push({ name: "children", value: childExprs[0] });
-      } else if (childExprs.length > 1) {
-        props.push({ name: "children", value: t.arrayExpression(childExprs) });
-      }
-      const sites = rawCallGraph.get(callerFn) ?? [];
-      sites.push({ calleeName: name.name, props, spreads });
-      rawCallGraph.set(callerFn, sites);
-    }
-  });
-  for (const [callerFn, sites] of rawCallGraph) {
-    const resolved = [];
-    for (const site of sites) {
-      const callee = componentNames.get(site.calleeName);
-      if (callee) {
-        resolved.push({ callee, props: site.props, spreads: site.spreads });
-      }
-    }
-    if (resolved.length > 0) {
-      callGraph.set(callerFn, resolved);
-    }
-  }
-  for (const [localName, fn] of componentNames) {
-    if (exported.has(fn)) {
-      if (!exportNameByFn.has(fn)) {
-        exportNameByFn.set(fn, localName);
-      }
-    }
-  }
-  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
-  if (!hasAnyImport)
-    return;
-  const reactiveProps = propagateReactiveProps2(localScopes, callGraph, componentFunctions);
-  let needsResolve = false;
-  traverse(ast, {
-    Function(path) {
-      const scope = localScopes.get(path.node);
-      if (!scope)
-        return;
-      const isComponent = componentFunctions.has(path.node);
-      if (isComponent) {
-        const isExported = exported.has(path.node);
-        if (isExported) {
-          let props = null;
-          if (metadata && absoluteFilename) {
-            const fileProps = metadata.get(absoluteFilename);
-            const exportName = exportNameByFn.get(path.node);
-            if (fileProps && exportName) {
-              props = fileProps.get(exportName) ?? null;
-            }
-          }
-          if (props) {
-            trackPropBindings(scope, path.node.params[0], props);
-          } else {
-            const allProps = getAllPropNames2(path.node.params[0]);
-            trackPropBindings(scope, path.node.params[0], allProps);
-          }
-        } else if (reactiveProps.has(path.node)) {
-          const props = reactiveProps.get(path.node);
-          trackPropBindings(scope, path.node.params[0], props);
-        } else {
-          const allProps = getAllPropNames2(path.node.params[0]);
-          trackPropBindings(scope, path.node.params[0], allProps);
-        }
-      }
-      path.traverse({
-        JSXExpressionContainer(exprPath) {
-          const expr = exprPath.node.expression;
-          const compInfo = getComponentExpressionInfo(exprPath);
-          if (compInfo.attributeName?.startsWith("on")) {
-            return;
-          }
-          if (compInfo.isComponent && compInfo.attributeName !== null) {
-            const knownProp = !!compInfo.componentName && isReactiveComponentProp(compInfo.componentName, compInfo.attributeName, componentNames, reactiveProps, importedReactiveProps);
-            if (!knownProp && (!shouldWrap(expr, scope) || isReactiveContainerPassThrough(expr, scope))) {
-              return;
-            }
-          }
-          if (shouldWrap(expr, scope)) {
-            const childrenGetter = isChildrenPropRead(expr, scope);
-            if (transformPropMemberAccess(expr, scope)) {
-              needsResolve = true;
-            }
-            exprPath.replaceWith(t.jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options, scope, childrenGetter)));
-          }
-        }
-      });
-    }
-  });
-  if (needsResolve && !hasUnwrapImport) {
-    ast.program.body.unshift(t.importDeclaration([
-      t.importSpecifier(t.identifier(RESOLVE_HELPER), t.identifier("unwrap"))
-    ], t.stringLiteral("sinwan/reactivity")));
-  }
-}
-
-// src/auto-cc.ts
-import * as t2 from "@babel/types";
-import _traverse2 from "@babel/traverse";
-var traverse2 = typeof _traverse2 === "function" ? _traverse2 : _traverse2.default ?? _traverse2;
-var CC_SOURCE_MODULES = new Set(["sinwan", "sinwan/component"]);
-var EXCLUDE_KEYS = new Set([
-  "loc",
-  "start",
-  "end",
-  "type",
-  "leadingComments",
-  "trailingComments",
-  "innerComments",
-  "extra"
-]);
-function isComponentName(name) {
-  return !!name && /^[A-Z]/.test(name);
-}
-function containsJsx(node, enterFunctions) {
-  if (!node || typeof node !== "object")
-    return false;
-  if (t2.isJSXElement(node) || t2.isJSXFragment(node))
-    return true;
-  if (!enterFunctions && (t2.isFunctionExpression(node) || t2.isArrowFunctionExpression(node) || t2.isFunctionDeclaration(node))) {
-    return false;
-  }
-  for (const key of Object.keys(node)) {
-    if (EXCLUDE_KEYS.has(key))
-      continue;
-    const val = node[key];
-    if (Array.isArray(val)) {
-      const foundInArray = val.some((item) => Boolean(item) && typeof item === "object" && containsJsx(item, enterFunctions));
-      if (foundInArray)
-        return true;
-    } else if (val && typeof val === "object" && containsJsx(val, enterFunctions)) {
-      return true;
-    }
-  }
-  return false;
-}
-function functionReturnsJsx(fnPath) {
-  const fn = fnPath.node;
-  if (t2.isArrowFunctionExpression(fn) && !t2.isBlockStatement(fn.body)) {
-    return containsJsx(fn.body, false);
-  }
-  let found = false;
-  fnPath.traverse({
-    ReturnStatement(p) {
-      if (p.node.argument && containsJsx(p.node.argument, false)) {
-        found = true;
-        p.stop();
-      }
-    },
-    Function(p) {
-      p.skip();
-    }
-  });
-  return found;
-}
-function isComponentArity(fn) {
-  if (t2.isFunctionDeclaration(fn) && fn.generator)
-    return false;
-  if ((t2.isFunctionExpression(fn) || t2.isArrowFunctionExpression(fn)) && fn.generator) {
-    return false;
-  }
-  return fn.params.length <= 1;
-}
-function collectCcAliases(ast) {
-  const aliases = new Set;
-  traverse2(ast, {
-    ImportDeclaration(path) {
-      const source = path.node.source.value;
-      if (!CC_SOURCE_MODULES.has(source))
-        return;
-      for (const spec of path.node.specifiers) {
-        if (!t2.isImportSpecifier(spec))
-          continue;
-        const imported = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-        if (imported === "cc") {
-          aliases.add(spec.local.name);
-        }
-      }
-    }
-  });
-  return { aliases, alreadyImported: aliases.size > 0 };
-}
-function ccCall(arg, ccName) {
-  return t2.callExpression(t2.identifier(ccName), [arg]);
-}
-function autoWrapComponents2(ast, filename) {
-  const { aliases, alreadyImported } = collectCcAliases(ast);
-  const ccName = aliases.values().next().value;
-  let changed = false;
-  const wrapIfCandidate = (fnPath, name) => {
-    if (name !== null && !isComponentName(name))
-      return false;
-    const fn = fnPath.node;
-    if (!isComponentArity(fn))
-      return false;
-    if (!functionReturnsJsx(fnPath))
-      return false;
-    return true;
-  };
-  traverse2(ast, {
-    ExportNamedDeclaration(path) {
-      const decl = path.node.declaration;
-      if (!decl)
-        return;
-      if (t2.isFunctionDeclaration(decl) && decl.id) {
-        const name = decl.id.name;
-        const fnPath = path.get("declaration");
-        if (!wrapIfCandidate(fnPath, name))
-          return;
-        const fnExpr = t2.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
-        const varDecl = t2.variableDeclaration("const", [
-          t2.variableDeclarator(t2.identifier(name), ccCall(fnExpr, ccName ?? "cc"))
-        ]);
-        path.replaceWith(t2.exportNamedDeclaration(varDecl, []));
-        changed = true;
-        return;
-      }
-      if (t2.isVariableDeclaration(decl)) {
-        for (const dPath of path.get("declaration.declarations")) {
-          const id = dPath.node.id;
-          if (!t2.isIdentifier(id) || !isComponentName(id.name))
-            continue;
-          const init = dPath.node.init;
-          if (!init)
-            continue;
-          if (t2.isCallExpression(init) && t2.isIdentifier(init.callee) && aliases.has(init.callee.name)) {
-            continue;
-          }
-          if (!t2.isFunction(init))
-            continue;
-          const initPath = dPath.get("init");
-          if (!wrapIfCandidate(initPath, id.name))
-            continue;
-          dPath.node.init = ccCall(init, ccName ?? "cc");
-          changed = true;
-        }
-        return;
-      }
-    },
-    ExportDefaultDeclaration(path) {
-      const decl = path.node.declaration;
-      if (t2.isFunctionDeclaration(decl) && decl.id) {
-        const name = decl.id.name;
-        const fnPath = path.get("declaration");
-        if (!wrapIfCandidate(fnPath, name))
-          return;
-        const fnDecl = t2.functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async);
-        const exportDefault = t2.exportDefaultDeclaration(ccCall(t2.identifier(name), ccName ?? "cc"));
-        path.replaceWithMultiple([fnDecl, exportDefault]);
-        changed = true;
-        return;
-      }
-      if (t2.isFunctionDeclaration(decl) && !decl.id) {
-        const fnPath = path.get("declaration");
-        if (!wrapIfCandidate(fnPath, null))
-          return;
-        const fnExpr = t2.functionExpression(null, decl.params, decl.body, decl.generator, decl.async);
-        path.node.declaration = ccCall(fnExpr, ccName ?? "cc");
-        changed = true;
-        return;
-      }
-      if (t2.isArrowFunctionExpression(decl) || t2.isFunctionExpression(decl)) {
-        const declPath = path.get("declaration");
-        if (!wrapIfCandidate(declPath, null))
-          return;
-        path.node.declaration = ccCall(decl, ccName ?? "cc");
-        changed = true;
-        return;
-      }
-    }
-  });
-  if (changed && !alreadyImported) {
-    ast.program.body.unshift(t2.importDeclaration([t2.importSpecifier(t2.identifier("cc"), t2.identifier("cc"))], t2.stringLiteral("sinwan/component")));
-  }
-  return changed;
-}
-
-// src/analyze.ts
-var traverse3 = typeof _traverse3 === "function" ? _traverse3 : _traverse3.default ?? _traverse3;
-function functionRef(fn) {
-  return { start: fn.start ?? -1, end: fn.end ?? -1 };
-}
-function refKey(ref) {
-  return `${ref.start}:${ref.end}`;
-}
-function findFunctionByRef(ast, ref) {
-  let found = null;
-  traverse3(ast, {
-    Function(path) {
-      const node = path.node;
-      if (node.start === ref.start && node.end === ref.end) {
-        found = node;
-        path.stop();
-      }
-    }
-  });
-  return found;
-}
-function serializeReactiveProps(reactiveProps) {
-  const result = {};
-  for (const [filePath, fileMap] of reactiveProps) {
-    const entry = {};
-    for (const [exportName, props] of fileMap) {
-      entry[exportName] = Array.from(props);
-    }
-    result[filePath] = entry;
-  }
-  return result;
-}
-function serializeModule(mod) {
-  const localScopes = {};
-  for (const [fn, scope] of mod.localScopes) {
-    localScopes[refKey(functionRef(fn))] = {
-      bindings: Object.fromEntries(scope.bindings)
-    };
-  }
-  const localCallGraph = {};
-  for (const [callerFn, sites] of mod.localCallGraph) {
-    localCallGraph[refKey(functionRef(callerFn))] = sites.map((s) => ({
-      callee: functionRef(s.callee),
-      props: s.props,
-      spreads: s.spreads
-    }));
-  }
-  return {
-    imports: Object.fromEntries(mod.imports),
-    exports: Object.fromEntries(Array.from(mod.exports.entries()).map(([name, fn]) => [
-      name,
-      functionRef(fn)
-    ])),
-    defaultExport: mod.defaultExport ? functionRef(mod.defaultExport) : null,
-    componentFunctions: Array.from(mod.componentFunctions).map(functionRef),
-    localScopes,
-    localCallGraph,
-    importedCallSites: mod.importedCallSites.map((s) => ({
-      caller: functionRef(s.caller),
-      source: s.source,
-      name: s.name,
-      props: s.props,
-      spreads: s.spreads
-    }))
-  };
-}
-function restoreModule(filePath, serialized) {
-  let code;
-  try {
-    code = fs.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const ast = parse(code, {
-    sourceType: "module",
-    plugins: ["jsx", "typescript"]
-  });
-  const imports = new Map(Object.entries(serialized.imports));
-  const exports = new Map;
-  for (const [name, ref] of Object.entries(serialized.exports)) {
-    const fn = findFunctionByRef(ast, ref);
-    if (!fn)
-      return null;
-    exports.set(name, fn);
-  }
-  const defaultExport = serialized.defaultExport ? findFunctionByRef(ast, serialized.defaultExport) : null;
-  if (serialized.defaultExport && !defaultExport)
-    return null;
-  const componentFunctions = new Set;
-  for (const ref of serialized.componentFunctions) {
-    const fn = findFunctionByRef(ast, ref);
-    if (!fn)
-      return null;
-    componentFunctions.add(fn);
-  }
-  const localScopes = new Map;
-  for (const [key, scope] of Object.entries(serialized.localScopes)) {
-    const ref = parseRefKey(key);
-    if (!ref)
-      return null;
-    const fn = findFunctionByRef(ast, ref);
-    if (!fn)
-      return null;
-    localScopes.set(fn, {
-      bindings: new Map(Object.entries(scope.bindings))
-    });
-  }
-  const localCallGraph = new Map;
-  for (const [key, sites] of Object.entries(serialized.localCallGraph)) {
-    const ref = parseRefKey(key);
-    if (!ref)
-      return null;
-    const callerFn = findFunctionByRef(ast, ref);
-    if (!callerFn)
-      return null;
-    const restored = [];
-    for (const s of sites) {
-      const callee = findFunctionByRef(ast, s.callee);
-      if (!callee)
-        return null;
-      restored.push({
-        callee,
-        props: s.props,
-        spreads: s.spreads
-      });
-    }
-    localCallGraph.set(callerFn, restored);
-  }
-  const importedCallSites = [];
-  for (const s of serialized.importedCallSites) {
-    const caller = findFunctionByRef(ast, s.caller);
-    if (!caller)
-      return null;
-    importedCallSites.push({
-      caller,
-      source: s.source,
-      name: s.name,
-      props: s.props,
-      spreads: s.spreads
-    });
-  }
-  return {
-    filePath,
-    imports,
-    exports,
-    defaultExport,
-    componentFunctions,
-    localScopes,
-    localCallGraph,
-    importedCallSites
-  };
-}
-function parseRefKey(key) {
-  const parts = key.split(":");
-  if (parts.length !== 2)
-    return null;
-  const startStr = parts[0];
-  const endStr = parts[1];
-  if (!startStr || !endStr)
-    return null;
-  const start = Number(startStr);
-  const end = Number(endStr);
-  if (Number.isNaN(start) || Number.isNaN(end))
-    return null;
-  return { start, end };
-}
-function collectImports(ast) {
-  const imports = new Map;
-  traverse3(ast, {
-    ImportDeclaration(path) {
-      const source = path.node.source.value;
-      for (const spec of path.node.specifiers) {
-        if (t3.isImportSpecifier(spec)) {
-          const localName = spec.local.name;
-          const importedName = t3.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-          imports.set(localName, { source, importedName });
-        } else if (t3.isImportDefaultSpecifier(spec)) {
-          imports.set(spec.local.name, { source, importedName: "default" });
-        }
-      }
-    }
-  });
-  return imports;
-}
-function collectImportedCallSites(ast, componentNames, imports) {
-  const sites = [];
-  traverse3(ast, {
-    JSXElement(path) {
-      const name = path.node.openingElement.name;
-      if (!t3.isJSXIdentifier(name))
-        return;
-      const tagName = name.name;
-      if (!/^[A-Z]/.test(tagName))
-        return;
-      if (componentNames.has(tagName))
-        return;
-      const importInfo = imports.get(tagName);
-      if (!importInfo)
-        return;
-      const callerPath = path.findParent((p) => p.isFunction());
-      if (!callerPath)
-        return;
-      const callerFn = callerPath.node;
-      const props = [];
-      const spreads = [];
-      for (const attr of path.node.openingElement.attributes) {
-        if (t3.isJSXSpreadAttribute(attr)) {
-          if (attr.argument) {
-            spreads.push(attr.argument);
-          }
-          continue;
-        }
-        if (t3.isJSXAttribute(attr)) {
-          const attrName = attr.name.name;
-          if (!attrName)
-            continue;
-          if (t3.isJSXExpressionContainer(attr.value)) {
-            const expr = attr.value.expression;
-            if (!expr || t3.isJSXEmptyExpression(expr))
-              continue;
-            props.push({ name: attrName, value: expr });
-          }
-        }
-      }
-      const childExprs = [];
-      for (const child of path.node.children) {
-        if (t3.isJSXExpressionContainer(child)) {
-          const expr = child.expression;
-          if (!expr || t3.isJSXEmptyExpression(expr))
-            continue;
-          childExprs.push(expr);
-        }
-      }
-      if (childExprs.length === 1) {
-        props.push({ name: "children", value: childExprs[0] });
-      } else if (childExprs.length > 1) {
-        props.push({ name: "children", value: t3.arrayExpression(childExprs) });
-      }
-      sites.push({
-        caller: callerFn,
-        source: importInfo.source,
-        name: importInfo.importedName,
-        props,
-        spreads
-      });
-    }
-  });
-  return sites;
-}
-function analyzeModule2(code, filePath) {
-  const ast = parse(code, {
-    sourceType: "module",
-    plugins: ["jsx", "typescript"]
-  });
-  autoWrapComponents2(ast, filePath);
-  const names = trackReactiveImports2(ast);
-  const {
-    functions,
-    names: componentNames,
-    exported
-  } = collectComponentFunctions2(ast, names.cc);
-  const localScopes = computeLocalScopes2(ast, names);
-  const localCallGraph = collectComponentCallGraph2(ast, componentNames);
-  const imports = collectImports(ast);
-  const importedCallSites = collectImportedCallSites(ast, componentNames, imports);
-  const exports = new Map;
-  let defaultExport = null;
-  for (const [localName, fn] of componentNames) {
-    if (exported.has(fn)) {
-      exports.set(localName, fn);
-    }
-  }
-  traverse3(ast, {
-    ExportDefaultDeclaration(path) {
-      const decl = path.node.declaration;
-      if (t3.isIdentifier(decl)) {
-        const fn = componentNames.get(decl.name);
-        if (fn)
-          defaultExport = fn;
-      } else if (t3.isCallExpression(decl)) {
-        const callee = decl.callee;
-        if (t3.isIdentifier(callee) && names.cc.has(callee.name)) {
-          const firstArg = decl.arguments[0];
-          if (firstArg && t3.isFunction(firstArg)) {
-            defaultExport = firstArg;
-          }
-        }
-      }
-    }
-  });
-  return {
-    filePath,
-    imports,
-    exports,
-    defaultExport,
-    componentFunctions: functions,
-    localScopes,
-    localCallGraph,
-    importedCallSites
-  };
-}
-function loadTsConfigPaths(tsConfigPath) {
-  try {
-    const raw = JSON.parse(fs.readFileSync(tsConfigPath, "utf-8"));
-    const paths = raw.compilerOptions?.paths;
-    if (!paths)
-      return null;
-    const baseUrl = raw.compilerOptions?.baseUrl;
-    const root = path2.dirname(tsConfigPath);
-    const resolvedBase = baseUrl ? path2.resolve(root, baseUrl) : root;
-    const result = new Map;
-    for (const [pattern, mappings] of Object.entries(paths)) {
-      result.set(pattern, mappings.map((m) => path2.resolve(resolvedBase, m)));
-    }
-    return result;
-  } catch {
-    return null;
-  }
-}
-function matchTsConfigPath(source, paths) {
-  for (const [pattern, mappings] of paths) {
-    if (pattern.endsWith("/*")) {
-      const prefix = pattern.slice(0, -1);
-      if (source.startsWith(prefix)) {
-        const rest = source.slice(prefix.length);
-        for (const mapping of mappings) {
-          if (mapping.endsWith("/*")) {
-            return mapping.slice(0, -1) + rest;
-          }
-        }
-      }
-    } else if (pattern === source) {
-      return mappings[0] ?? null;
-    }
-  }
-  return null;
-}
-function resolveRelativeImport(source, fromFile, extensions) {
-  if (!source.startsWith("."))
-    return null;
-  const base = path2.resolve(path2.dirname(fromFile), source);
-  const candidates = [
-    ...extensions.map((ext) => base + ext),
-    ...extensions.map((ext) => path2.join(base, "index" + ext))
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate))
-      return candidate;
-  }
-  return null;
-}
-function parseTomlString(value) {
-  value = value.trim();
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function parseAliasObject(content, aliases) {
-  const pairs = [];
-  let current = "";
-  let inQuotes = null;
-  for (const char of content) {
-    if (char === '"' || char === "'") {
-      if (inQuotes === char) {
-        inQuotes = null;
-      } else if (!inQuotes) {
-        inQuotes = char;
-      }
-    }
-    if (char === "," && !inQuotes) {
-      pairs.push(current);
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  if (current.trim())
-    pairs.push(current);
-  for (const pair of pairs) {
-    const eq = pair.indexOf("=");
-    if (eq < 0)
-      continue;
-    const key = parseTomlString(pair.slice(0, eq));
-    const value = parseTomlString(pair.slice(eq + 1));
-    if (key && value)
-      aliases.set(key, value);
-  }
-}
-function loadBunfigAliases(bunfigPath) {
-  try {
-    const content = fs.readFileSync(bunfigPath, "utf-8");
-    const aliases = new Map;
-    const lines = content.split(`
-`);
-    let section = null;
-    for (const rawLine of lines) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#"))
-        continue;
-      if (line.startsWith("[") && line.endsWith("]")) {
-        section = line.slice(1, -1);
-        continue;
-      }
-      if (section === "install" && line.startsWith("alias")) {
-        const start = line.indexOf("{");
-        const end = line.lastIndexOf("}");
-        if (start >= 0 && end > start) {
-          parseAliasObject(line.slice(start + 1, end), aliases);
-        }
-        continue;
-      }
-      if (section === "install.alias") {
-        const eq = line.indexOf("=");
-        if (eq >= 0) {
-          const key = parseTomlString(line.slice(0, eq));
-          const value = parseTomlString(line.slice(eq + 1));
-          if (key && value)
-            aliases.set(key, value);
-        }
-      }
-    }
-    return aliases.size > 0 ? aliases : null;
-  } catch {
-    return null;
-  }
-}
-function matchBunfigAlias(source, aliases, root) {
-  for (const [alias, target] of aliases) {
-    if (source === alias) {
-      return path2.resolve(root, target);
-    }
-    if (source.startsWith(alias + "/")) {
-      return path2.resolve(root, target, source.slice(alias.length + 1));
-    }
-  }
-  return null;
-}
-function resolveWithExtensions(mapped, extensions) {
-  const candidates = [
-    ...extensions.map((ext) => mapped + ext),
-    ...extensions.map((ext) => path2.join(mapped, "index" + ext))
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate))
-      return candidate;
-  }
-  return null;
-}
-function readPackageName(pkgDir) {
-  try {
-    const pkgJson = JSON.parse(fs.readFileSync(path2.join(pkgDir, "package.json"), "utf-8"));
-    return pkgJson.name ?? null;
-  } catch {
-    return null;
-  }
-}
-function resolveWorkspacePackage(source, packages, extensions) {
-  if (packages.length === 0)
-    return null;
-  if (source.startsWith(".") || source.startsWith("/"))
-    return null;
-  let matchedPkg = null;
-  let matchedName = null;
-  for (const pkg of packages) {
-    const pkgName = readPackageName(pkg);
-    if (!pkgName)
-      continue;
-    if (source === pkgName || source.startsWith(pkgName + "/")) {
-      if (!matchedName || pkgName.length > matchedName.length) {
-        matchedName = pkgName;
-        matchedPkg = pkg;
-      }
-    }
-  }
-  if (!matchedPkg || !matchedName)
-    return null;
-  const subpath = source.slice(matchedName.length + 1);
-  let sourceDir;
-  try {
-    const pkgJson = JSON.parse(fs.readFileSync(path2.join(matchedPkg, "package.json"), "utf-8"));
-    if (pkgJson.source) {
-      sourceDir = path2.dirname(path2.resolve(matchedPkg, pkgJson.source));
-    } else {
-      sourceDir = path2.join(matchedPkg, "src");
-    }
-  } catch {
-    sourceDir = path2.join(matchedPkg, "src");
-  }
-  const targetBase = subpath ? path2.join(sourceDir, subpath) : path2.join(sourceDir, "index");
-  return resolveWithExtensions(targetBase, extensions);
-}
-function loadPackageJsonWorkspaces(filePath) {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return pkg.workspaces ?? [];
-  } catch {
-    return [];
-  }
-}
-function loadPnpmWorkspaces(filePath) {
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const lines = content.split(`
-`);
-    const patterns = [];
-    let inPackages = false;
-    for (const rawLine of lines) {
-      const line = rawLine.trim();
-      if (!line || line.startsWith("#"))
-        continue;
-      if (line.startsWith("packages:")) {
-        inPackages = true;
-        continue;
-      }
-      if (inPackages) {
-        if (!line.startsWith("-") && !line.startsWith("  ")) {
-          inPackages = false;
-          continue;
-        }
-        const match = line.match(/^-\s*["']?([^"']+)["']?$/);
-        if (match)
-          patterns.push(match[1]);
-      }
-    }
-    return patterns;
-  } catch {
-    return [];
-  }
-}
-function expandGlob(pattern, cwd) {
-  const fullPattern = path2.resolve(cwd, pattern);
-  const parts = fullPattern.split(path2.sep);
-  const wildcardIndex = parts.findIndex((p) => p.includes("*"));
-  if (wildcardIndex === -1) {
-    return fs.existsSync(fullPattern) ? [fullPattern] : [];
-  }
-  const prefix = parts.slice(0, wildcardIndex).join(path2.sep);
-  const suffixParts = parts.slice(wildcardIndex + 1);
-  const suffix = suffixParts.join(path2.sep);
-  let entries;
-  try {
-    entries = fs.readdirSync(prefix, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const results = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const candidate = path2.join(prefix, entry.name, suffix);
-    results.push(...expandGlob(candidate, cwd));
-  }
-  return results;
-}
-function loadWorkspacePackages(workspaces, root) {
-  const patternEntries = [];
-  if (typeof workspaces === "string") {
-    const resolved = path2.resolve(root, workspaces);
-    if (fs.existsSync(resolved)) {
-      const stat = fs.statSync(resolved);
-      if (stat.isDirectory()) {
-        patternEntries.push({ pattern: workspaces, base: root });
-      } else if (resolved.endsWith("package.json")) {
-        const base = path2.dirname(resolved);
-        for (const p of loadPackageJsonWorkspaces(resolved)) {
-          patternEntries.push({ pattern: p, base });
-        }
-      } else if (resolved.endsWith("pnpm-workspace.yaml")) {
-        const base = path2.dirname(resolved);
-        for (const p of loadPnpmWorkspaces(resolved)) {
-          patternEntries.push({ pattern: p, base });
-        }
-      } else {
-        patternEntries.push({ pattern: workspaces, base: root });
-      }
-    } else {
-      patternEntries.push({ pattern: workspaces, base: root });
-    }
-  } else if (Array.isArray(workspaces)) {
-    for (const p of workspaces) {
-      patternEntries.push({ pattern: p, base: root });
-    }
-  } else if (workspaces && typeof workspaces === "object") {
-    if (workspaces.file) {
-      const resolved = path2.resolve(root, workspaces.file);
-      if (resolved.endsWith("package.json")) {
-        const base = path2.dirname(resolved);
-        for (const p of loadPackageJsonWorkspaces(resolved)) {
-          patternEntries.push({ pattern: p, base });
-        }
-      } else if (resolved.endsWith("pnpm-workspace.yaml")) {
-        const base = path2.dirname(resolved);
-        for (const p of loadPnpmWorkspaces(resolved)) {
-          patternEntries.push({ pattern: p, base });
-        }
-      }
-    }
-    if (workspaces.include) {
-      for (const p of workspaces.include) {
-        patternEntries.push({ pattern: p, base: root });
-      }
-    }
-  }
-  const packages = new Set;
-  for (const { pattern, base } of patternEntries) {
-    for (const dir of expandGlob(pattern, base)) {
-      const pkgJson = path2.join(dir, "package.json");
-      if (fs.existsSync(pkgJson)) {
-        packages.add(dir);
-      }
-    }
-  }
-  return Array.from(packages);
-}
-function createResolver(root, extensions, tsConfigPath, bunfigPath, workspaces) {
-  const paths = tsConfigPath ? loadTsConfigPaths(tsConfigPath) : null;
-  const aliases = bunfigPath ? loadBunfigAliases(bunfigPath) : null;
-  const packages = workspaces ? loadWorkspacePackages(workspaces, root) : [];
-  return (source, fromFile) => {
-    if (paths) {
-      const mapped = matchTsConfigPath(source, paths);
-      if (mapped) {
-        const resolved = resolveWithExtensions(mapped, extensions);
-        if (resolved)
-          return resolved;
-      }
-    }
-    if (aliases) {
-      const mapped = matchBunfigAlias(source, aliases, root);
-      if (mapped) {
-        const resolved = resolveWithExtensions(mapped, extensions);
-        if (resolved)
-          return resolved;
-      }
-    }
-    const pkgResolved = resolveWorkspacePackage(source, packages, extensions);
-    if (pkgResolved)
-      return pkgResolved;
-    return resolveRelativeImport(source, fromFile, extensions);
-  };
-}
-function findFiles(root, extensions) {
-  const files = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === "node_modules" || entry.name === ".git")
-          continue;
-        walk(fullPath);
-      } else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(root);
-  return files;
-}
-function analyzeProject2(options) {
-  const extensions = options.extensions ?? [".tsx", ".ts", ".jsx", ".js"];
-  const resolve = options.resolve ?? createResolver(options.root, extensions, options.tsConfigPath, options.bunfigPath, options.workspaces);
-  const modules = new Map;
-  const providedFiles = options.files;
-  if (providedFiles) {
-    for (const [filePath, code] of Object.entries(providedFiles)) {
-      modules.set(filePath, analyzeModule2(code, filePath));
-    }
-  } else {
-    const files = findFiles(options.root, extensions);
-    for (const file of files) {
-      const code = fs.readFileSync(file, "utf-8");
-      modules.set(file, analyzeModule2(code, file));
-    }
-  }
-  function ensureAnalyzed(filePath) {
-    if (modules.has(filePath))
-      return modules.get(filePath);
-    try {
-      const code = fs.readFileSync(filePath, "utf-8");
-      const mod = analyzeModule2(code, filePath);
-      modules.set(filePath, mod);
-      return mod;
-    } catch {
-      return;
-    }
-  }
-  const globalLocalScopes = new Map;
-  const globalCallGraph = new Map;
-  const globalComponentFunctions = new Set;
-  for (const mod of modules.values()) {
-    for (const [fn, scope] of mod.localScopes) {
-      globalLocalScopes.set(fn, scope);
-    }
-    for (const fn of mod.componentFunctions) {
-      globalComponentFunctions.add(fn);
-    }
-    for (const [callerFn, sites] of mod.localCallGraph) {
-      const list = globalCallGraph.get(callerFn) ?? [];
-      list.push(...sites);
-      globalCallGraph.set(callerFn, list);
-    }
-  }
-  const reactiveProps = buildProjectReactiveProps(modules, resolve, globalLocalScopes, globalCallGraph, globalComponentFunctions, ensureAnalyzed);
-  return { modules, reactiveProps };
-}
-function buildProjectReactiveProps(modules, resolve, globalLocalScopes, globalCallGraph, globalComponentFunctions, ensureAnalyzed) {
-  for (const mod of modules.values()) {
-    for (const site of mod.importedCallSites) {
-      const resolvedFile = resolve(site.source, mod.filePath);
-      if (!resolvedFile)
-        continue;
-      let targetMod = modules.get(resolvedFile);
-      if (!targetMod && ensureAnalyzed) {
-        targetMod = ensureAnalyzed(resolvedFile);
-        if (targetMod) {
-          for (const [fn, scope] of targetMod.localScopes) {
-            globalLocalScopes.set(fn, scope);
-          }
-          for (const fn of targetMod.componentFunctions) {
-            globalComponentFunctions.add(fn);
-          }
-          for (const [callerFn, sites] of targetMod.localCallGraph) {
-            const list = globalCallGraph.get(callerFn) ?? [];
-            list.push(...sites);
-            globalCallGraph.set(callerFn, list);
-          }
-        }
-      }
-      if (!targetMod)
-        continue;
-      const targetFn = site.name === "default" ? targetMod.defaultExport : targetMod.exports.get(site.name);
-      if (!targetFn)
-        continue;
-      const list = globalCallGraph.get(site.caller) ?? [];
-      list.push({
-        callee: targetFn,
-        props: site.props,
-        spreads: site.spreads
-      });
-      globalCallGraph.set(site.caller, list);
-    }
-  }
-  const globalReactiveProps = propagateReactiveProps2(globalLocalScopes, globalCallGraph, globalComponentFunctions);
-  const reactiveProps = new Map;
-  for (const mod of modules.values()) {
-    const fileMap = new Map;
-    for (const [exportName, fn] of mod.exports) {
-      const props = globalReactiveProps.get(fn);
-      fileMap.set(exportName, props ? new Set(props) : new Set);
-    }
-    if (mod.defaultExport) {
-      const props = globalReactiveProps.get(mod.defaultExport);
-      fileMap.set("default", props ? new Set(props) : new Set);
-    }
-    reactiveProps.set(mod.filePath, fileMap);
-  }
-  return reactiveProps;
-}
-
-class AnalyzerCache2 {
-  root;
-  extensions;
-  tsConfigPath;
-  bunfigPath;
-  workspaces;
-  cachePath;
-  resolve;
-  modules = new Map;
-  reactiveProps = new Map;
-  importers = new Map;
-  constructor(options) {
-    this.root = options.root;
-    this.extensions = options.extensions ?? [".tsx", ".ts", ".jsx", ".js"];
-    this.tsConfigPath = options.tsConfigPath;
-    this.bunfigPath = options.bunfigPath;
-    this.workspaces = options.workspaces;
-    this.cachePath = options.cachePath;
-    const bunfigPath = options.bunfigPath;
-    const diskResolver = options.resolve ?? createResolver(this.root, this.extensions, this.tsConfigPath, bunfigPath, this.workspaces);
-    this.resolve = (source, fromFile) => {
-      if (source.startsWith(".")) {
-        const base = path2.resolve(path2.dirname(fromFile), source);
-        for (const ext of this.extensions) {
-          if (this.modules.has(base + ext))
-            return base + ext;
-          const indexCandidate = path2.join(base, "index" + ext);
-          if (this.modules.has(indexCandidate))
-            return indexCandidate;
-        }
-      }
-      return diskResolver(source, fromFile);
-    };
-    if (this.cachePath) {
-      this.restore();
-    }
-  }
-  update(filePath, code) {
-    const oldMod = this.modules.get(filePath);
-    const newMod = analyzeModule2(code, filePath);
-    this.modules.set(filePath, newMod);
-    if (oldMod)
-      this.removeImporters(oldMod);
-    this.addImporters(newMod);
-    this.recomputeFor([filePath]);
-    this.save();
-  }
-  remove(filePath) {
-    const oldMod = this.modules.get(filePath);
-    const affected = new Set(this.importers.get(filePath) ?? []);
-    if (oldMod) {
-      for (const site of oldMod.importedCallSites) {
-        const resolved = this.resolve(site.source, oldMod.filePath);
-        if (resolved)
-          affected.add(resolved);
-      }
-    }
-    this.modules.delete(filePath);
-    this.importers.delete(filePath);
-    if (oldMod)
-      this.removeImporters(oldMod);
-    this.recomputeFor(affected);
-    this.save();
-  }
-  save() {
-    if (!this.cachePath)
-      return;
-    const data = {
-      version: 1,
-      modules: Object.fromEntries(Array.from(this.modules.entries()).map(([filePath, mod]) => [
-        filePath,
-        serializeModule(mod)
-      ])),
-      reactiveProps: serializeReactiveProps(this.reactiveProps)
-    };
-    const dir = path2.dirname(this.cachePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(this.cachePath, JSON.stringify(data, null, 2));
-  }
-  restore() {
-    if (!this.cachePath || !fs.existsSync(this.cachePath))
-      return;
-    let data;
-    try {
-      data = JSON.parse(fs.readFileSync(this.cachePath, "utf-8"));
-    } catch {
-      return;
-    }
-    if (data.version !== 1)
-      return;
-    for (const [filePath, serialized] of Object.entries(data.modules)) {
-      const mod = restoreModule(filePath, serialized);
-      if (mod) {
-        this.modules.set(filePath, mod);
-      }
-    }
-    this.importers = new Map;
-    for (const mod of this.modules.values()) {
-      this.addImporters(mod);
-    }
-    this.reactiveProps = new Map;
-    for (const [filePath, fileMap] of Object.entries(data.reactiveProps)) {
-      const map = new Map;
-      for (const [exportName, props] of Object.entries(fileMap)) {
-        map.set(exportName, new Set(props));
-      }
-      this.reactiveProps.set(filePath, map);
-    }
-  }
-  addImporters(mod) {
-    for (const site of mod.importedCallSites) {
-      const resolvedFile = this.resolve(site.source, mod.filePath);
-      if (!resolvedFile)
-        continue;
-      let set = this.importers.get(resolvedFile);
-      if (!set) {
-        set = new Set;
-        this.importers.set(resolvedFile, set);
-      }
-      set.add(mod.filePath);
-    }
-  }
-  removeImporters(mod) {
-    for (const site of mod.importedCallSites) {
-      const resolvedFile = this.resolve(site.source, mod.filePath);
-      if (!resolvedFile)
-        continue;
-      this.importers.get(resolvedFile)?.delete(mod.filePath);
-    }
-  }
-  ensureAnalyzed(filePath) {
-    if (this.modules.has(filePath))
-      return this.modules.get(filePath);
-    try {
-      const code = fs.readFileSync(filePath, "utf-8");
-      const mod = analyzeModule2(code, filePath);
-      this.modules.set(filePath, mod);
-      return mod;
-    } catch {
-      return;
-    }
-  }
-  collectAffected(filePaths) {
-    const affected = new Set;
-    const queue = Array.from(filePaths);
-    while (queue.length > 0) {
-      const current = queue.pop();
-      if (affected.has(current))
-        continue;
-      let mod = this.modules.get(current);
-      if (!mod) {
-        mod = this.ensureAnalyzed(current);
-        if (mod)
-          this.addImporters(mod);
-      }
-      if (!mod)
-        continue;
-      affected.add(current);
-      for (const importer of this.importers.get(current) ?? []) {
-        if (!affected.has(importer))
-          queue.push(importer);
-      }
-      for (const site of mod.importedCallSites) {
-        const resolved = this.resolve(site.source, mod.filePath);
-        if (resolved && !affected.has(resolved)) {
-          queue.push(resolved);
-        }
-      }
-    }
-    return affected;
-  }
-  recomputeFor(filePaths) {
-    const affected = this.collectAffected(filePaths);
-    const subgraphModules = new Map;
-    for (const filePath of affected) {
-      const mod = this.modules.get(filePath);
-      if (mod)
-        subgraphModules.set(filePath, mod);
-    }
-    const globalLocalScopes = new Map;
-    const globalCallGraph = new Map;
-    const globalComponentFunctions = new Set;
-    for (const mod of subgraphModules.values()) {
-      for (const [fn, scope] of mod.localScopes) {
-        globalLocalScopes.set(fn, scope);
-      }
-      for (const fn of mod.componentFunctions) {
-        globalComponentFunctions.add(fn);
-      }
-      for (const [callerFn, sites] of mod.localCallGraph) {
-        const list = globalCallGraph.get(callerFn) ?? [];
-        list.push(...sites);
-        globalCallGraph.set(callerFn, list);
-      }
-    }
-    const subgraphReactiveProps = buildProjectReactiveProps(subgraphModules, this.resolve, globalLocalScopes, globalCallGraph, globalComponentFunctions);
-    for (const filePath of affected) {
-      const map = subgraphReactiveProps.get(filePath);
-      if (map) {
-        this.reactiveProps.set(filePath, map);
-      }
-    }
-  }
-}
-function analyze2(options) {
-  const tsConfigPath = options.tsConfigPath ?? path2.join(options.root, "tsconfig.json");
-  const bunfigPath = options.bunfigPath ?? path2.join(options.root, "bunfig.toml");
-  const project = analyzeProject2({
-    root: options.root,
-    extensions: options.extensions,
-    resolve: options.resolve,
-    tsConfigPath: fs.existsSync(tsConfigPath) ? tsConfigPath : undefined,
-    bunfigPath: fs.existsSync(bunfigPath) ? bunfigPath : undefined,
-    workspaces: options.workspaces
-  });
-  const serialized = {};
-  for (const [filePath, fileMap] of project.reactiveProps) {
-    const entry = {};
-    for (const [exportName, props] of fileMap) {
-      entry[exportName] = Array.from(props);
-    }
-    serialized[filePath] = entry;
-  }
-  const dir = path2.dirname(options.outFile);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(options.outFile, JSON.stringify(serialized, null, 2));
-}
-function loadMetadata2(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return new Map;
-  }
-  const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  const result = new Map;
-  for (const [filePath, fileMap] of Object.entries(raw)) {
-    const map = new Map;
-    for (const [exportName, props] of Object.entries(fileMap)) {
-      map.set(exportName, new Set(props));
-    }
-    result.set(filePath, map);
-  }
-  return result;
-}
-
-// src/cli.ts
-function runAnalyzeCli2(args = process.argv.slice(2)) {
-  let command;
-  let root;
-  let outFile;
-  let tsConfigPath;
-  let bunfigPath;
-  let workspaces;
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--tsconfig" || arg === "-t") {
-      tsConfigPath = args[++i];
-    } else if (arg === "--bunfig" || arg === "-b") {
-      bunfigPath = args[++i];
-    } else if (arg === "--workspaces" || arg === "-w") {
-      workspaces = args[++i];
-    } else if (command === undefined) {
-      command = arg;
-    } else if (root === undefined) {
-      root = arg;
-    } else if (outFile === undefined) {
-      outFile = arg;
-    }
-  }
-  if (command !== "analyze") {
-    console.error("Unknown command. Use: sinwan analyze [root] [outFile] [--tsconfig path] [--bunfig path] [--workspaces path]");
-    process.exit(1);
-  }
-  root = root ?? process.cwd();
-  outFile = outFile ?? path3.join(root, ".sinwan/reactive-props.json");
-  analyze2({ root, outFile, tsConfigPath, bunfigPath, workspaces });
-  console.log(`[sinwan] analyzed ${root} -> ${outFile}`);
-}
-function runCliIfMain2(isMain = import.meta.main, args) {
-  if (!isMain)
-    return;
-  runAnalyzeCli2(args);
-}
-runCliIfMain2();
-
-export { autoWrapComponents2, analyzeModule2, analyzeProject2, AnalyzerCache2, analyze2, loadMetadata2, trackReactiveImports2, getAllPropNames2, isReactiveValue2, containsReactiveValue2, collectComponentFunctions2, computeLocalScopes2, collectComponentCallGraph2, buildFullScope2, propagateReactiveProps2, wrapReactiveExpressions2, runAnalyzeCli2, runCliIfMain2 };