sinwan-compiler 0.3.1 → 1.0.0

package/dist/chunk-rshqq0t3.js

@@ -0,0 +1,4190 @@
+// @bun
+// src/ast/types.ts
+function lit(value, raw) {
+  return {
+    type: "Literal",
+    value,
+    raw: raw ?? (typeof value === "string" ? JSON.stringify(value) : value === null ? "null" : String(value))
+  };
+}
+function identifier(name) {
+  return { type: "Identifier", name };
+}
+function stringLiteral(value) {
+  return lit(value);
+}
+function numericLiteral(value) {
+  return lit(value);
+}
+function callExpression(callee, args) {
+  return {
+    type: "CallExpression",
+    callee,
+    arguments: args,
+    optional: false
+  };
+}
+function memberExpression(object, property, computed = false) {
+  return {
+    type: "MemberExpression",
+    object,
+    property,
+    computed,
+    optional: false
+  };
+}
+function arrowFunctionExpression(params, body, expression = !isBlockStatement(body)) {
+  return {
+    type: "ArrowFunctionExpression",
+    params,
+    body,
+    expression,
+    async: false,
+    generator: false,
+    id: null
+  };
+}
+function functionExpression(id, params, body, generator = false, async = false) {
+  return {
+    type: "FunctionExpression",
+    id,
+    params,
+    body,
+    generator,
+    async
+  };
+}
+function functionDeclaration(id, params, body, generator = false, async = false) {
+  return {
+    type: "FunctionDeclaration",
+    id,
+    params,
+    body,
+    generator,
+    async
+  };
+}
+function variableDeclarator(id, init = null) {
+  return { type: "VariableDeclarator", id, init };
+}
+function variableDeclaration(kind, declarations) {
+  return { type: "VariableDeclaration", kind, declarations };
+}
+function arrayExpression(elements) {
+  return { type: "ArrayExpression", elements };
+}
+function objectExpression(properties) {
+  return { type: "ObjectExpression", properties };
+}
+function objectProperty(key, value, computed = false, shorthand = false) {
+  return {
+    type: "Property",
+    key,
+    value,
+    kind: "init",
+    method: false,
+    shorthand,
+    computed
+  };
+}
+function importSpecifier(local, imported) {
+  return { type: "ImportSpecifier", local, imported, importKind: "value" };
+}
+function importDeclaration(specifiers, source) {
+  return {
+    type: "ImportDeclaration",
+    specifiers,
+    source,
+    importKind: "value",
+    attributes: []
+  };
+}
+function exportNamedDeclaration(declaration, specifiers = []) {
+  return {
+    type: "ExportNamedDeclaration",
+    declaration,
+    specifiers,
+    source: null,
+    exportKind: "value",
+    attributes: []
+  };
+}
+function exportDefaultDeclaration(declaration) {
+  return { type: "ExportDefaultDeclaration", declaration };
+}
+function jsxExpressionContainer(expression) {
+  return { type: "JSXExpressionContainer", expression };
+}
+function blockStatement(body) {
+  return { type: "BlockStatement", body };
+}
+function returnStatement(argument = null) {
+  return { type: "ReturnStatement", argument };
+}
+function binaryExpression(operator, left, right) {
+  return { type: "BinaryExpression", operator, left, right };
+}
+function conditionalExpression(test, consequent, alternate) {
+  return { type: "ConditionalExpression", test, consequent, alternate };
+}
+function unaryExpression(operator, argument, prefix = true) {
+  return { type: "UnaryExpression", operator, argument, prefix };
+}
+function isNode(n) {
+  return !!n && typeof n === "object" && typeof n.type === "string";
+}
+function isIdentifier(n, opts) {
+  if (!isNode(n) || n.type !== "Identifier" || typeof n.name !== "string")
+    return false;
+  if (opts?.name !== undefined)
+    return n.name === opts.name;
+  return true;
+}
+function isLiteral(n) {
+  return isNode(n) && n.type === "Literal";
+}
+function isStringLiteral(n, opts) {
+  if (!isLiteral(n) || typeof n.value !== "string")
+    return false;
+  if (opts?.value !== undefined)
+    return n.value === opts.value;
+  return true;
+}
+function isNumericLiteral(n) {
+  return isLiteral(n) && typeof n.value === "number";
+}
+function isBooleanLiteral(n) {
+  return isLiteral(n) && typeof n.value === "boolean";
+}
+function isNullLiteral(n) {
+  return isLiteral(n) && n.value === null && !n.regex;
+}
+function isTemplateLiteral(n) {
+  return isNode(n) && n.type === "TemplateLiteral";
+}
+function templateElementRaw(n) {
+  const raw = n?.value;
+  if (typeof raw === "string")
+    return raw;
+  if (raw && typeof raw === "object" && "raw" in raw) {
+    return String(raw.raw ?? "");
+  }
+  return "";
+}
+function isCallExpression(n) {
+  return isNode(n) && n.type === "CallExpression";
+}
+function isOptionalCallExpression(n) {
+  return isNode(n) && (n.type === "CallExpression" && n.optional === true || n.type === "ChainExpression" && isNode(n.expression) && n.expression.type === "CallExpression" && n.expression.optional === true);
+}
+function isMemberExpression(n) {
+  return isNode(n) && n.type === "MemberExpression";
+}
+function isOptionalMemberExpression(n) {
+  return isNode(n) && (n.type === "MemberExpression" && n.optional === true || n.type === "ChainExpression" && isNode(n.expression) && n.expression.type === "MemberExpression");
+}
+function isChainExpression(n) {
+  return isNode(n) && n.type === "ChainExpression";
+}
+function unwrapChain(n) {
+  return isChainExpression(n) && isNode(n.expression) ? n.expression : n;
+}
+function isParenthesizedExpression(n) {
+  return isNode(n) && n.type === "ParenthesizedExpression";
+}
+function unwrapParens(n) {
+  let current = n;
+  while (current && isParenthesizedExpression(current) && isNode(current.expression)) {
+    current = current.expression;
+  }
+  return current ?? n;
+}
+function unwrapCall(n) {
+  return unwrapParens(unwrapChain(unwrapParens(n)));
+}
+function isObjectExpression(n) {
+  return isNode(n) && n.type === "ObjectExpression";
+}
+function isObjectProperty(n) {
+  return isNode(n) && (n.type === "Property" || n.type === "ObjectProperty");
+}
+function isObjectPattern(n) {
+  return isNode(n) && n.type === "ObjectPattern";
+}
+function isArrayPattern(n) {
+  return isNode(n) && n.type === "ArrayPattern";
+}
+function isRestElement(n) {
+  return isNode(n) && n.type === "RestElement";
+}
+function isSpreadElement(n) {
+  return isNode(n) && n.type === "SpreadElement";
+}
+function isAssignmentPattern(n) {
+  return isNode(n) && n.type === "AssignmentPattern";
+}
+function isBlockStatement(n) {
+  return isNode(n) && n.type === "BlockStatement";
+}
+function isVariableDeclaration(n, opts) {
+  if (!isNode(n) || n.type !== "VariableDeclaration")
+    return false;
+  if (opts?.kind !== undefined)
+    return n.kind === opts.kind;
+  return true;
+}
+function isVariableDeclarator(n) {
+  return isNode(n) && n.type === "VariableDeclarator";
+}
+function isFunctionDeclaration(n) {
+  return isNode(n) && n.type === "FunctionDeclaration";
+}
+function isFunctionExpression(n) {
+  return isNode(n) && n.type === "FunctionExpression";
+}
+function isArrowFunctionExpression(n) {
+  return isNode(n) && n.type === "ArrowFunctionExpression";
+}
+function isFunction(n) {
+  return isFunctionDeclaration(n) || isFunctionExpression(n) || isArrowFunctionExpression(n);
+}
+function isImportDeclaration(n) {
+  return isNode(n) && n.type === "ImportDeclaration";
+}
+function isImportSpecifier(n) {
+  return isNode(n) && n.type === "ImportSpecifier";
+}
+function isImportDefaultSpecifier(n) {
+  return isNode(n) && n.type === "ImportDefaultSpecifier";
+}
+function isImportNamespaceSpecifier(n) {
+  return isNode(n) && n.type === "ImportNamespaceSpecifier";
+}
+function isExportSpecifier(n) {
+  return isNode(n) && n.type === "ExportSpecifier";
+}
+function isClassDeclaration(n) {
+  return isNode(n) && n.type === "ClassDeclaration";
+}
+function isJSXElement(n) {
+  return isNode(n) && n.type === "JSXElement";
+}
+function isJSXFragment(n) {
+  return isNode(n) && n.type === "JSXFragment";
+}
+function isJSXIdentifier(n) {
+  return isNode(n) && n.type === "JSXIdentifier" && typeof n.name === "string";
+}
+function isJSXOpeningElement(n) {
+  return isNode(n) && n.type === "JSXOpeningElement";
+}
+function isJSXMemberExpression(n) {
+  return isNode(n) && n.type === "JSXMemberExpression";
+}
+function isJSXAttribute(n) {
+  return isNode(n) && n.type === "JSXAttribute";
+}
+function isJSXSpreadAttribute(n) {
+  return isNode(n) && n.type === "JSXSpreadAttribute";
+}
+function isJSXExpressionContainer(n) {
+  return isNode(n) && n.type === "JSXExpressionContainer";
+}
+function isJSXEmptyExpression(n) {
+  return isNode(n) && n.type === "JSXEmptyExpression";
+}
+function isTSNonNullExpression(n) {
+  return isNode(n) && n.type === "TSNonNullExpression";
+}
+function isTSAsExpression(n) {
+  return isNode(n) && n.type === "TSAsExpression";
+}
+function isTSTypeAssertion(n) {
+  return isNode(n) && n.type === "TSTypeAssertion";
+}
+function isTSSatisfiesExpression(n) {
+  return isNode(n) && n.type === "TSSatisfiesExpression";
+}
+function isTSTypeAnnotation(n) {
+  return isNode(n) && n.type === "TSTypeAnnotation";
+}
+function isExpression(n) {
+  if (!isNode(n))
+    return false;
+  switch (n.type) {
+    case "Identifier":
+    case "Literal":
+    case "ThisExpression":
+    case "ArrayExpression":
+    case "ObjectExpression":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+    case "ClassExpression":
+    case "UnaryExpression":
+    case "UpdateExpression":
+    case "BinaryExpression":
+    case "LogicalExpression":
+    case "AssignmentExpression":
+    case "MemberExpression":
+    case "ConditionalExpression":
+    case "CallExpression":
+    case "NewExpression":
+    case "SequenceExpression":
+    case "TemplateLiteral":
+    case "TaggedTemplateExpression":
+    case "YieldExpression":
+    case "AwaitExpression":
+    case "ImportExpression":
+    case "MetaProperty":
+    case "ChainExpression":
+    case "ParenthesizedExpression":
+    case "JSXElement":
+    case "JSXFragment":
+    case "TSAsExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "TSSatisfiesExpression":
+    case "TSInstantiationExpression":
+      return true;
+    default:
+      return false;
+  }
+}
+function importedBindingName(n) {
+  if (!n)
+    return null;
+  if (isIdentifier(n))
+    return n.name;
+  if (typeof n.value === "string")
+    return n.value;
+  return null;
+}
+function moduleSourceValue(n) {
+  if (!n)
+    return null;
+  return typeof n.value === "string" ? n.value : null;
+}
+function assertExpression(n) {
+  if (!isExpression(n)) {
+    throw new TypeError(`Expected Expression, got ${isNode(n) ? n.type : typeof n}`);
+  }
+}
+
+// src/ast/path.ts
+import { visitorKeys } from "oxc-parser";
+class Binding {
+  identifier;
+  path;
+  kind;
+  constant;
+  referenced = false;
+  referencePaths = [];
+  constantViolations = [];
+  constructor(identifier, path, kind) {
+    this.identifier = identifier;
+    this.path = path;
+    this.kind = kind;
+    this.constant = kind === "const" || kind === "module" || kind === "hoisted" || kind === "param";
+  }
+}
+
+class Scope {
+  path;
+  parent;
+  bindings = new Map;
+  constructor(path, parent = null) {
+    this.path = path;
+    this.parent = parent;
+  }
+  getBinding(name) {
+    let scope = this;
+    while (scope) {
+      const b = scope.bindings.get(name);
+      if (b)
+        return b;
+      scope = scope.parent;
+    }
+    return;
+  }
+  register(name, binding) {
+    this.bindings.set(name, binding);
+  }
+  crawl() {
+    this.bindings.clear();
+    seedScopeBindings(this);
+    markReferences(this.path);
+  }
+}
+function singlePath(path) {
+  if (Array.isArray(path)) {
+    throw new Error("Expected a single NodePath");
+  }
+  return path;
+}
+function keysFor(node) {
+  return visitorKeys[node.type] ?? [];
+}
+function isScopeNode(node) {
+  return isFunction(node) || node.type === "Program" || node.type === "BlockStatement" || node.type === "CatchClause" || node.type === "SwitchStatement" || node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement";
+}
+function lexicalScopeFor(kind, scope) {
+  if (kind !== "var")
+    return scope;
+  let current = scope;
+  while (current.parent && !isFunction(current.path.node) && current.path.node.type !== "Program") {
+    current = current.parent;
+  }
+  return current;
+}
+function registerVariableDeclaration(stmt, stmtPath, scope) {
+  if (!isVariableDeclaration(stmt))
+    return;
+  const kind = String(stmt.kind);
+  const target = lexicalScopeFor(kind, scope);
+  const decls = stmt.declarations;
+  for (let j = 0;j < decls.length; j++) {
+    registerPattern(decls[j].id, singlePath(stmtPath.get(`declarations.${j}`)), target, kind);
+  }
+}
+function isTypeOnlyImport(spec, stmt) {
+  const declarationKind = stmt.importKind;
+  const specifierKind = spec.importKind;
+  return declarationKind === "type" || specifierKind === "type";
+}
+function registerPattern(pattern, bindingPath, scope, kind) {
+  if (isIdentifier(pattern)) {
+    scope.register(pattern.name, new Binding(pattern, bindingPath, kind));
+    return;
+  }
+  if (isObjectPattern(pattern)) {
+    for (const prop of pattern.properties ?? []) {
+      if (isRestElement(prop)) {
+        registerPattern(prop.argument, bindingPath, scope, kind);
+      } else if (isObjectProperty(prop)) {
+        let value = prop.value;
+        if (isAssignmentPattern(value))
+          value = value.left;
+        registerPattern(value, bindingPath, scope, kind);
+      }
+    }
+    return;
+  }
+  if (isArrayPattern(pattern)) {
+    for (const el of pattern.elements ?? []) {
+      if (!el)
+        continue;
+      if (isRestElement(el)) {
+        registerPattern(el.argument, bindingPath, scope, kind);
+      } else if (isAssignmentPattern(el)) {
+        registerPattern(el.left, bindingPath, scope, kind);
+      } else {
+        registerPattern(el, bindingPath, scope, kind);
+      }
+    }
+  }
+}
+function seedScopeBindings(scope) {
+  const path = scope.path;
+  const node = path.node;
+  if (isFunction(node)) {
+    if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && isIdentifier(node.id)) {
+      scope.register(node.id.name, new Binding(node.id, singlePath(path.get("id")), "hoisted"));
+    }
+    for (let i = 0;i < node.params.length; i++) {
+      registerPattern(node.params[i], singlePath(path.get(`params.${i}`)), scope, "param");
+    }
+  }
+  if (node.type === "ForStatement" && isVariableDeclaration(node.init)) {
+    registerVariableDeclaration(node.init, singlePath(path.get("init")), scope);
+  }
+  if ((node.type === "ForInStatement" || node.type === "ForOfStatement") && isVariableDeclaration(node.left)) {
+    registerVariableDeclaration(node.left, singlePath(path.get("left")), scope);
+  }
+  if (node.type === "CatchClause" && node.param && typeof node.param === "object") {
+    registerPattern(node.param, singlePath(path.get("param")), scope, "const");
+  }
+  if (node.type === "SwitchStatement") {
+    const cases = node.cases ?? [];
+    for (let i = 0;i < cases.length; i++) {
+      const consequent = cases[i].consequent ?? [];
+      const casePath = singlePath(path.get(`cases.${i}`));
+      for (let j = 0;j < consequent.length; j++) {
+        const stmt = consequent[j];
+        if (!isVariableDeclaration(stmt))
+          continue;
+        registerVariableDeclaration(stmt, singlePath(casePath.get(`consequent.${j}`)), scope);
+      }
+    }
+  }
+  if (node.type === "Program" || node.type === "BlockStatement") {
+    const body = node.body ?? [];
+    for (let i = 0;i < body.length; i++) {
+      const stmt = body[i];
+      const stmtPath = singlePath(path.get(`body.${i}`));
+      if (isVariableDeclaration(stmt)) {
+        registerVariableDeclaration(stmt, stmtPath, scope);
+      } else if (isFunctionDeclaration(stmt) && isIdentifier(stmt.id)) {
+        scope.register(stmt.id.name, new Binding(stmt.id, stmtPath, "hoisted"));
+      } else if (isClassDeclaration(stmt) && isIdentifier(stmt.id)) {
+        scope.register(stmt.id.name, new Binding(stmt.id, stmtPath, "const"));
+      } else if (isImportDeclaration(stmt)) {
+        const specs = stmt.specifiers;
+        for (let j = 0;j < specs.length; j++) {
+          const spec = specs[j];
+          if (isTypeOnlyImport(spec, stmt))
+            continue;
+          if (isImportSpecifier(spec) || isImportDefaultSpecifier(spec) || isImportNamespaceSpecifier(spec)) {
+            const local = spec.local;
+            scope.register(local.name, new Binding(local, singlePath(stmtPath.get(`specifiers.${j}`)), "module"));
+          }
+        }
+      } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && isFunctionDeclaration(stmt.declaration) && isIdentifier(stmt.declaration.id)) {
+        const fnId = stmt.declaration.id;
+        scope.register(fnId.name, new Binding(fnId, singlePath(stmtPath.get("declaration")), "hoisted"));
+      } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && isClassDeclaration(stmt.declaration) && isIdentifier(stmt.declaration.id)) {
+        const classId = stmt.declaration.id;
+        scope.register(classId.name, new Binding(classId, singlePath(stmtPath.get("declaration")), "const"));
+      } else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && isVariableDeclaration(stmt.declaration)) {
+        const decl = stmt.declaration;
+        const kind = String(decl.kind);
+        const decls = decl.declarations;
+        const declPath = singlePath(stmtPath.get("declaration"));
+        for (let j = 0;j < decls.length; j++) {
+          registerPattern(decls[j].id, singlePath(declPath.get(`declarations.${j}`)), scope, kind);
+        }
+      }
+    }
+  }
+}
+function markReferences(root) {
+  const stack = [];
+  const visit = (path) => {
+    stack.push(path);
+    if (isIdentifier(path.node) && path.isReferencedIdentifier()) {
+      const binding = path.scope.getBinding(path.node.name);
+      if (binding) {
+        binding.referenced = true;
+        binding.referencePaths.push(path);
+      }
+    }
+    if (path.node.type === "AssignmentExpression" && isIdentifier(path.node.left)) {
+      const binding = path.scope.getBinding(path.node.left.name);
+      if (binding) {
+        binding.constant = false;
+        binding.constantViolations.push(path);
+      }
+    }
+    if (path.node.type === "UpdateExpression" && isIdentifier(path.node.argument)) {
+      const binding = path.scope.getBinding(path.node.argument.name);
+      if (binding) {
+        binding.constant = false;
+        binding.constantViolations.push(path);
+      }
+    }
+    for (const key of keysFor(path.node)) {
+      const child = path.node[key];
+      if (Array.isArray(child)) {
+        for (let i = 0;i < child.length; i++) {
+          const c = child[i];
+          if (!c || typeof c !== "object" || !("type" in c))
+            continue;
+          visit(childPath(path, key, i, c));
+        }
+      } else if (child && typeof child === "object" && "type" in child) {
+        visit(childPath(path, key, null, child));
+      }
+    }
+    stack.pop();
+  };
+  visit(root);
+}
+function childPath(parent, key, index, node) {
+  let scope = parent.scope;
+  if (isScopeNode(node)) {
+    scope = new Scope(parent, parent.scope);
+  }
+  let path;
+  if (index !== null) {
+    path = new Path(node, parent.node, parent, index, parent.node[key], key, scope);
+  } else {
+    path = new Path(node, parent.node, parent, key, parent.node, null, scope);
+  }
+  if (isScopeNode(node)) {
+    scope.path = path;
+    seedScopeBindings(scope);
+  }
+  return path;
+}
+
+class Path {
+  node;
+  parent;
+  parentPath;
+  key;
+  container;
+  listKey;
+  scope;
+  _skip = false;
+  _stop = false;
+  _removed = false;
+  _hubEmpty = false;
+  constructor(node, parent, parentPath, key, container, listKey, scope) {
+    this.node = node;
+    this.parent = parent;
+    this.parentPath = parentPath;
+    this.key = key;
+    this.container = container;
+    this.listKey = listKey;
+    this.scope = scope ?? new Scope(this, parentPath?.scope ?? null);
+  }
+  skip() {
+    this._skip = true;
+  }
+  stop() {
+    this._stop = true;
+  }
+  get shouldSkip() {
+    return this._skip;
+  }
+  get shouldStop() {
+    return this._stop;
+  }
+  get(dotPath) {
+    const parts = dotPath.split(".");
+    let current = this;
+    for (const part of parts) {
+      if (Array.isArray(current)) {
+        current = current[Number(part)];
+        continue;
+      }
+      const node = current.node;
+      if (/^\d+$/.test(part)) {
+        throw new Error(`Unexpected index without array at ${dotPath}`);
+      }
+      const value = node[part];
+      if (Array.isArray(value)) {
+        const paths = [];
+        for (let i = 0;i < value.length; i++) {
+          const c = value[i];
+          if (!c || typeof c !== "object" || !("type" in c))
+            continue;
+          let childScope = current.scope;
+          let childPath;
+          if (isScopeNode(c)) {
+            childScope = new Scope(current, current.scope);
+            childPath = new Path(c, node, current, i, value, part, childScope);
+            childScope.path = childPath;
+            childScope.crawl();
+          } else {
+            childPath = new Path(c, node, current, i, value, part, childScope);
+          }
+          paths.push(childPath);
+        }
+        current = paths;
+        continue;
+      }
+      if (value && typeof value === "object" && "type" in value) {
+        const childNode = value;
+        let childScope = current.scope;
+        if (isScopeNode(childNode)) {
+          childScope = new Scope(current, current.scope);
+          const tmp = new Path(childNode, node, current, part, node, null, childScope);
+          childScope.path = tmp;
+          childScope.crawl();
+          current = tmp;
+        } else {
+          current = new Path(childNode, node, current, part, node, null, childScope);
+        }
+      } else {
+        const empty = new Path({ type: "EmptyStatement" }, node, current, part, node, null, current.scope);
+        empty._hubEmpty = true;
+        current = empty;
+      }
+    }
+    return current;
+  }
+  getFunctionParent() {
+    let cur = this.parentPath;
+    while (cur) {
+      if (isFunction(cur.node))
+        return cur;
+      cur = cur.parentPath;
+    }
+    return null;
+  }
+  findParent(pred) {
+    let cur = this.parentPath;
+    while (cur) {
+      if (pred(cur))
+        return cur;
+      cur = cur.parentPath;
+    }
+    return null;
+  }
+  replaceWith(replacement) {
+    if (this.parent == null || this.key == null) {
+      throw new Error("Cannot replace root");
+    }
+    if (Array.isArray(this.container) && typeof this.key === "number") {
+      this.container[this.key] = replacement;
+    } else if (typeof this.key === "string") {
+      this.parent[this.key] = replacement;
+    }
+    this.node = replacement;
+  }
+  replaceWithMultiple(nodes) {
+    if (!Array.isArray(this.container) || typeof this.key !== "number") {
+      throw new Error("replaceWithMultiple requires a list path");
+    }
+    this.container.splice(this.key, 1, ...nodes);
+    this._removed = true;
+  }
+  traverse(visitors) {
+    for (const key of keysFor(this.node)) {
+      const child = this.node[key];
+      if (Array.isArray(child)) {
+        for (let i = 0;i < child.length; ) {
+          const c = child[i];
+          if (!c || typeof c !== "object" || !("type" in c)) {
+            i += 1;
+            continue;
+          }
+          const childP = new Path(c, this.node, this, i, child, key, this.scope);
+          const stopped = traverseInner(childP, visitors, false);
+          if (stopped || this.shouldStop)
+            return;
+          if (child[i] === c)
+            i += 1;
+        }
+      } else if (child && typeof child === "object" && "type" in child) {
+        const childP = new Path(child, this.node, this, key, this.node, null, this.scope);
+        const stopped = traverseInner(childP, visitors, false);
+        if (stopped || this.shouldStop)
+          return;
+      }
+    }
+  }
+  isReferencedIdentifier() {
+    if (!isIdentifier(this.node))
+      return false;
+    const parent = this.parent;
+    if (!parent)
+      return true;
+    if (this.listKey === "params")
+      return false;
+    if (isVariableDeclarator(parent) && this.key === "id")
+      return false;
+    if (isFunction(parent) && this.key === "id")
+      return false;
+    if ((parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && this.key === "id")
+      return false;
+    if ((parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") && this.key === "key" && parent.computed !== true)
+      return false;
+    if (isFunction(parent) && this.key === "params")
+      return false;
+    if ((isImportSpecifier(parent) || isImportDefaultSpecifier(parent) || isImportNamespaceSpecifier(parent)) && this.key === "local")
+      return false;
+    if (isObjectProperty(parent) && this.key === "key" && !parent.computed && !parent.shorthand)
+      return false;
+    if (isMemberExpression(parent) && this.key === "property" && !parent.computed)
+      return false;
+    if (parent.type === "Property" && this.key === "key" && !parent.computed)
+      return false;
+    if (isAssignmentPattern(parent) && this.key === "left")
+      return false;
+    if (isRestElement(parent)) {
+      const gp = this.parentPath?.parent;
+      if (gp && (isObjectPattern(gp) || isArrayPattern(gp)))
+        return false;
+    }
+    if (isObjectPattern(parent) || isArrayPattern(parent))
+      return false;
+    if (isObjectProperty(parent) && this.key === "value" && this.parentPath?.parent && (isObjectPattern(this.parentPath.parent) || isArrayPattern(this.parentPath.parent)))
+      return false;
+    if (isObjectProperty(parent) && parent.shorthand && (this.key === "key" || this.key === "value")) {
+      const gp = this.parentPath?.parent;
+      if (gp && isObjectPattern(gp))
+        return false;
+      return true;
+    }
+    if (parent.type === "CatchClause" && this.key === "param")
+      return false;
+    if (parent.type === "JSXAttribute" && this.key === "name")
+      return false;
+    if ((parent.type === "JSXOpeningElement" || parent.type === "JSXClosingElement") && this.key === "name")
+      return false;
+    if (parent.type === "JSXMemberExpression" && this.key === "property")
+      return false;
+    return true;
+  }
+  isFunction() {
+    return isFunction(this.node);
+  }
+  isIdentifier(opts) {
+    return isIdentifier(this.node, opts);
+  }
+  isLiteral() {
+    return isLiteral(this.node);
+  }
+  isCallExpression() {
+    return isCallExpression(this.node);
+  }
+  isOptionalCallExpression() {
+    return isOptionalCallExpression(this.node);
+  }
+  isMemberExpression() {
+    return isMemberExpression(this.node);
+  }
+  isOptionalMemberExpression() {
+    return isOptionalMemberExpression(this.node);
+  }
+  isObjectProperty(opts) {
+    if (!isObjectProperty(this.node))
+      return false;
+    if (opts?.shorthand !== undefined)
+      return this.node.shorthand === opts.shorthand;
+    return true;
+  }
+  isObjectExpression() {
+    return isObjectExpression(this.node);
+  }
+  isParenthesizedExpression() {
+    return isParenthesizedExpression(this.node);
+  }
+  isIfStatement() {
+    return this.node.type === "IfStatement";
+  }
+  isObjectPattern() {
+    return isObjectPattern(this.node);
+  }
+  isArrayExpression() {
+    return this.node.type === "ArrayExpression";
+  }
+  isArrayPattern() {
+    return isArrayPattern(this.node);
+  }
+  isVariableDeclarator() {
+    return isVariableDeclarator(this.node);
+  }
+  isVariableDeclaration(opts) {
+    return isVariableDeclaration(this.node, opts);
+  }
+  isImportSpecifier() {
+    return isImportSpecifier(this.node);
+  }
+  isImportDefaultSpecifier() {
+    return isImportDefaultSpecifier(this.node);
+  }
+  isImportDeclaration() {
+    return isImportDeclaration(this.node);
+  }
+  isJSXElement() {
+    return isJSXElement(this.node);
+  }
+  isJSXFragment() {
+    return isJSXFragment(this.node);
+  }
+  isJSXExpressionContainer() {
+    return isJSXExpressionContainer(this.node);
+  }
+  isJSXAttribute() {
+    return isJSXAttribute(this.node);
+  }
+  isBlockStatement() {
+    return isBlockStatement(this.node);
+  }
+  isArrowFunctionExpression() {
+    return isArrowFunctionExpression(this.node);
+  }
+  isFunctionExpression() {
+    return isFunctionExpression(this.node);
+  }
+  isFunctionDeclaration() {
+    return isFunctionDeclaration(this.node);
+  }
+  isSpreadElement() {
+    return isSpreadElement(this.node);
+  }
+  isTemplateLiteral() {
+    return isTemplateLiteral(this.node);
+  }
+  isTemplateElement() {
+    return this.node.type === "TemplateElement";
+  }
+  isBinaryExpression() {
+    return this.node.type === "BinaryExpression";
+  }
+  isLogicalExpression() {
+    return this.node.type === "LogicalExpression";
+  }
+  isConditionalExpression() {
+    return this.node.type === "ConditionalExpression";
+  }
+  isUnaryExpression(opts) {
+    if (this.node.type !== "UnaryExpression")
+      return false;
+    if (opts?.operator !== undefined)
+      return this.node.operator === opts.operator;
+    return true;
+  }
+  isUpdateExpression() {
+    return this.node.type === "UpdateExpression";
+  }
+  isAssignmentExpression() {
+    return this.node.type === "AssignmentExpression";
+  }
+  isForInStatement() {
+    return this.node.type === "ForInStatement";
+  }
+  isForOfStatement() {
+    return this.node.type === "ForOfStatement";
+  }
+  isTSType() {
+    return this.node.type.startsWith("TS") && !isTSAsExpression(this.node) && !isTSTypeAssertion(this.node) && !isTSNonNullExpression(this.node) && !isTSSatisfiesExpression(this.node);
+  }
+  isTSAsExpression() {
+    return isTSAsExpression(this.node);
+  }
+  isTSTypeAssertion() {
+    return isTSTypeAssertion(this.node);
+  }
+  isTSNonNullExpression() {
+    return isTSNonNullExpression(this.node);
+  }
+  isTSSatisfiesExpression() {
+    return isTSSatisfiesExpression(this.node);
+  }
+  isProgram() {
+    return this.node.type === "Program";
+  }
+  assertExpression() {
+    if (this._hubEmpty)
+      throw new TypeError("Expected Expression");
+    assertExpression(this.node);
+  }
+}
+function aliasesFor(type) {
+  switch (type) {
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+      return ["Function"];
+    case "Property":
+      return ["ObjectProperty"];
+    case "Literal":
+      return [];
+    default:
+      return [];
+  }
+}
+function runVisitor(visitors, type, path, phase) {
+  const names = [type, ...aliasesFor(type)];
+  for (const key of Object.keys(visitors)) {
+    if (key.includes("|")) {
+      for (const part of key.split("|")) {
+        if (part === type || aliasesFor(type).includes(part)) {
+          names.push(key);
+          break;
+        }
+      }
+    }
+  }
+  const seen = new Set;
+  for (const name of names) {
+    if (seen.has(name))
+      continue;
+    seen.add(name);
+    const v = visitors[name];
+    if (!v)
+      continue;
+    if (typeof v === "function") {
+      if (phase === "enter")
+        v(path);
+    } else if (phase === "enter" && v.enter) {
+      v.enter(path);
+    } else if (phase === "exit" && v.exit) {
+      v.exit(path);
+    }
+  }
+  if (phase === "enter" && typeof visitors.enter === "function") {
+    visitors.enter(path);
+  }
+}
+function traverseInner(path, visitors, isRoot) {
+  if (isScopeNode(path.node) && path.parentPath) {
+    const scoped = new Scope(path, path.parentPath.scope ?? null);
+    path.scope = scoped;
+    seedScopeBindings(scoped);
+  }
+  path._skip = false;
+  runVisitor(visitors, path.node.type, path, "enter");
+  if (path.shouldStop)
+    return true;
+  if (!path.shouldSkip && !path._removed) {
+    for (const key of keysFor(path.node)) {
+      const child = path.node[key];
+      if (Array.isArray(child)) {
+        const seen = new WeakSet;
+        for (let i = 0;i < child.length; ) {
+          const c = child[i];
+          if (!c || typeof c !== "object" || !("type" in c)) {
+            i += 1;
+            continue;
+          }
+          if (seen.has(c)) {
+            i += 1;
+            continue;
+          }
+          seen.add(c);
+          const childP = new Path(c, path.node, path, i, child, key, path.scope);
+          const stopped = traverseInner(childP, visitors, false);
+          if (stopped || path.shouldStop)
+            return true;
+          if (child[i] === c)
+            i += 1;
+        }
+      } else if (child && typeof child === "object" && "type" in child) {
+        const childP = new Path(child, path.node, path, key, path.node, null, path.scope);
+        const stopped = traverseInner(childP, visitors, false);
+        if (stopped || path.shouldStop)
+          return true;
+      }
+    }
+  }
+  runVisitor(visitors, path.node.type, path, "exit");
+  return path.shouldStop;
+}
+function traverse(ast, visitors) {
+  const root = ast.type === "File" && ast.program ? ast.program : ast;
+  const rootPath = new Path(root, null, null, null, null, null, undefined);
+  rootPath.scope = new Scope(rootPath, null);
+  rootPath.scope.crawl();
+  traverseInner(rootPath, visitors, true);
+}
+// src/auto-cc.ts
+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 (isJSXElement(node) || isJSXFragment(node))
+    return true;
+  if (!enterFunctions && (isFunctionExpression(node) || isArrowFunctionExpression(node) || 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 (isArrowFunctionExpression(fn) && !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 (isFunctionDeclaration(fn) && fn.generator)
+    return false;
+  if ((isFunctionExpression(fn) || isArrowFunctionExpression(fn)) && fn.generator) {
+    return false;
+  }
+  return fn.params.length <= 1;
+}
+function collectCcAliases(ast) {
+  const aliases = new Set;
+  traverse(ast, {
+    ImportDeclaration(path) {
+      const source = moduleSourceValue(path.node.source);
+      if (!source)
+        return;
+      if (!CC_SOURCE_MODULES.has(source))
+        return;
+      for (const spec of path.node.specifiers ?? []) {
+        if (!isImportSpecifier(spec))
+          continue;
+        const imported = importedBindingName(spec.imported);
+        if (imported === "cc") {
+          aliases.add(spec.local.name);
+        }
+      }
+    }
+  });
+  return { aliases, alreadyImported: aliases.size > 0 };
+}
+function unwrapFunctionPath(fnPath) {
+  let current = fnPath;
+  while (current && isParenthesizedExpression(current.node)) {
+    current = singlePath(current.get("expression"));
+  }
+  return current;
+}
+function ccCall(arg, ccName) {
+  return callExpression(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;
+  };
+  traverse(ast, {
+    ExportNamedDeclaration(path) {
+      const decl = path.node.declaration;
+      if (!decl)
+        return;
+      if (isFunctionDeclaration(decl) && isIdentifier(decl.id)) {
+        const name = decl.id.name;
+        const fnPath = path.get("declaration");
+        if (!wrapIfCandidate(fnPath, name))
+          return;
+        const fnExpr = functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const varDecl = variableDeclaration("const", [
+          variableDeclarator(identifier(name), ccCall(fnExpr, ccName ?? "cc"))
+        ]);
+        path.replaceWith(exportNamedDeclaration(varDecl, []));
+        changed = true;
+        return;
+      }
+      if (isVariableDeclaration(decl)) {
+        for (const dPath of path.get("declaration.declarations")) {
+          const id = dPath.node.id;
+          if (!isIdentifier(id) || !isComponentName(id.name))
+            continue;
+          const init = dPath.node.init ? unwrapParens(dPath.node.init) : dPath.node.init;
+          if (!init)
+            continue;
+          let initPath = unwrapFunctionPath(dPath.get("init"));
+          if (isCallExpression(initPath.node) && isIdentifier(initPath.node.callee) && aliases.has(initPath.node.callee.name)) {
+            continue;
+          }
+          if (!isFunction(initPath.node))
+            continue;
+          if (!wrapIfCandidate(initPath, id.name))
+            continue;
+          dPath.node.init = ccCall(initPath.node, ccName ?? "cc");
+          changed = true;
+        }
+        return;
+      }
+    },
+    ExportDefaultDeclaration(path) {
+      const decl = isNode(path.node.declaration) ? unwrapParens(path.node.declaration) : path.node.declaration;
+      if (isFunctionDeclaration(decl) && isIdentifier(decl.id)) {
+        const name = decl.id.name;
+        const fnPath = path.get("declaration");
+        if (!wrapIfCandidate(fnPath, name))
+          return;
+        const fnDecl = functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const exportDefault = exportDefaultDeclaration(ccCall(identifier(name), ccName ?? "cc"));
+        path.replaceWithMultiple([fnDecl, exportDefault]);
+        changed = true;
+        return;
+      }
+      if (isFunctionDeclaration(decl) && !decl.id) {
+        const fnPath = path.get("declaration");
+        if (!wrapIfCandidate(fnPath, null))
+          return;
+        const fnExpr = functionExpression(null, decl.params, decl.body, decl.generator, decl.async);
+        path.node.declaration = ccCall(fnExpr, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+      if (isArrowFunctionExpression(decl) || isFunctionExpression(decl)) {
+        const declPath = unwrapFunctionPath(path.get("declaration"));
+        if (!isFunction(declPath.node))
+          return;
+        if (!wrapIfCandidate(declPath, null))
+          return;
+        path.node.declaration = ccCall(declPath.node, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+    }
+  });
+  if (changed && !alreadyImported) {
+    ast.program.body.unshift(importDeclaration([importSpecifier(identifier("cc"), identifier("cc"))], stringLiteral("sinwan/component")));
+  }
+  return changed;
+}
+
+// src/reactive-wrap.ts
+import * as path2 from "path";
+
+// src/ast/parse.ts
+import { parseSync } from "oxc-parser";
+
+// src/ast/node.ts
+function isAstNode(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string";
+}
+
+// src/ast/parse.ts
+function containsSpan(node, start, end) {
+  const nodeStart = node.start ?? -1;
+  const nodeEnd = node.end ?? -1;
+  return nodeStart <= start && nodeEnd >= end;
+}
+function attachComments(program, comments) {
+  if (comments.length === 0)
+    return;
+  const nodes = [];
+  const visit = (node) => {
+    if (typeof node.start === "number" && typeof node.end === "number") {
+      nodes.push(node);
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "leadingComments" || key === "trailingComments" || key === "innerComments")
+        continue;
+      const val = node[key];
+      if (Array.isArray(val)) {
+        for (const item of val) {
+          if (item && typeof item === "object" && "type" in item) {
+            visit(item);
+          }
+        }
+      } else if (val && typeof val === "object" && "type" in val) {
+        visit(val);
+      }
+    }
+  };
+  visit(program);
+  nodes.sort((a, b) => {
+    const ds = (a.start ?? 0) - (b.start ?? 0);
+    if (ds !== 0)
+      return ds;
+    return (b.end ?? 0) - (a.end ?? 0);
+  });
+  for (const comment of comments) {
+    const mapped = {
+      type: comment.type === "Line" ? "CommentLine" : "CommentBlock",
+      value: comment.value
+    };
+    let container = null;
+    let containerSpan = Number.POSITIVE_INFINITY;
+    for (const node of nodes) {
+      if (node.type === "Program")
+        continue;
+      if (!containsSpan(node, comment.start, comment.end))
+        continue;
+      const span = (node.end ?? 0) - (node.start ?? 0);
+      if (span < containerSpan) {
+        container = node;
+        containerSpan = span;
+      }
+    }
+    const commentIsNode = container != null && (container.type === "JSXEmptyExpression" || (container.start ?? -1) === comment.start && (container.end ?? -1) === comment.end);
+    if (commentIsNode && container) {
+      const list = container.leadingComments ??= [];
+      list.push(mapped);
+      continue;
+    }
+    let leading = null;
+    for (const node of nodes) {
+      if (node.type === "Program" || node === container)
+        continue;
+      const start = node.start ?? 0;
+      if (start < comment.end)
+        continue;
+      if (container && !containsSpan(container, node.start ?? 0, node.end ?? 0)) {
+        continue;
+      }
+      leading = node;
+      break;
+    }
+    if (leading) {
+      const list = leading.leadingComments ??= [];
+      list.push(mapped);
+      continue;
+    }
+    if (container) {
+      const list = container.innerComments ??= [];
+      list.push(mapped);
+      continue;
+    }
+    const list = program.trailingComments ??= [];
+    list.push(mapped);
+  }
+}
+function asProgram(parsed) {
+  if (!isAstNode(parsed) || parsed.type !== "Program" || !Array.isArray(parsed.body)) {
+    throw new Error("oxc-parser did not return a Program");
+  }
+  return {
+    ...parsed,
+    type: "Program",
+    body: parsed.body,
+    sourceType: parsed.sourceType === "script" ? "script" : "module"
+  };
+}
+function parse(code, options = {}) {
+  const filename = options.sourceFilename ?? "unknown.tsx";
+  const sourceType = options.sourceType === "script" ? "script" : options.sourceType === "unambiguous" ? "unambiguous" : "module";
+  const result = parseSync(filename, code, {
+    lang: "tsx",
+    sourceType
+  });
+  if (result.errors.length > 0 && !options.errorRecovery) {
+    throw new Error(result.errors[0].message);
+  }
+  const program = asProgram(result.program);
+  const comments = result.comments ?? [];
+  attachComments(program, comments);
+  return {
+    type: "File",
+    program,
+    comments: comments.map((c) => ({
+      type: c.type === "Line" ? "CommentLine" : "CommentBlock",
+      value: c.value
+    }))
+  };
+}
+
+// src/reactive-wrap.ts
+import * as fs2 from "fs";
+
+// src/analyze.ts
+import * as fs from "fs";
+import * as path from "path";
+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;
+  traverse(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;
+  traverse(ast, {
+    ImportDeclaration(path) {
+      const source = moduleSourceValue(path.node.source);
+      if (!source)
+        return;
+      for (const spec of path.node.specifiers) {
+        if (isImportSpecifier(spec)) {
+          const localName = spec.local.name;
+          const importedName = importedBindingName(spec.imported);
+          if (!importedName)
+            continue;
+          imports.set(localName, { source, importedName });
+        } else if (isImportDefaultSpecifier(spec)) {
+          imports.set(spec.local.name, { source, importedName: "default" });
+        }
+      }
+    }
+  });
+  return imports;
+}
+function collectImportedCallSites(ast, componentNames, imports) {
+  const sites = [];
+  traverse(ast, {
+    JSXElement(path) {
+      const name = path.node.openingElement.name;
+      if (!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 (isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of path.node.children) {
+        if (isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || 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: 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);
+    }
+  }
+  traverse(ast, {
+    ExportDefaultDeclaration(path) {
+      const decl = isNode(path.node.declaration) ? unwrapParens(path.node.declaration) : path.node.declaration;
+      if (isIdentifier(decl)) {
+        const fn = componentNames.get(decl.name);
+        if (fn)
+          defaultExport = fn;
+      } else if (isCallExpression(decl)) {
+        const callee = decl.callee;
+        if (isIdentifier(callee) && names.cc.has(callee.name)) {
+          const firstArg = decl.arguments[0];
+          const fnArg = firstArg && isNode(firstArg) ? unwrapParens(firstArg) : firstArg;
+          if (fnArg && isFunction(fnArg)) {
+            defaultExport = fnArg;
+          }
+        }
+      }
+    }
+  });
+  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 = path.dirname(tsConfigPath);
+    const resolvedBase = baseUrl ? path.resolve(root, baseUrl) : root;
+    const result = new Map;
+    for (const [pattern, mappings] of Object.entries(paths)) {
+      result.set(pattern, mappings.map((m) => path.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 = path.resolve(path.dirname(fromFile), source);
+  const candidates = [
+    ...extensions.map((ext) => base + ext),
+    ...extensions.map((ext) => path.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 path.resolve(root, target);
+    }
+    if (source.startsWith(alias + "/")) {
+      return path.resolve(root, target, source.slice(alias.length + 1));
+    }
+  }
+  return null;
+}
+function resolveWithExtensions(mapped, extensions) {
+  const candidates = [
+    ...extensions.map((ext) => mapped + ext),
+    ...extensions.map((ext) => path.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(path.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(path.join(matchedPkg, "package.json"), "utf-8"));
+    if (pkgJson.source) {
+      sourceDir = path.dirname(path.resolve(matchedPkg, pkgJson.source));
+    } else {
+      sourceDir = path.join(matchedPkg, "src");
+    }
+  } catch {
+    sourceDir = path.join(matchedPkg, "src");
+  }
+  const targetBase = subpath ? path.join(sourceDir, subpath) : path.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 = path.resolve(cwd, pattern);
+  const parts = fullPattern.split(path.sep);
+  const wildcardIndex = parts.findIndex((p) => p.includes("*"));
+  if (wildcardIndex === -1) {
+    return fs.existsSync(fullPattern) ? [fullPattern] : [];
+  }
+  const prefix = parts.slice(0, wildcardIndex).join(path.sep);
+  const suffixParts = parts.slice(wildcardIndex + 1);
+  const suffix = suffixParts.join(path.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 = path.join(prefix, entry.name, suffix);
+    results.push(...expandGlob(candidate, cwd));
+  }
+  return results;
+}
+function loadWorkspacePackages(workspaces, root) {
+  const patternEntries = [];
+  if (typeof workspaces === "string") {
+    const resolved = path.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 = path.dirname(resolved);
+        for (const p of loadPackageJsonWorkspaces(resolved)) {
+          patternEntries.push({ pattern: p, base });
+        }
+      } else if (resolved.endsWith("pnpm-workspace.yaml")) {
+        const base = path.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 = path.resolve(root, workspaces.file);
+      if (resolved.endsWith("package.json")) {
+        const base = path.dirname(resolved);
+        for (const p of loadPackageJsonWorkspaces(resolved)) {
+          patternEntries.push({ pattern: p, base });
+        }
+      } else if (resolved.endsWith("pnpm-workspace.yaml")) {
+        const base = path.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 = path.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 = path.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 = path.resolve(path.dirname(fromFile), source);
+        for (const ext of this.extensions) {
+          if (this.modules.has(base + ext))
+            return base + ext;
+          const indexCandidate = path.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 = path.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 ?? path.join(options.root, "tsconfig.json");
+  const bunfigPath = options.bunfigPath ?? path.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 = path.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/reactive-wrap.ts
+var REACTIVE_SOURCE_MODULES = {
+  sinway: new Set(["createMutable", "createStore"]),
+  "sinwan/reactivity": new Set(["signal", "computed"]),
+  "sinwan/react": new Set(["useState"]),
+  "sinwan/hook": new Set(["useFetch"])
+};
+function addImportLocal(names, imported, local) {
+  switch (imported) {
+    case "createMutable":
+    case "createStore":
+    case "signal":
+    case "computed":
+    case "useState":
+    case "useFetch":
+    case "cc":
+      names[imported].add(local);
+      break;
+  }
+}
+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 = unwrapParens(expr);
+  while (isTSNonNullExpression(node)) {
+    node = node.expression;
+  }
+  if (!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 = moduleSourceValue(path.node.source);
+      if (!source)
+        return;
+      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
+      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
+      if (!reactiveAllowed && !componentAllowed)
+        return;
+      for (const spec of path.node.specifiers ?? []) {
+        if (!isImportSpecifier(spec))
+          continue;
+        const imported = importedBindingName(spec.imported);
+        if (imported && reactiveAllowed?.has(imported)) {
+          addImportLocal(names, imported, spec.local.name);
+        } else if (imported && componentAllowed?.has(imported)) {
+          names.cc.add(spec.local.name);
+        }
+      }
+    }
+  });
+  return names;
+}
+var pureImportCache = new Map;
+var PURE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts"
+];
+function tryResolveFile(base) {
+  if (PURE_EXTENSIONS.some((ext) => base.endsWith(ext))) {
+    try {
+      if (fs2.existsSync(base))
+        return base;
+    } catch {}
+    return null;
+  }
+  for (const ext of PURE_EXTENSIONS) {
+    try {
+      if (fs2.existsSync(base + ext))
+        return base + ext;
+    } catch {}
+  }
+  return null;
+}
+function tryResolveIndex(dir) {
+  for (const ext of PURE_EXTENSIONS) {
+    try {
+      const candidate = path2.join(dir, "index") + ext;
+      if (fs2.existsSync(candidate))
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+function tryResolveRelative(source, fromFile) {
+  const base = path2.resolve(path2.dirname(fromFile), source);
+  return tryResolveFile(base) ?? tryResolveIndex(base);
+}
+function tryResolveBare(source, fromFile) {
+  const parts = source.split("/");
+  const pkgName = source.startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+  const subpath = parts.slice(source.startsWith("@") ? 2 : 1).join("/");
+  let dir = path2.dirname(fromFile);
+  for (let i = 0;i < 30; i++) {
+    const nodeModules = path2.join(dir, "node_modules", pkgName);
+    if (fs2.existsSync(nodeModules)) {
+      return resolvePackageEntry(nodeModules, subpath);
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function resolvePackageEntry(pkgDir, subpath) {
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(fs2.readFileSync(path2.join(pkgDir, "package.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof pkgJson.exports === "object" && pkgJson.exports) {
+    const exports = pkgJson.exports;
+    const exportKey = subpath ? `./${subpath}` : ".";
+    const entry = exports[exportKey];
+    if (typeof entry === "string") {
+      const resolved = tryResolveFile(path2.resolve(pkgDir, entry));
+      if (resolved)
+        return resolved;
+    } else if (entry && typeof entry === "object") {
+      for (const condValue of Object.values(entry)) {
+        if (typeof condValue === "string") {
+          const resolved = tryResolveFile(path2.resolve(pkgDir, condValue));
+          if (resolved)
+            return resolved;
+        }
+      }
+    }
+  }
+  if (!subpath) {
+    for (const field of ["source", "module", "main", "types"]) {
+      const entry = pkgJson[field];
+      if (typeof entry === "string") {
+        const resolved = tryResolveFile(path2.resolve(pkgDir, entry));
+        if (resolved)
+          return resolved;
+      }
+    }
+    const indexResolved = tryResolveIndex(pkgDir);
+    if (indexResolved)
+      return indexResolved;
+  }
+  if (subpath) {
+    for (const srcDir of ["src", "dist", "."]) {
+      const base = path2.join(pkgDir, srcDir, subpath);
+      const resolved = tryResolveFile(base) ?? tryResolveIndex(base);
+      if (resolved)
+        return resolved;
+    }
+  }
+  return null;
+}
+function resolveAnyImport(source, fromFile, resolveImport) {
+  if (resolveImport) {
+    try {
+      const resolved = resolveImport(source, fromFile);
+      if (resolved)
+        return resolved;
+    } catch {}
+  }
+  if (source.startsWith(".")) {
+    return tryResolveRelative(source, fromFile);
+  }
+  return tryResolveBare(source, fromFile);
+}
+function scanPureExports(filePath, resolveImport, depth = 0) {
+  const pure = new Map;
+  if (depth > 10)
+    return pure;
+  let code;
+  try {
+    code = fs2.readFileSync(filePath, "utf-8");
+  } catch {
+    return pure;
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      sourceFilename: filePath
+    });
+  } catch {
+    return pure;
+  }
+  const hasPureJSDoc = (node) => node?.leadingComments?.some((c) => c.type === "CommentBlock" && c.value.includes("@sinwan-pure")) ?? false;
+  traverse(ast, {
+    ExportNamedDeclaration(p) {
+      if (hasPureJSDoc(p.node)) {
+        const decl = p.node.declaration;
+        if (isFunctionDeclaration(decl) && isIdentifier(decl.id)) {
+          pure.set(decl.id.name, "function");
+        } else if (isClassDeclaration(decl) && isIdentifier(decl.id)) {
+          pure.set(decl.id.name, "class");
+        } else if (isVariableDeclaration(decl)) {
+          for (const d of decl.declarations) {
+            if (!isIdentifier(d.id))
+              continue;
+            const init = d.init;
+            if (isObjectExpression(init)) {
+              pure.set(d.id.name, "object");
+            } else {
+              pure.set(d.id.name, "function");
+            }
+          }
+        }
+      }
+      const source = moduleSourceValue(p.node.source);
+      if (source && p.node.specifiers) {
+        const resolved = resolveAnyImport(source, filePath, resolveImport);
+        if (resolved) {
+          let reExportPure = pureImportCache.get(resolved);
+          if (!reExportPure) {
+            reExportPure = scanPureExports(resolved, resolveImport, depth + 1);
+            pureImportCache.set(resolved, reExportPure);
+          }
+          for (const spec of p.node.specifiers ?? []) {
+            if (!isExportSpecifier(spec))
+              continue;
+            const exported = isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+            const original = spec.local.name;
+            const kind = reExportPure.get(original);
+            if (kind) {
+              pure.set(exported, kind);
+            }
+          }
+        }
+      }
+    },
+    ExportDefaultDeclaration(p) {
+      if (!hasPureJSDoc(p.node))
+        return;
+      const decl = p.node.declaration;
+      if (isFunctionDeclaration(decl) || isArrowFunctionExpression(decl) || isFunctionExpression(decl)) {
+        pure.set("default", "function");
+      } else if (isClassDeclaration(decl)) {
+        pure.set("default", "class");
+      }
+    },
+    ExportAllDeclaration(p) {
+      const source = moduleSourceValue(p.node.source);
+      if (!source)
+        return;
+      const resolved = resolveAnyImport(source, filePath, resolveImport);
+      if (!resolved)
+        return;
+      let reExportPure = pureImportCache.get(resolved);
+      if (!reExportPure) {
+        reExportPure = scanPureExports(resolved, resolveImport, depth + 1);
+        pureImportCache.set(resolved, reExportPure);
+      }
+      for (const [name, kind] of reExportPure) {
+        if (name !== "default") {
+          pure.set(name, kind);
+        }
+      }
+    }
+  });
+  return pure;
+}
+function collectPureImports(ast, filename, resolveImport) {
+  const result = {
+    direct: new Set,
+    namespace: new Map,
+    member: new Set
+  };
+  if (!filename)
+    return result;
+  const absoluteFilename = path2.resolve(filename);
+  traverse(ast, {
+    ImportDeclaration(p) {
+      const source = moduleSourceValue(p.node.source);
+      if (!source)
+        return;
+      if (p.node.importKind === "type")
+        return;
+      const resolved = resolveAnyImport(source, absoluteFilename, resolveImport);
+      if (!resolved)
+        return;
+      let filePure = pureImportCache.get(resolved);
+      if (!filePure) {
+        filePure = scanPureExports(resolved, resolveImport);
+        pureImportCache.set(resolved, filePure);
+      }
+      for (const spec of p.node.specifiers ?? []) {
+        if (isImportSpecifier(spec)) {
+          const imported = importedBindingName(spec.imported);
+          if (!imported)
+            continue;
+          const kind = filePure.get(imported);
+          if (!kind)
+            continue;
+          if (kind === "function") {
+            result.direct.add(spec.local.name);
+          } else {
+            result.member.add(spec.local.name);
+          }
+        } else if (isImportDefaultSpecifier(spec)) {
+          const kind = filePure.get("default");
+          if (!kind)
+            continue;
+          if (kind === "function") {
+            result.direct.add(spec.local.name);
+          } else {
+            result.member.add(spec.local.name);
+          }
+        } else if (isImportNamespaceSpecifier(spec)) {
+          const pureMembers = new Set;
+          for (const [name, kind] of filePure) {
+            if (name === "default")
+              continue;
+            if (kind === "function") {
+              pureMembers.add(name);
+            } else {
+              pureMembers.add(name);
+            }
+          }
+          if (pureMembers.size > 0) {
+            result.namespace.set(spec.local.name, pureMembers);
+          }
+        }
+      }
+    }
+  });
+  return result;
+}
+function isReactiveSourceCall(expr, names) {
+  if (!isCallExpression(expr))
+    return null;
+  const callee = expr.callee;
+  if (!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 (!isCallExpression(expr))
+    return false;
+  const callee = expr.callee;
+  if (isIdentifier(callee)) {
+    return names.useFetch.has(callee.name);
+  }
+  if (isMemberExpression(callee) && !callee.computed && isIdentifier(callee.property) && USEFETCH_CHAIN_METHODS.has(callee.property.name)) {
+    return isUseFetchCall(callee.object, names);
+  }
+  return false;
+}
+function trackLocalScopeBindings(path, names, scope, shallow = false) {
+  const collect = (visitors) => {
+    path.traverse(shallow ? {
+      ...visitors,
+      Function(p) {
+        p.skip();
+      }
+    } : visitors);
+  };
+  collect({
+    VariableDeclarator(p) {
+      const id = p.node.id;
+      const init = p.node.init;
+      if (!init)
+        return;
+      if (isIdentifier(id) && isCallExpression(init) && 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 (isArrayPattern(id) && id.elements[0]) {
+            const first = id.elements[0];
+            if (isIdentifier(first)) {
+              scope.bindings.set(first.name, { kind: source.kind });
+            }
+          }
+          return;
+        }
+        if (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 (isObjectPattern(id)) {
+          for (const prop of id.properties) {
+            if (isObjectProperty(prop) && !prop.computed && isIdentifier(prop.value)) {
+              scope.bindings.set(prop.value.name, {
+                kind: "signal"
+              });
+            }
+          }
+        } else if (isIdentifier(id)) {
+          scope.bindings.set(id.name, { kind: "signalObject" });
+        }
+        return;
+      }
+    }
+  });
+  collect({
+    VariableDeclarator(p) {
+      const id = p.node.id;
+      const init = p.node.init;
+      if (!init || !isIdentifier(init))
+        return;
+      const initBinding = scope.bindings.get(init.name);
+      if (!initBinding || initBinding.kind !== "mutable")
+        return;
+      if (isObjectPattern(id)) {
+        for (const prop of id.properties) {
+          if (!isObjectProperty(prop))
+            continue;
+          const key = prop.key;
+          const value = prop.value;
+          if (!isIdentifier(key) || !isIdentifier(value))
+            continue;
+          scope.bindings.set(value.name, {
+            kind: "mutable",
+            root: initBinding.root,
+            path: [...initBinding.path, key.name]
+          });
+        }
+      }
+    }
+  });
+  collect({
+    "FunctionDeclaration|VariableDeclarator"(p) {
+      const node = p.node;
+      let fn = null;
+      let name = null;
+      if (isFunctionDeclaration(node)) {
+        fn = node;
+        name = isIdentifier(node.id) ? node.id.name : null;
+      } else if (isVariableDeclarator(node)) {
+        const init = node.init;
+        if (init && (isArrowFunctionExpression(init) || isFunctionExpression(init))) {
+          fn = init;
+        }
+        if (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 (isIdentifier(params)) {
+    scope.bindings.set(params.name, { kind: "prop" });
+  } else if (isObjectPattern(params)) {
+    for (const prop of params.properties) {
+      if (isObjectProperty(prop) && isIdentifier(prop.value)) {
+        const key = prop.key;
+        if (isIdentifier(key) && reactiveProps.has(key.name)) {
+          scope.bindings.set(prop.value.name, { kind: "prop" });
+        }
+      }
+    }
+  }
+}
+function getAllPropNames2(params) {
+  if (!params)
+    return new Set;
+  if (isIdentifier(params))
+    return new Set(["*"]);
+  if (isObjectPattern(params)) {
+    const names = new Set;
+    for (const prop of params.properties) {
+      if (isObjectProperty(prop) && 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 (!isBlockStatement(body))
+    return null;
+  for (const stmt of body.body) {
+    if (!isVariableDeclaration(stmt))
+      continue;
+    for (const decl of stmt.declarations) {
+      if (!isIdentifier(decl.id) || decl.id.name !== name)
+        continue;
+      const init = decl.init;
+      if (!isObjectExpression(init))
+        continue;
+      return init;
+    }
+  }
+  return null;
+}
+function analyzeObjectLiteralSpread(spread, fullScope, calleeReactive) {
+  for (const prop of spread.properties) {
+    if (isObjectProperty(prop) && !prop.computed) {
+      const key = prop.key;
+      const name = isIdentifier(key) ? key.name : isStringLiteral(key) ? key.value : null;
+      if (name && containsReactiveValue2(prop.value, fullScope)) {
+        calleeReactive.add(name);
+      }
+    }
+  }
+}
+function isMemberLike(node) {
+  if (isChainExpression(node))
+    return isMemberLike(unwrapChain(node));
+  return isMemberExpression(node);
+}
+function isFunctionLike(node) {
+  return isArrowFunctionExpression(node) || isFunctionExpression(node);
+}
+function isCallLike(node) {
+  const inner = unwrapCall(node);
+  return isCallExpression(inner);
+}
+var COMPILER_BINDING_CALLEES = new Set([
+  "_$bindText",
+  "_$bindAttr",
+  "_$bindStyle",
+  "_$bindClass",
+  "_$unwrap"
+]);
+function isCompilerBindingCall(node) {
+  const call = unwrapCall(node);
+  if (!isCallExpression(call))
+    return false;
+  const callee = unwrapParens(call.callee);
+  return isIdentifier(callee) && COMPILER_BINDING_CALLEES.has(callee.name);
+}
+function visitCallCalleeAndArgs(node, visitExpr) {
+  const call = unwrapCall(node);
+  if (!isCallExpression(call))
+    return;
+  if (isCompilerBindingCall(call))
+    return;
+  const callee = unwrapParens(call.callee);
+  visitExpr(callee, true);
+  for (const arg of call.arguments) {
+    if (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) {
+    current = unwrapParens(current);
+    if (isTSNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isChainExpression(current)) {
+      current = unwrapChain(current);
+      continue;
+    }
+    if (isMemberLike(current)) {
+      const member = isChainExpression(current) ? unwrapChain(current) : current;
+      if (member.computed)
+        return null;
+      const property = member.property;
+      if (!isIdentifier(property))
+        return null;
+      path.push(property.name);
+      current = member.object;
+      continue;
+    }
+    break;
+  }
+  if (isIdentifier(current)) {
+    return { root: current.name, path: path.reverse() };
+  }
+  return null;
+}
+function isReactiveRead(node, scope) {
+  if (isTSNonNullExpression(node)) {
+    return isReactiveRead(node.expression, scope);
+  }
+  if (isChainExpression(node)) {
+    return isReactiveRead(unwrapChain(node), scope);
+  }
+  if (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 call = unwrapCall(node);
+  if (!isCallExpression(call))
+    return false;
+  const callee = unwrapParens(call.callee);
+  if (isIdentifier(callee)) {
+    const binding = scope.bindings.get(callee.name);
+    if (binding?.kind === "getter")
+      return true;
+    if (binding)
+      return false;
+    return call.arguments.length === 0;
+  }
+  if (isMemberLike(callee) && !callee.computed && isIdentifier(callee.property)) {
+    if (call.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 (isParenthesizedExpression(node)) {
+    return isReactiveValue2(unwrapParens(node), scope);
+  }
+  if (isTSNonNullExpression(node)) {
+    return isReactiveValue2(node.expression, scope);
+  }
+  if (isChainExpression(node)) {
+    return isReactiveValue2(unwrapChain(node), scope);
+  }
+  if (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 (node.type === "ParenthesizedExpression") {
+      visit(node.expression);
+      return;
+    }
+    if (isChainExpression(node)) {
+      visit(unwrapChain(node));
+      return;
+    }
+    if (isMemberLike(node) || isTSNonNullExpression(node) || isIdentifier(node)) {
+      if (isReactiveValue2(node, scope)) {
+        found = true;
+        return;
+      }
+    }
+    if (isCallLike(node) && isGetterCall(node, scope)) {
+      found = true;
+      return;
+    }
+    if (isArrowFunctionExpression(node) || 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 (node.type === "ParenthesizedExpression") {
+      visit(node.expression, enterFunction);
+      return;
+    }
+    if (isChainExpression(node)) {
+      visit(unwrapChain(node), enterFunction);
+      return;
+    }
+    if (isFunctionLike(node)) {
+      if (!enterFunction)
+        return;
+      for (const param of node.params) {
+        visit(param, false);
+      }
+      visit(node.body, false);
+      return;
+    }
+    if (isJSXElement(node) || isJSXFragment(node)) {
+      return;
+    }
+    if (isMemberLike(node) || isTSNonNullExpression(node) || 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 (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 (isJSXIdentifier(name)) {
+    componentName = name.name;
+    firstChar = name.name?.[0] ?? null;
+  } else if (isJSXMemberExpression(name)) {
+    let current = name;
+    while (isJSXMemberExpression(current)) {
+      current = current.object;
+    }
+    if (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) {
+  const inner = unwrapParens(expr);
+  if (isArrowFunctionExpression(inner) || isFunctionExpression(inner))
+    return false;
+  if (isJSXEmptyExpression(inner))
+    return false;
+  return containsReactiveRead(inner, scope);
+}
+var RESOLVE_HELPER = "_$unwrap";
+function transformPropMemberAccess(expr, scope) {
+  let changed = false;
+  function resolveRoot(rootName) {
+    return callExpression(identifier(RESOLVE_HELPER), [
+      identifier(rootName)
+    ]);
+  }
+  function replaceMemberRoot(node, rootName) {
+    let current = node;
+    let parent = null;
+    while (true) {
+      if (isParenthesizedExpression(current)) {
+        current = unwrapParens(current);
+        continue;
+      }
+      if (isChainExpression(current)) {
+        current = unwrapChain(current);
+        continue;
+      }
+      if (isTSNonNullExpression(current)) {
+        current = current.expression;
+        continue;
+      }
+      if (!isMemberExpression(current))
+        break;
+      parent = current;
+      current = current.object;
+    }
+    if (parent && isIdentifier(current) && current.name === rootName) {
+      parent.object = resolveRoot(rootName);
+    }
+  }
+  function visit(node, enterFunction) {
+    if (!node || typeof node !== "object")
+      return;
+    if (node.type === "ParenthesizedExpression") {
+      visit(node.expression, enterFunction);
+      return;
+    }
+    if (isFunctionLike(node)) {
+      if (!enterFunction)
+        return;
+      for (const param of node.params) {
+        visit(param, false);
+      }
+      visit(node.body, false);
+      return;
+    }
+    if (isJSXElement(node) || 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 arrowFunctionExpression([], expr);
+}
+function isPropRoot(expr, scope) {
+  if (isIdentifier(expr)) {
+    return scope.bindings.get(expr.name)?.kind === "prop";
+  }
+  if (isCallExpression(expr) && isIdentifier(expr.callee, { name: "_$unwrap" }) && expr.arguments.length === 1 && isIdentifier(expr.arguments[0])) {
+    return scope.bindings.get(expr.arguments[0].name)?.kind === "prop";
+  }
+  return false;
+}
+function isChildrenPropRead(expr, scope) {
+  let node = unwrapParens(expr);
+  if (isChainExpression(node))
+    node = unwrapParens(unwrapChain(node));
+  if (isIdentifier(node, { name: "children" }))
+    return true;
+  if (!isMemberExpression(node) || node.computed)
+    return false;
+  if (!isIdentifier(node.property, { name: "children" }))
+    return false;
+  return isPropRoot(node.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 callExpression(identifier("_$bindStyle"), [
+        wrapExpression(expr)
+      ]);
+    }
+    if (attrName === "class") {
+      return callExpression(identifier("_$bindClass"), [
+        wrapExpression(expr)
+      ]);
+    }
+    return callExpression(identifier("_$bindAttr"), [
+      stringLiteral(attrName),
+      wrapExpression(expr)
+    ]);
+  }
+  const compInfo = getComponentExpressionInfo(exprPath);
+  if (isChildrenPropRead(expr, scope) || childrenGetter || compInfo.isComponent && compInfo.attributeName === null) {
+    return wrapExpression(expr);
+  }
+  return callExpression(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 (!isIdentifier(callee) || !ccNames.has(callee.name))
+        return;
+      const firstArg = path.node.arguments[0];
+      if (!firstArg || !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 (isIdentifier(id)) {
+          names.set(id.name, componentFn);
+        }
+      }
+    }
+  });
+  traverse(ast, {
+    ExportNamedDeclaration(path) {
+      const declaration = path.node.declaration;
+      if (!isVariableDeclaration(declaration))
+        return;
+      for (const decl of declaration.declarations) {
+        const init = decl.init;
+        if (!init || !isCallExpression(init))
+          continue;
+        const callee = init.callee;
+        if (!isIdentifier(callee) || !ccNames.has(callee.name))
+          continue;
+        const firstArg = init.arguments[0];
+        if (!firstArg || !isFunction(firstArg))
+          continue;
+        exported.add(firstArg);
+      }
+    },
+    ExportDefaultDeclaration(path) {
+      const decl = path.node.declaration;
+      if (isIdentifier(decl)) {
+        const componentFn = names.get(decl.name);
+        if (componentFn) {
+          exported.add(componentFn);
+        }
+      } else if (isCallExpression(decl)) {
+        const callee = decl.callee;
+        if (isIdentifier(callee) && ccNames.has(callee.name)) {
+          const firstArg = decl.arguments[0];
+          if (firstArg && 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 (!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 (isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of path.node.children) {
+        if (isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || 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: 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 = isObjectExpression(spread) ? spread : 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 hasSnapshotPragma(node) {
+  return node.leadingComments?.some((comment) => /\bsinwan-snapshot\b/.test(comment.value)) ?? false;
+}
+function isTypePosition(ref) {
+  return ref.findParent((parent) => parent.isTSType()) != null;
+}
+function canRewriteDerivedReference(ref) {
+  if (!ref.isIdentifier() || !ref.isReferencedIdentifier())
+    return false;
+  if (isTypePosition(ref))
+    return true;
+  let target = ref;
+  while ((target.parentPath?.isMemberExpression() || target.parentPath?.isOptionalMemberExpression()) && target.key === "object" || (target.parentPath?.isTSNonNullExpression() || target.parentPath?.isTSAsExpression() || target.parentPath?.isTSTypeAssertion() || target.parentPath?.isTSSatisfiesExpression() || target.parentPath?.isParenthesizedExpression()) && target.key === "expression") {
+    target = target.parentPath;
+  }
+  const parent = target.parentPath;
+  return !(parent?.isAssignmentExpression() && target.key === "left" || parent?.isUpdateExpression() || parent?.isUnaryExpression({ operator: "delete" }) || (parent?.isForInStatement() || parent?.isForOfStatement()) && target.key === "left" || target !== ref && (parent?.isCallExpression() || parent?.isOptionalCallExpression()) && target.key === "callee");
+}
+function isPureDerivedCall(path, names, pureImports) {
+  if (!path.isCallExpression() && !path.isOptionalCallExpression())
+    return false;
+  const call = unwrapCall(path.node);
+  const callee = unwrapParens(call.callee);
+  const args = call.arguments ?? [];
+  if (isMemberExpression(callee) || isOptionalMemberExpression(callee)) {
+    const props = [];
+    let node = unwrapParens(callee);
+    while (true) {
+      node = unwrapParens(node);
+      if (isChainExpression(node)) {
+        node = unwrapChain(node);
+        continue;
+      }
+      if (!isMemberExpression(node))
+        break;
+      const prop = node.property;
+      if (isIdentifier(prop)) {
+        props.unshift(prop.name);
+      } else if (isStringLiteral(prop)) {
+        props.unshift(prop.value);
+      } else {
+        return false;
+      }
+      node = node.object;
+    }
+    if (!isIdentifier(node))
+      return false;
+    const root = node.name;
+    if (pureImports.member.has(root)) {
+      return true;
+    }
+    const nsMembers = pureImports.namespace.get(root);
+    if (nsMembers && props.some((p) => nsMembers.has(p))) {
+      return true;
+    }
+    return false;
+  }
+  if (!isIdentifier(callee))
+    return false;
+  const binding = path.scope.getBinding(callee.name);
+  if (!binding) {
+    return ["Boolean", "Number", "String"].includes(callee.name) && args.length === 1;
+  }
+  if ((binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && pureImports.direct.has(callee.name)) {
+    return true;
+  }
+  if (args.length !== 0 || !binding.path.isVariableDeclarator())
+    return false;
+  const { id, init } = binding.path.node;
+  return isArrayPattern(id) && id.elements[0] === binding.identifier && isCallExpression(init) && isIdentifier(init.callee) && names.useState.has(init.callee.name) && binding.path.scope.getBinding(init.callee.name)?.path.isImportSpecifier() === true;
+}
+function isDerivedInitializer(declaration, scope, names, derived, pureImports) {
+  const init = singlePath(declaration.get("init"));
+  init.assertExpression();
+  let safe = true;
+  let reactive = false;
+  const inspect = (path) => {
+    if (!safe || path.isTSType()) {
+      path.skip();
+      return;
+    }
+    const node = path.node;
+    if (path.isReferencedIdentifier()) {
+      const binding = path.scope.getBinding(path.node.name);
+      if (binding && (!binding.constant || binding.kind === "let" || binding.kind === "var" || binding.path.isVariableDeclarator() && (binding.path.node.start ?? -1) >= (declaration.node.start ?? Infinity))) {
+        safe = false;
+        return;
+      }
+      if (binding && derived.has(binding))
+        reactive = true;
+      if (isReactiveRead(node, scope))
+        reactive = true;
+    } else if (path.isMemberExpression() || path.isOptionalMemberExpression()) {
+      if (isReactiveRead(node, scope))
+        reactive = true;
+    } else if (path.isCallExpression() || path.isOptionalCallExpression()) {
+      if (!isPureDerivedCall(path, names, pureImports))
+        safe = false;
+      if (isGetterCall(path.node, scope))
+        reactive = true;
+    } else if (path.isSpreadElement()) {} else if (!(path.isIdentifier() || path.isLiteral() || path.isTemplateLiteral() || path.isTemplateElement() || path.isBinaryExpression() || path.isLogicalExpression() || path.isConditionalExpression() || path.isObjectExpression() || path.isObjectProperty() || path.isArrayExpression() || path.isParenthesizedExpression() || path.node.type === "ChainExpression" || path.isUnaryExpression() && path.node.operator !== "delete" || path.isTSAsExpression() || path.isTSSatisfiesExpression() || path.isTSNonNullExpression() || path.isTSTypeAssertion())) {
+      safe = false;
+    }
+  };
+  inspect(init);
+  if (safe)
+    init.traverse({ enter: inspect });
+  return safe && reactive;
+}
+function promoteReactiveConstInitializers(ast, options) {
+  if (!options.derivedLocals && !options.dev)
+    return;
+  const names = trackReactiveImports2(ast);
+  const pureImports = collectPureImports(ast, options.filename, options.resolveImport);
+  const { functions } = collectComponentFunctions2(ast, names.cc);
+  traverse(ast, {
+    Program(p) {
+      p.scope.crawl();
+    }
+  });
+  traverse(ast, {
+    Function(fnPath) {
+      if (!isFunction(fnPath.node) || !functions.has(fnPath.node))
+        return;
+      const factory = fnPath.parentPath;
+      if (!factory || !factory.isCallExpression() || !isIdentifier(factory.node.callee) || factory.scope.getBinding(factory.node.callee.name)?.kind !== "module")
+        return;
+      const body = singlePath(fnPath.get("body"));
+      if (!body.isBlockStatement())
+        return;
+      let hasDirectEval = false;
+      fnPath.traverse({
+        CallExpression(p) {
+          if (isIdentifier(p.node.callee, { name: "eval" }) && !p.scope.getBinding("eval"))
+            hasDirectEval = true;
+        }
+      });
+      if (hasDirectEval)
+        return;
+      const scope = { bindings: new Map };
+      trackPropBindings(scope, fnPath.node.params[0], getAllPropNames2(fnPath.node.params[0]));
+      trackLocalScopeBindings(fnPath, names, scope, true);
+      const derived = new Map;
+      const statements = body.get("body");
+      for (const statement of Array.isArray(statements) ? statements : [statements]) {
+        if (!statement.isVariableDeclaration({ kind: "const" }) || hasSnapshotPragma(statement.node))
+          continue;
+        for (const declaration of (() => {
+          const decls = statement.get("declarations");
+          return Array.isArray(decls) ? decls : [decls];
+        })()) {
+          const { id, init } = declaration.node;
+          if (!isIdentifier(id) || !init || hasSnapshotPragma(declaration.node) || hasSnapshotPragma(init))
+            continue;
+          const binding = declaration.scope.getBinding(id.name);
+          if (!binding.constant || !binding.referenced || !binding.referencePaths.every(canRewriteDerivedReference))
+            continue;
+          if (isDerivedInitializer(declaration, scope, names, derived, pureImports)) {
+            derived.set(binding, { declaration, binding });
+          }
+        }
+      }
+      for (const { declaration, binding } of derived.values()) {
+        const { id, init } = declaration.node;
+        if (!isIdentifier(id) || !isExpression(init))
+          continue;
+        const location = `${options.filename ?? "<module>"}:${id.loc?.start.line ?? 0}`;
+        if (!options.derivedLocals) {
+          if (binding.referencePaths.some((ref) => ref.findParent((p) => p.isJSXExpressionContainer()))) {
+            console.warn(`[Sinwan] ${location}: derived local "${id.name}" snapshots a reactive read used in JSX. Enable derivedLocals or use a getter/computed; use /* sinwan-snapshot */ for an intentional snapshot.`);
+          }
+          continue;
+        }
+        const getter = arrowFunctionExpression([], init);
+        if (isTSTypeAnnotation(id.typeAnnotation)) {
+          getter.returnType = id.typeAnnotation;
+          id.typeAnnotation = null;
+        }
+        declaration.node.init = getter;
+        for (const ref of binding.referencePaths) {
+          if (isTypePosition(ref))
+            continue;
+          if (options.dev && ref.parentPath?.isIfStatement() && ref.key === "test" && ref.getFunctionParent()?.node === fnPath.node) {
+            console.warn(`[Sinwan] ${location}: derived local "${id.name}" in a setup if is read once, not a reactive branch. The compiler calls its getter to preserve boolean semantics; use Show for reactive control flow.`);
+          }
+          if (ref.parentPath?.isObjectProperty({ shorthand: true })) {
+            ref.parentPath.node.shorthand = false;
+          }
+          ref.replaceWith(callExpression(identifier(id.name), []));
+        }
+      }
+      fnPath.scope.crawl();
+    }
+  });
+}
+function wrapReactiveExpressions2(ast, options = {}) {
+  promoteReactiveConstInitializers(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 ? path2.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 = moduleSourceValue(p.node.source);
+      if (!source)
+        return;
+      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
+      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
+      if (reactiveAllowed || componentAllowed) {
+        for (const spec of p.node.specifiers ?? []) {
+          if (!isImportSpecifier(spec))
+            continue;
+          const imported = importedBindingName(spec.imported);
+          if (imported && reactiveAllowed?.has(imported)) {
+            addImportLocal(names, imported, spec.local.name);
+          } else if (imported && componentAllowed?.has(imported)) {
+            names.cc.add(spec.local.name);
+          }
+        }
+      }
+      if (source === "sinwan/reactivity") {
+        for (const spec of p.node.specifiers ?? []) {
+          if (isImportSpecifier(spec) && 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 (!isImportSpecifier(spec))
+                continue;
+              const imported = importedBindingName(spec.imported);
+              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 (!isIdentifier(callee) || !names.cc.has(callee.name))
+        return;
+      const firstArg = p.node.arguments[0];
+      if (!firstArg || !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 (isIdentifier(id)) {
+          componentNames.set(id.name, componentFn);
+        }
+      }
+    },
+    ExportNamedDeclaration(p) {
+      const declaration = p.node.declaration;
+      if (!isVariableDeclaration(declaration))
+        return;
+      for (const decl of declaration.declarations) {
+        const init = decl.init;
+        if (!init || !isCallExpression(init))
+          continue;
+        const callee = init.callee;
+        if (!isIdentifier(callee) || !names.cc.has(callee.name))
+          continue;
+        const firstArg = init.arguments[0];
+        if (!firstArg || !isFunction(firstArg))
+          continue;
+        exported.add(firstArg);
+      }
+    },
+    ExportDefaultDeclaration(p) {
+      const decl = p.node.declaration;
+      if (isIdentifier(decl)) {
+        const fn = componentNames.get(decl.name);
+        if (fn) {
+          exported.add(fn);
+          exportNameByFn.set(fn, "default");
+        }
+      } else if (isCallExpression(decl)) {
+        const callee = decl.callee;
+        if (isIdentifier(callee) && names.cc.has(callee.name)) {
+          const firstArg = decl.arguments[0];
+          if (firstArg && isFunction(firstArg)) {
+            exported.add(firstArg);
+            exportNameByFn.set(firstArg, "default");
+          }
+        }
+      }
+    },
+    Function(p) {
+      const scope = { bindings: new Map };
+      if (options.derivedLocals && componentFunctions.has(p.node)) {
+        trackPropBindings(scope, p.node.params[0], getAllPropNames2(p.node.params[0]));
+      }
+      trackLocalScopeBindings(p, names, scope, options.derivedLocals === true && componentFunctions.has(p.node));
+      localScopes.set(p.node, scope);
+    },
+    JSXElement(p) {
+      const name = p.node.openingElement.name;
+      if (!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 (isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of p.node.children) {
+        if (isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || 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: 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(jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options, scope, childrenGetter)));
+          }
+        }
+      });
+    }
+  });
+  if (needsResolve && !hasUnwrapImport) {
+    ast.program.body.unshift(importDeclaration([
+      importSpecifier(identifier(RESOLVE_HELPER), identifier("unwrap"))
+    ], stringLiteral("sinwan/reactivity")));
+  }
+}
+
+// src/cli.ts
+import * as path3 from "path";
+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 { identifier, stringLiteral, numericLiteral, callExpression, memberExpression, variableDeclarator, variableDeclaration, arrayExpression, objectExpression, objectProperty, importSpecifier, importDeclaration, jsxExpressionContainer, blockStatement, returnStatement, binaryExpression, conditionalExpression, unaryExpression, isNode, isIdentifier, isStringLiteral, isNumericLiteral, isBooleanLiteral, isNullLiteral, isTemplateLiteral, templateElementRaw, isParenthesizedExpression, unwrapParens, isObjectExpression, isObjectProperty, isObjectPattern, isRestElement, isAssignmentPattern, isBlockStatement, isArrowFunctionExpression, isFunction, isImportDeclaration, isImportSpecifier, isJSXIdentifier, isJSXOpeningElement, isJSXMemberExpression, isExpression, importedBindingName, moduleSourceValue, singlePath, traverse, autoWrapComponents2, parse, analyzeModule2, analyzeProject2, AnalyzerCache2, analyze2, loadMetadata2, trackReactiveImports2, getAllPropNames2, isReactiveValue2, containsReactiveValue2, collectComponentFunctions2, computeLocalScopes2, collectComponentCallGraph2, buildFullScope2, propagateReactiveProps2, wrapReactiveExpressions2, runAnalyzeCli2, runCliIfMain2 };