sinwan-compiler 0.0.0 → 0.2.0

package/dist/chunk-ba0546ea.js

@@ -0,0 +1,1848 @@
+// @bun
+// src/cli.ts
+import * as path3 from "path";
+
+// src/analyze.ts
+import { parse } from "@babel/parser";
+import * as t2 from "@babel/types";
+import _traverse2 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-client": new Set(["useState"])
+};
+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 trackReactiveImports(ast) {
+  const names = {
+    createMutable: new Set,
+    createStore: new Set,
+    signal: new Set,
+    computed: new Set,
+    useState: new Set,
+    cc: new Set
+  };
+  traverse(ast, {
+    ImportDeclaration(path2) {
+      const source = path2.node.source.value;
+      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
+      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
+      if (!reactiveAllowed && !componentAllowed)
+        return;
+      for (const spec of path2.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;
+}
+function trackLocalScopeBindings(path2, names, scope) {
+  path2.traverse({
+    VariableDeclarator(p) {
+      const id = p.node.id;
+      const init = p.node.init;
+      if (!init)
+        return;
+      const source = isReactiveSourceCall(init, names);
+      if (!source)
+        return;
+      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 });
+        }
+      }
+    }
+  });
+  path2.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]
+          });
+        }
+      }
+    }
+  });
+  path2.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" });
+      }
+    }
+  });
+}
+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 getAllPropNames(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;
+      if (decl.init && t.isObjectExpression(decl.init)) {
+        return decl.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 && containsReactiveValue(prop.value, fullScope)) {
+        calleeReactive.add(name);
+      }
+    }
+  }
+}
+function getMemberExpressionRootAndPath(node) {
+  const path2 = [];
+  let current = node;
+  while (t.isMemberExpression(current)) {
+    if (current.computed)
+      return null;
+    if (!t.isIdentifier(current.property))
+      return null;
+    path2.push(current.property.name);
+    current = current.object;
+  }
+  if (t.isIdentifier(current)) {
+    return { root: current.name, path: path2.reverse() };
+  }
+  return null;
+}
+function isReactiveRead(node, scope) {
+  if (t.isIdentifier(node)) {
+    const binding2 = scope.bindings.get(node.name);
+    if (!binding2)
+      return false;
+    if (binding2.kind === "prop") {
+      return true;
+    }
+    if (binding2.kind === "mutable" && binding2.path.length > 0) {
+      return true;
+    }
+    return false;
+  }
+  const rootPath = getMemberExpressionRootAndPath(node);
+  if (!rootPath)
+    return false;
+  const binding = scope.bindings.get(rootPath.root);
+  if (!binding)
+    return false;
+  if (binding.kind === "prop") {
+    return true;
+  }
+  if (binding.kind === "mutable") {
+    return true;
+  }
+  if (binding.kind === "signal" || binding.kind === "computed") {
+    return rootPath.path[0] === "value";
+  }
+  return false;
+}
+function isGetterCall(node, scope) {
+  const callee = node.callee;
+  if (!t.isIdentifier(callee))
+    return false;
+  const binding = scope.bindings.get(callee.name);
+  return binding?.kind === "getter";
+}
+function isReactiveValue(node, scope) {
+  if (t.isIdentifier(node)) {
+    const binding2 = scope.bindings.get(node.name);
+    if (!binding2)
+      return false;
+    return binding2.kind === "prop" || binding2.kind === "signal" || binding2.kind === "computed" || binding2.kind === "mutable";
+  }
+  const rootPath = getMemberExpressionRootAndPath(node);
+  if (!rootPath)
+    return false;
+  const binding = scope.bindings.get(rootPath.root);
+  if (!binding)
+    return false;
+  if (binding.kind === "prop" || binding.kind === "mutable") {
+    return true;
+  }
+  if (binding.kind === "signal" || binding.kind === "computed") {
+    return rootPath.path[0] === "value";
+  }
+  return false;
+}
+function containsReactiveValue(expr, scope) {
+  let found = false;
+  function visit(node) {
+    if (found)
+      return;
+    if (!node || typeof node !== "object")
+      return;
+    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+      if (isReactiveValue(node, scope)) {
+        found = true;
+        return;
+      }
+    }
+    if (t.isCallExpression(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) {
+    if (found)
+      return;
+    if (!node || typeof node !== "object")
+      return;
+    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+      if (isReactiveRead(node, scope)) {
+        found = true;
+        return;
+      }
+    }
+    if (t.isCallExpression(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 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: null };
+  }
+  return { isComponent: true, componentName, attributeName };
+}
+function isReactiveComponentProp(info, componentNames, reactiveProps) {
+  if (!info.isComponent || !info.componentName || !info.attributeName) {
+    return false;
+  }
+  if (isBuiltinReactiveProp(info.componentName, info.attributeName)) {
+    return true;
+  }
+  const componentFn = componentNames.get(info.componentName);
+  if (!componentFn)
+    return false;
+  const props = reactiveProps.get(componentFn);
+  if (!props)
+    return false;
+  return props.has(info.attributeName);
+}
+function shouldWrap(expr, scope) {
+  if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr))
+    return false;
+  if (t.isJSXEmptyExpression(expr))
+    return false;
+  return containsReactiveRead(expr, scope);
+}
+function wrapExpression(expr) {
+  return t.arrowFunctionExpression([], expr);
+}
+function createBindingDescriptor(expr, exprPath, options) {
+  if (!options.explicitBindings) {
+    return wrapExpression(expr);
+  }
+  const parent = exprPath.parentPath;
+  if (parent && parent.isJSXAttribute && parent.isJSXAttribute()) {
+    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)
+    ]);
+  }
+  return t.callExpression(t.identifier("_$bindText"), [wrapExpression(expr)]);
+}
+function collectComponentFunctions(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(path2) {
+      const callee = path2.node.callee;
+      if (!t.isIdentifier(callee) || !ccNames.has(callee.name))
+        return;
+      const firstArg = path2.node.arguments[0];
+      if (!firstArg || !t.isFunction(firstArg))
+        return;
+      const componentFn = firstArg;
+      functions.add(componentFn);
+      const parent = path2.parentPath;
+      if (parent && parent.isVariableDeclarator && parent.isVariableDeclarator()) {
+        const id = parent.node.id;
+        if (t.isIdentifier(id)) {
+          names.set(id.name, componentFn);
+        }
+      } else if (parent && parent.isExportNamedDeclaration && parent.isExportNamedDeclaration()) {
+        const declaration = parent.node.declaration;
+        if (t.isVariableDeclaration(declaration)) {
+          for (const decl of declaration.declarations) {
+            if (t.isIdentifier(decl.id)) {
+              names.set(decl.id.name, componentFn);
+            }
+          }
+        }
+      }
+    }
+  });
+  traverse(ast, {
+    ExportNamedDeclaration(path2) {
+      const declaration = path2.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(path2) {
+      const decl = path2.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 computeLocalScopes(ast, names) {
+  const scopes = new Map;
+  traverse(ast, {
+    Function(path2) {
+      const scope = { bindings: new Map };
+      trackLocalScopeBindings(path2, names, scope);
+      scopes.set(path2.node, scope);
+    }
+  });
+  return scopes;
+}
+function collectComponentCallGraph(ast, componentNames) {
+  const callGraph = new Map;
+  if (componentNames.size === 0)
+    return callGraph;
+  traverse(ast, {
+    JSXElement(path2) {
+      const name = path2.node.openingElement.name;
+      if (!t.isJSXIdentifier(name))
+        return;
+      const callee = componentNames.get(name.name);
+      if (!callee)
+        return;
+      const callerPath = path2.findParent((p) => p.isFunction());
+      const callerFn = callerPath ? callerPath.node : null;
+      if (!callerFn)
+        return;
+      const props = [];
+      const spreads = [];
+      for (const attr of path2.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 path2.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 buildFullScope(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 propagateReactiveProps(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 (containsReactiveValue(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 = buildFullScope(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 (containsReactiveValue(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 = getAllPropNames(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 wrapReactiveExpressions(ast, options = {}) {
+  const names = trackReactiveImports(ast);
+  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
+  if (!hasAnyImport)
+    return;
+  const {
+    functions: componentFunctions,
+    names: componentNames,
+    exported
+  } = collectComponentFunctions(ast, names.cc);
+  const localScopes = computeLocalScopes(ast, names);
+  const callGraph = collectComponentCallGraph(ast, componentNames);
+  const reactiveProps = propagateReactiveProps(localScopes, callGraph, componentFunctions);
+  const exportNameByFn = new Map;
+  for (const [localName, fn] of componentNames) {
+    if (exported.has(fn)) {
+      exportNameByFn.set(fn, localName);
+    }
+  }
+  traverse(ast, {
+    ExportDefaultDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (t.isIdentifier(decl)) {
+        const fn = componentNames.get(decl.name);
+        if (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)) {
+            exportNameByFn.set(firstArg, "default");
+          }
+        }
+      }
+    }
+  });
+  let metadata = null;
+  if (options.analyzeMetadata) {
+    metadata = options.analyzeMetadata;
+  } else if (options.analyze && options.filename) {
+    try {
+      metadata = loadMetadata(options.analyze);
+    } catch {
+      metadata = null;
+    }
+  }
+  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
+  traverse(ast, {
+    Function(path2) {
+      const scope = localScopes.get(path2.node);
+      if (!scope)
+        return;
+      const isComponent = componentFunctions.has(path2.node);
+      if (isComponent) {
+        const isExported = exported.has(path2.node);
+        if (isExported) {
+          let props = null;
+          if (metadata && absoluteFilename) {
+            const fileProps = metadata.get(absoluteFilename);
+            const exportName = exportNameByFn.get(path2.node);
+            if (fileProps && exportName) {
+              props = fileProps.get(exportName) ?? null;
+            }
+          }
+          if (props) {
+            trackPropBindings(scope, path2.node.params[0], props);
+          } else {
+            const allProps = getAllPropNames(path2.node.params[0]);
+            trackPropBindings(scope, path2.node.params[0], allProps);
+          }
+        } else if (reactiveProps.has(path2.node)) {
+          const props = reactiveProps.get(path2.node);
+          trackPropBindings(scope, path2.node.params[0], props);
+        } else {
+          const allProps = getAllPropNames(path2.node.params[0]);
+          trackPropBindings(scope, path2.node.params[0], allProps);
+        }
+      }
+      if (scope.bindings.size === 0)
+        return;
+      path2.traverse({
+        JSXExpressionContainer(exprPath) {
+          const expr = exprPath.node.expression;
+          const compInfo = getComponentExpressionInfo(exprPath);
+          if (compInfo.isComponent) {
+            if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps)) {
+              return;
+            }
+          }
+          if (shouldWrap(expr, scope)) {
+            exprPath.replaceWith(t.jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options)));
+          }
+        }
+      });
+    }
+  });
+}
+
+// src/analyze.ts
+var traverse2 = typeof _traverse2 === "function" ? _traverse2 : _traverse2.default ?? _traverse2;
+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;
+  traverse2(ast, {
+    Function(path3) {
+      const node = path3.node;
+      if (node.start === ref.start && node.end === ref.end) {
+        found = node;
+        path3.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;
+    localCallGraph.set(callerFn, sites.map((s) => {
+      const callee = findFunctionByRef(ast, s.callee);
+      if (!callee)
+        throw new Error("Failed to restore callee");
+      return {
+        callee,
+        props: s.props,
+        spreads: s.spreads
+      };
+    }));
+  }
+  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;
+  traverse2(ast, {
+    ImportDeclaration(path3) {
+      const source = path3.node.source.value;
+      for (const spec of path3.node.specifiers) {
+        if (t2.isImportSpecifier(spec)) {
+          const localName = spec.local.name;
+          const importedName = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          imports.set(localName, { source, importedName });
+        } else if (t2.isImportDefaultSpecifier(spec)) {
+          imports.set(spec.local.name, { source, importedName: "default" });
+        }
+      }
+    }
+  });
+  return imports;
+}
+function collectImportedCallSites(ast, componentNames, imports) {
+  const sites = [];
+  traverse2(ast, {
+    JSXElement(path3) {
+      const name = path3.node.openingElement.name;
+      if (!t2.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 = path3.findParent((p) => p.isFunction());
+      if (!callerPath)
+        return;
+      const callerFn = callerPath.node;
+      const props = [];
+      const spreads = [];
+      for (const attr of path3.node.openingElement.attributes) {
+        if (t2.isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (t2.isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (t2.isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || t2.isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of path3.node.children) {
+        if (t2.isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || t2.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: t2.arrayExpression(childExprs) });
+      }
+      sites.push({
+        caller: callerFn,
+        source: importInfo.source,
+        name: importInfo.importedName,
+        props,
+        spreads
+      });
+    }
+  });
+  return sites;
+}
+function analyzeModule(code, filePath) {
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  });
+  const names = trackReactiveImports(ast);
+  const {
+    functions,
+    names: componentNames,
+    exported
+  } = collectComponentFunctions(ast, names.cc);
+  const localScopes = computeLocalScopes(ast, names);
+  const localCallGraph = collectComponentCallGraph(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);
+    }
+  }
+  traverse2(ast, {
+    ExportDefaultDeclaration(path3) {
+      const decl = path3.node.declaration;
+      if (t2.isIdentifier(decl)) {
+        const fn = componentNames.get(decl.name);
+        if (fn)
+          defaultExport = fn;
+      } else if (t2.isCallExpression(decl)) {
+        const callee = decl.callee;
+        if (t2.isIdentifier(callee) && names.cc.has(callee.name)) {
+          const firstArg = decl.arguments[0];
+          if (firstArg && t2.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 analyzeProject(options) {
+  const extensions = options.extensions ?? [".tsx", ".ts", ".jsx", ".js"];
+  const resolve3 = 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, analyzeModule(code, filePath));
+    }
+  } else {
+    const files = findFiles(options.root, extensions);
+    for (const file of files) {
+      const code = fs.readFileSync(file, "utf-8");
+      modules.set(file, analyzeModule(code, file));
+    }
+  }
+  function ensureAnalyzed(filePath) {
+    if (modules.has(filePath))
+      return modules.get(filePath);
+    try {
+      const code = fs.readFileSync(filePath, "utf-8");
+      const mod = analyzeModule(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, resolve3, globalLocalScopes, globalCallGraph, globalComponentFunctions, ensureAnalyzed);
+  return { modules, reactiveProps };
+}
+function buildProjectReactiveProps(modules, resolve3, globalLocalScopes, globalCallGraph, globalComponentFunctions, ensureAnalyzed) {
+  for (const mod of modules.values()) {
+    for (const site of mod.importedCallSites) {
+      const resolvedFile = resolve3(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 list2 = globalCallGraph.get(callerFn) ?? [];
+            list2.push(...sites);
+            globalCallGraph.set(callerFn, list2);
+          }
+        }
+      }
+      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 = propagateReactiveProps(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 AnalyzerCache {
+  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 = analyzeModule(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 affectedImporters = new Set(this.importers.get(filePath) ?? []);
+    this.modules.delete(filePath);
+    this.importers.delete(filePath);
+    if (oldMod)
+      this.removeImporters(oldMod);
+    this.recomputeFor(affectedImporters);
+    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 = analyzeModule(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);
+      }
+    }
+  }
+  recompute() {
+    const affected = this.collectAffected(Array.from(this.modules.keys()));
+    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);
+      }
+    }
+    this.reactiveProps = buildProjectReactiveProps(subgraphModules, this.resolve, globalLocalScopes, globalCallGraph, globalComponentFunctions);
+  }
+}
+function analyze(options) {
+  const tsConfigPath = options.tsConfigPath ?? path2.join(options.root, "tsconfig.json");
+  const bunfigPath = options.bunfigPath ?? path2.join(options.root, "bunfig.toml");
+  const project = analyzeProject({
+    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 loadMetadata(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return new Map;
+  }
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  const result = new Map;
+  for (const [filePath2, 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(filePath2, map);
+  }
+  return result;
+}
+
+// src/cli.ts
+function runAnalyzeCli(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");
+  analyze({ root, outFile, tsConfigPath, bunfigPath, workspaces });
+  console.log(`[sinwan] analyzed ${root} -> ${outFile}`);
+}
+if (import.meta.main) {
+  runAnalyzeCli();
+}
+
+export { analyzeModule, analyzeProject, AnalyzerCache, analyze, loadMetadata, trackReactiveImports, getAllPropNames, isReactiveValue, containsReactiveValue, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, buildFullScope, propagateReactiveProps, wrapReactiveExpressions, runAnalyzeCli };