sinwan-compiler 0.3.1 → 0.4.0

package/dist/{chunk-fadpxq9v.js → chunk-sy6qf73w.js}

@@ -3,16 +3,18 @@
 import * as path3 from "path";
 
 // src/analyze.ts
-import { parse } from "@babel/parser";
+import { parse as parse2 } from "@babel/parser";
 import * as t3 from "@babel/types";
 import _traverse3 from "@babel/traverse";
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path2 from "path";
 
 // src/reactive-wrap.ts
 import * as t from "@babel/types";
 import _traverse from "@babel/traverse";
 import * as path from "path";
+import { parse } from "@babel/parser";
+import * as fs from "fs";
 var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?? _traverse;
 var REACTIVE_SOURCE_MODULES = {
   "sinwan/store": new Set(["createMutable", "createStore"]),
@@ -87,6 +89,282 @@ function trackReactiveImports2(ast) {
   });
   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 (fs.existsSync(base))
+        return base;
+    } catch {}
+    return null;
+  }
+  for (const ext of PURE_EXTENSIONS) {
+    try {
+      if (fs.existsSync(base + ext))
+        return base + ext;
+    } catch {}
+  }
+  return null;
+}
+function tryResolveIndex(dir) {
+  for (const ext of PURE_EXTENSIONS) {
+    try {
+      const candidate = path.join(dir, "index") + ext;
+      if (fs.existsSync(candidate))
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+function tryResolveRelative(source, fromFile) {
+  const base = path.resolve(path.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 = path.dirname(fromFile);
+  for (let i = 0;i < 30; i++) {
+    const nodeModules = path.join(dir, "node_modules", pkgName);
+    if (fs.existsSync(nodeModules)) {
+      return resolvePackageEntry(nodeModules, subpath);
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function resolvePackageEntry(pkgDir, subpath) {
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(path.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(path.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(path.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(path.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 = path.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 = fs.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 (t.isFunctionDeclaration(decl) && decl.id) {
+          pure.set(decl.id.name, "function");
+        } else if (t.isClassDeclaration(decl) && decl.id) {
+          pure.set(decl.id.name, "class");
+        } else if (t.isVariableDeclaration(decl)) {
+          for (const d of decl.declarations) {
+            if (!t.isIdentifier(d.id))
+              continue;
+            const init = d.init;
+            if (t.isObjectExpression(init)) {
+              pure.set(d.id.name, "object");
+            } else {
+              pure.set(d.id.name, "function");
+            }
+          }
+        }
+      }
+      const source = p.node.source?.value;
+      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 (!t.isExportSpecifier(spec))
+              continue;
+            const exported = t.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 (t.isFunctionDeclaration(decl) || t.isArrowFunctionExpression(decl) || t.isFunctionExpression(decl)) {
+        pure.set("default", "function");
+      } else if (t.isClassDeclaration(decl)) {
+        pure.set("default", "class");
+      }
+    },
+    ExportAllDeclaration(p) {
+      const source = p.node.source?.value;
+      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 = path.resolve(filename);
+  traverse(ast, {
+    ImportDeclaration(p) {
+      const source = p.node.source.value;
+      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 (t.isImportSpecifier(spec)) {
+          const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          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 (t.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 (t.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 (!t.isCallExpression(expr))
     return null;
@@ -136,8 +414,16 @@ function isUseFetchCall(expr, names) {
   }
   return false;
 }
-function trackLocalScopeBindings(path, names, scope) {
-  path.traverse({
+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;
@@ -187,7 +473,7 @@ function trackLocalScopeBindings(path, names, scope) {
       }
     }
   });
-  path.traverse({
+  collect({
     VariableDeclarator(p) {
       const id = p.node.id;
       const init = p.node.init;
@@ -213,7 +499,7 @@ function trackLocalScopeBindings(path, names, scope) {
       }
     }
   });
-  path.traverse({
+  collect({
     "FunctionDeclaration|VariableDeclarator"(p) {
       const node = p.node;
       let fn = null;
@@ -924,7 +1210,184 @@ function propagateReactiveProps2(localScopes, callGraph, componentFunctions) {
   }
   return reactiveProps;
 }
+function hasSnapshotPragma(node) {
+  return node.leadingComments?.some((comment) => /\bsinwan-snapshot\b/.test(comment.value)) ?? false;
+}
+function canRewriteDerivedReference(ref) {
+  if (!ref.isIdentifier() || !ref.isReferencedIdentifier() || ref.findParent((p) => p.isTSType())) {
+    return false;
+  }
+  let target = ref;
+  while ((target.parentPath?.isMemberExpression() || target.parentPath?.isOptionalMemberExpression()) && target.key === "object" || (target.parentPath?.isTSNonNullExpression() || target.parentPath?.isTSAsExpression() || target.parentPath?.isTSTypeAssertion()) && 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 callee = path.node.callee;
+  if (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) {
+    const props = [];
+    let node = callee;
+    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+      const prop = node.property;
+      if (t.isIdentifier(prop)) {
+        props.unshift(prop.name);
+      } else if (t.isStringLiteral(prop)) {
+        props.unshift(prop.value);
+      } else {
+        return false;
+      }
+      node = node.object;
+    }
+    if (!t.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 (!t.isIdentifier(callee))
+    return false;
+  const binding = path.scope.getBinding(callee.name);
+  if (!binding) {
+    return ["Boolean", "Number", "String"].includes(callee.name) && path.node.arguments.length === 1;
+  }
+  if ((binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && pureImports.direct.has(callee.name)) {
+    return true;
+  }
+  if (path.node.arguments.length !== 0 || !binding.path.isVariableDeclarator())
+    return false;
+  const { id, init } = binding.path.node;
+  return t.isArrayPattern(id) && id.elements[0] === binding.identifier && t.isCallExpression(init) && t.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 = 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.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 (!functions.has(fnPath.node))
+        return;
+      const factory = fnPath.parentPath;
+      if (!factory.isCallExpression() || !t.isIdentifier(factory.node.callee) || factory.scope.getBinding(factory.node.callee.name)?.kind !== "module")
+        return;
+      const body = fnPath.get("body");
+      if (!body.isBlockStatement())
+        return;
+      let hasDirectEval = false;
+      fnPath.traverse({
+        CallExpression(p) {
+          if (t.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;
+      for (const statement of body.get("body")) {
+        if (!statement.isVariableDeclaration({ kind: "const" }) || hasSnapshotPragma(statement.node))
+          continue;
+        for (const declaration of statement.get("declarations")) {
+          const { id, init } = declaration.node;
+          if (!t.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 (!t.isIdentifier(id) || !t.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 = t.arrowFunctionExpression([], init);
+        if (t.isTSTypeAnnotation(id.typeAnnotation)) {
+          getter.returnType = id.typeAnnotation;
+          id.typeAnnotation = null;
+        }
+        declaration.node.init = getter;
+        for (const ref of binding.referencePaths) {
+          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(t.callExpression(t.identifier(id.name), []));
+        }
+      }
+      fnPath.scope.crawl();
+    }
+  });
+}
 function wrapReactiveExpressions2(ast, options = {}) {
+  promoteReactiveConstInitializers(ast, options);
   let metadata = null;
   if (options.analyzeMetadata) {
     metadata = options.analyzeMetadata;
@@ -1054,7 +1517,10 @@ function wrapReactiveExpressions2(ast, options = {}) {
     },
     Function(p) {
       const scope = { bindings: new Map };
-      trackLocalScopeBindings(p, names, scope);
+      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) {
@@ -1441,11 +1907,11 @@ function serializeModule(mod) {
 function restoreModule(filePath, serialized) {
   let code;
   try {
-    code = fs.readFileSync(filePath, "utf-8");
+    code = fs2.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
-  const ast = parse(code, {
+  const ast = parse2(code, {
     sourceType: "module",
     plugins: ["jsx", "typescript"]
   });
@@ -1622,7 +2088,7 @@ function collectImportedCallSites(ast, componentNames, imports) {
   return sites;
 }
 function analyzeModule2(code, filePath) {
-  const ast = parse(code, {
+  const ast = parse2(code, {
     sourceType: "module",
     plugins: ["jsx", "typescript"]
   });
@@ -1675,7 +2141,7 @@ function analyzeModule2(code, filePath) {
 }
 function loadTsConfigPaths(tsConfigPath) {
   try {
-    const raw = JSON.parse(fs.readFileSync(tsConfigPath, "utf-8"));
+    const raw = JSON.parse(fs2.readFileSync(tsConfigPath, "utf-8"));
     const paths = raw.compilerOptions?.paths;
     if (!paths)
       return null;
@@ -1718,7 +2184,7 @@ function resolveRelativeImport(source, fromFile, extensions) {
     ...extensions.map((ext) => path2.join(base, "index" + ext))
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate))
+    if (fs2.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -1763,7 +2229,7 @@ function parseAliasObject(content, aliases) {
 }
 function loadBunfigAliases(bunfigPath) {
   try {
-    const content = fs.readFileSync(bunfigPath, "utf-8");
+    const content = fs2.readFileSync(bunfigPath, "utf-8");
     const aliases = new Map;
     const lines = content.split(`
 `);
@@ -1816,14 +2282,14 @@ function resolveWithExtensions(mapped, extensions) {
     ...extensions.map((ext) => path2.join(mapped, "index" + ext))
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate))
+    if (fs2.existsSync(candidate))
       return candidate;
   }
   return null;
 }
 function readPackageName(pkgDir) {
   try {
-    const pkgJson = JSON.parse(fs.readFileSync(path2.join(pkgDir, "package.json"), "utf-8"));
+    const pkgJson = JSON.parse(fs2.readFileSync(path2.join(pkgDir, "package.json"), "utf-8"));
     return pkgJson.name ?? null;
   } catch {
     return null;
@@ -1852,7 +2318,7 @@ function resolveWorkspacePackage(source, packages, extensions) {
   const subpath = source.slice(matchedName.length + 1);
   let sourceDir;
   try {
-    const pkgJson = JSON.parse(fs.readFileSync(path2.join(matchedPkg, "package.json"), "utf-8"));
+    const pkgJson = JSON.parse(fs2.readFileSync(path2.join(matchedPkg, "package.json"), "utf-8"));
     if (pkgJson.source) {
       sourceDir = path2.dirname(path2.resolve(matchedPkg, pkgJson.source));
     } else {
@@ -1866,7 +2332,7 @@ function resolveWorkspacePackage(source, packages, extensions) {
 }
 function loadPackageJsonWorkspaces(filePath) {
   try {
-    const pkg = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const pkg = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
     return pkg.workspaces ?? [];
   } catch {
     return [];
@@ -1874,7 +2340,7 @@ function loadPackageJsonWorkspaces(filePath) {
 }
 function loadPnpmWorkspaces(filePath) {
   try {
-    const content = fs.readFileSync(filePath, "utf-8");
+    const content = fs2.readFileSync(filePath, "utf-8");
     const lines = content.split(`
 `);
     const patterns = [];
@@ -1907,14 +2373,14 @@ function expandGlob(pattern, cwd) {
   const parts = fullPattern.split(path2.sep);
   const wildcardIndex = parts.findIndex((p) => p.includes("*"));
   if (wildcardIndex === -1) {
-    return fs.existsSync(fullPattern) ? [fullPattern] : [];
+    return fs2.existsSync(fullPattern) ? [fullPattern] : [];
   }
   const prefix = parts.slice(0, wildcardIndex).join(path2.sep);
   const suffixParts = parts.slice(wildcardIndex + 1);
   const suffix = suffixParts.join(path2.sep);
   let entries;
   try {
-    entries = fs.readdirSync(prefix, { withFileTypes: true });
+    entries = fs2.readdirSync(prefix, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1931,8 +2397,8 @@ function loadWorkspacePackages(workspaces, root) {
   const patternEntries = [];
   if (typeof workspaces === "string") {
     const resolved = path2.resolve(root, workspaces);
-    if (fs.existsSync(resolved)) {
-      const stat = fs.statSync(resolved);
+    if (fs2.existsSync(resolved)) {
+      const stat = fs2.statSync(resolved);
       if (stat.isDirectory()) {
         patternEntries.push({ pattern: workspaces, base: root });
       } else if (resolved.endsWith("package.json")) {
@@ -1980,7 +2446,7 @@ function loadWorkspacePackages(workspaces, root) {
   for (const { pattern, base } of patternEntries) {
     for (const dir of expandGlob(pattern, base)) {
       const pkgJson = path2.join(dir, "package.json");
-      if (fs.existsSync(pkgJson)) {
+      if (fs2.existsSync(pkgJson)) {
         packages.add(dir);
       }
     }
@@ -2019,7 +2485,7 @@ function findFiles(root, extensions) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -2049,7 +2515,7 @@ function analyzeProject2(options) {
   } else {
     const files = findFiles(options.root, extensions);
     for (const file of files) {
-      const code = fs.readFileSync(file, "utf-8");
+      const code = fs2.readFileSync(file, "utf-8");
       modules.set(file, analyzeModule2(code, file));
     }
   }
@@ -2057,7 +2523,7 @@ function analyzeProject2(options) {
     if (modules.has(filePath))
       return modules.get(filePath);
     try {
-      const code = fs.readFileSync(filePath, "utf-8");
+      const code = fs2.readFileSync(filePath, "utf-8");
       const mod = analyzeModule2(code, filePath);
       modules.set(filePath, mod);
       return mod;
@@ -2214,17 +2680,17 @@ class AnalyzerCache2 {
       reactiveProps: serializeReactiveProps(this.reactiveProps)
     };
     const dir = path2.dirname(this.cachePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(this.cachePath, JSON.stringify(data, null, 2));
+    fs2.writeFileSync(this.cachePath, JSON.stringify(data, null, 2));
   }
   restore() {
-    if (!this.cachePath || !fs.existsSync(this.cachePath))
+    if (!this.cachePath || !fs2.existsSync(this.cachePath))
       return;
     let data;
     try {
-      data = JSON.parse(fs.readFileSync(this.cachePath, "utf-8"));
+      data = JSON.parse(fs2.readFileSync(this.cachePath, "utf-8"));
     } catch {
       return;
     }
@@ -2274,7 +2740,7 @@ class AnalyzerCache2 {
     if (this.modules.has(filePath))
       return this.modules.get(filePath);
     try {
-      const code = fs.readFileSync(filePath, "utf-8");
+      const code = fs2.readFileSync(filePath, "utf-8");
       const mod = analyzeModule2(code, filePath);
       this.modules.set(filePath, mod);
       return mod;
@@ -2351,8 +2817,8 @@ function analyze2(options) {
     root: options.root,
     extensions: options.extensions,
     resolve: options.resolve,
-    tsConfigPath: fs.existsSync(tsConfigPath) ? tsConfigPath : undefined,
-    bunfigPath: fs.existsSync(bunfigPath) ? bunfigPath : undefined,
+    tsConfigPath: fs2.existsSync(tsConfigPath) ? tsConfigPath : undefined,
+    bunfigPath: fs2.existsSync(bunfigPath) ? bunfigPath : undefined,
     workspaces: options.workspaces
   });
   const serialized = {};
@@ -2364,16 +2830,16 @@ function analyze2(options) {
     serialized[filePath] = entry;
   }
   const dir = path2.dirname(options.outFile);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(options.outFile, JSON.stringify(serialized, null, 2));
+  fs2.writeFileSync(options.outFile, JSON.stringify(serialized, null, 2));
 }
 function loadMetadata2(filePath) {
-  if (!fs.existsSync(filePath)) {
+  if (!fs2.existsSync(filePath)) {
     return new Map;
   }
-  const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
   const result = new Map;
   for (const [filePath, fileMap] of Object.entries(raw)) {
     const map = new Map;

package/dist/cli.js

@@ -3,7 +3,7 @@
 import {
   runAnalyzeCli2,
   runCliIfMain2
-} from "./chunk-fadpxq9v.js";
+} from "./chunk-sy6qf73w.js";
 export {
   runAnalyzeCli2 as runAnalyzeCli,
   runCliIfMain2 as runCliIfMain

package/dist/exports.d.ts

@@ -4,10 +4,11 @@
  * Shared utility for detecting top-level exported component bindings in a
  * module. Used by the Vite and Bun plugins for HMR boundary injection.
  *
- * Detection is intentionally conservative: only top-level exports whose name
- * starts with an uppercase letter (the component naming convention) are
- * returned. The runtime safely ignores anything that is not used as a
- * component, so over-matching is harmless.
+ * Detection is intentionally conservative: only top-level *value* exports
+ * whose name starts with an uppercase letter (the component naming
+ * convention) are returned. Type-only exports (`export type { Foo }`,
+ * `export { type Foo }`) must be skipped: HMR footers reference the local
+ * binding, and a type has no runtime binding (`ReferenceError`).
  */
 export interface ExportedComponent {
     /** Local binding name in the module (referenced in the accept callback). */

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   propagateReactiveProps2,
   wrapReactiveExpressions2,
   runAnalyzeCli2
-} from "./chunk-fadpxq9v.js";
+} from "./chunk-sy6qf73w.js";
 
 // src/transform.ts
 import { parse } from "@babel/parser";
@@ -619,6 +619,8 @@ function transformJSX(code, filename, options = {}) {
   autoWrapComponents2(ast, filename);
   rewriteLiveCcDestructure(ast);
   wrapReactiveExpressions2(ast, {
+    derivedLocals: options.derivedLocals,
+    dev: options.dev,
     explicitBindings: options.explicitBindings,
     analyze: options.analyze,
     analyzeMetadata: options.analyzeMetadata,
@@ -666,7 +668,9 @@ function transformJSX(code, filename, options = {}) {
         t2.importSpecifier(t2.identifier("_$bindStyle"), t2.identifier("_$bindStyle")),
         t2.importSpecifier(t2.identifier("_$bindClass"), t2.identifier("_$bindClass"))
       ], t2.stringLiteral("sinwan/renderer"));
-      ast.program.body.unshift(bindingImport);
+      bindingImport.specifiers = bindingImport.specifiers.filter((candidate) => !ast.program.body.some((statement) => t2.isImportDeclaration(statement) && statement.source.value === "sinwan/renderer" && statement.specifiers.some((specifier) => t2.isImportSpecifier(specifier) && t2.isIdentifier(specifier.imported) && specifier.local.name === candidate.local.name && specifier.imported.name === candidate.local.name)));
+      if (bindingImport.specifiers.length > 0)
+        ast.program.body.unshift(bindingImport);
     }
     const result = generate(ast, {
       sourceMaps: true,
@@ -702,6 +706,9 @@ import { parse as parse2 } from "@babel/parser";
 function isComponentName(name) {
   return !!name && name[0] === name[0].toUpperCase() && /^[A-Z]/.test(name);
 }
+function isTypeOnlyExport(node) {
+  return node.exportKind === "type";
+}
 function collectExportedComponents(code, filename) {
   let ast;
   try {
@@ -724,6 +731,8 @@ function collectExportedComponents(code, filename) {
   };
   for (const node of ast.program.body) {
     if (node.type === "ExportNamedDeclaration") {
+      if (isTypeOnlyExport(node))
+        continue;
       if (node.declaration) {
         const decl = node.declaration;
         if (decl.type === "FunctionDeclaration" && decl.id && isComponentName(decl.id.name)) {
@@ -737,6 +746,8 @@ function collectExportedComponents(code, filename) {
         }
       } else if (node.specifiers && !node.source) {
         for (const spec of node.specifiers) {
+          if (isTypeOnlyExport(spec))
+            continue;
           if (spec.type === "ExportSpecifier" && spec.local?.type === "Identifier" && spec.exported?.type === "Identifier" && isComponentName(spec.exported.name)) {
             add(spec.local.name, spec.exported.name);
           }

package/dist/reactive-wrap.d.ts

@@ -98,6 +98,8 @@ export declare function collectComponentCallGraph(ast: t.Node, componentNames: M
 export declare function buildFullScope(localScopes: Map<t.Function, ReactiveScope>, fn: t.Function, reactiveProps: Set<string>): ReactiveScope | null;
 export declare function propagateReactiveProps(localScopes: Map<t.Function, ReactiveScope>, callGraph: Map<t.Function, CallSite[]>, componentFunctions: Set<t.Function>): Map<t.Function, Set<string>>;
 export declare function wrapReactiveExpressions(ast: t.Node, options?: {
+    derivedLocals?: boolean;
+    dev?: boolean;
     explicitBindings?: boolean;
     analyze?: string;
     analyzeMetadata?: Map<string, Map<string, Set<string>>>;

package/dist/transform.d.ts

@@ -6,6 +6,7 @@
  * and replaced with optimized template creation calls.
  */
 export interface TransformOptions {
+    derivedLocals?: boolean;
     /** Enable template hoisting (default: true) */
     hoist?: boolean;
     /** Enable dev mode (source maps, etc.) */

package/docs/api.md

@@ -122,7 +122,7 @@ Parse `analyze [root] [outFile] [--tsconfig] [--bunfig] [--workspaces]` and call
 
 | Name | Role |
 | ---- | ---- |
-| `collectExportedComponents(code)` | File-local exported component names (no `cc` required) |
+| `collectExportedComponents(code)` | File-local exported component names (no `cc` required). Skips type-only exports. |
 | `wrapReactiveExpressions(ast, options?)` | Reactive wrap without hoisting |
 | `trackReactiveImports(ast)` | Import-name sets for signals, `cc`, `useFetch`, … |
 | `collectComponentFunctions(ast, ccNames)` | `cc(...)` functions, names, and exports |

package/docs/architecture.md

@@ -23,6 +23,8 @@ transformJSX
   autoWrapComponents
   rewriteLiveCcDestructure  ← flat destructure stays live; raw JSX spreads
   wrapReactiveExpressions   ← analyze / analyzeMetadata / resolveImport
+    promoteReactiveConstInitializers ← opt-in derivedLocals, snapshot diagnostics
+    rebuild scopes / call graph / JSX wrapping
   hoist JSXElement roots    ← _$createTemplate + slots
 
 analyze / AnalyzerCache.update

package/docs/plugins.md

@@ -48,14 +48,15 @@ The Vite plugin sets `resolve.dedupe: ["sinwan"]` for the same duplicate-runtime
 
 ## Shared plugin options
 
-| Option | Default | Role |
-| ------ | ------- | ---- |
-| `hoist` | `true` | Template hoisting |
-| `dev` | Bun: `NODE_ENV !== "production"` at `sinwan()`; Vite: `config.mode !== "production"` | Warn when hoisting is skipped. Pass `false` for library/`Bun.build` production bundles. |
-| `explicitBindings` | `false` | `_$bind*` helpers instead of bare `() =>` |
-| `analyze` | unset | Path to CLI JSON (production) |
-| `cache` | `true` | Incremental analyzer in dev. `false` turns it off. An object sets `root`, `tsConfigPath`, `bunfigPath`, `workspaces`, `cachePath` |
-| `fastRefresh` | Bun: same as `dev`; Vite: `true` in `serve` | Per-component `import.meta.hot.accept` so routed/looked-up pages hot-update |
+| Option             | Default                                                                              | Role                                                                                                                                                                                                                                                                                                       |
+| ------------------ | ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `hoist`            | `true`                                                                               | Template hoisting                                                                                                                                                                                                                                                                                          |
+| `derivedLocals`    | `false`                                                                              | Promote eligible component-local reactive constants to live getters; see [Transform](transform.md#derived-locals-opt-in). Supports `/** @sinwan-pure */` JSDoc-annotated imports; see [`@sinwan-pure` JSDoc contract](transform.md#sinwan-pure-jsdoc-contract). Requires compiler, plugin and runtime builds with this feature. |
+| `dev`              | Bun: `NODE_ENV !== "production"` at `sinwan()`; Vite: `config.mode !== "production"` | Warn when hoisting is skipped. Pass `false` for library/`Bun.build` production bundles.                                                                                                                                                                                                                    |
+| `explicitBindings` | `false`                                                                              | `_$bind*` helpers instead of bare `() =>`                                                                                                                                                                                                                                                                  |
+| `analyze`          | unset                                                                                | Path to CLI JSON (production)                                                                                                                                                                                                                                                                              |
+| `cache`            | `true`                                                                               | Incremental analyzer in dev. `false` turns it off. An object sets `root`, `tsConfigPath`, `bunfigPath`, `workspaces`, `cachePath`                                                                                                                                                                          |
+| `fastRefresh`      | Bun: same as `dev`; Vite: `true` in `serve`                                          | Per-component `import.meta.hot.accept` so routed/looked-up pages hot-update                                                                                                                                                                                                                                |
 
 ## Dev vs production
 

package/docs/transform.md

@@ -76,12 +76,12 @@ export const Child = cc((props) => <span>{() => props.value}</span>);
 
 Tracked imports:
 
-| Module | Names |
-| ------ | ----- |
-| `sinwan/store` | `createMutable`, `createStore` |
-| `sinwan/reactivity` | `signal`, `computed` |
-| `sinwan/react` | `useState` |
-| `sinwan/hook` | `useFetch` |
+| Module              | Names                          |
+| ------------------- | ------------------------------ |
+| `sinwan/store`      | `createMutable`, `createStore` |
+| `sinwan/reactivity` | `signal`, `computed`           |
+| `sinwan/react`      | `useState`                     |
+| `sinwan/hook`       | `useFetch`                     |
 
 Reads the compiler wraps:
 
@@ -98,11 +98,311 @@ Not wrapped:
 
 - Literals and plain identifiers
 - Event-handler functions (`onClick={fn}` or `onClick={() => …}`)
-- Nested function *values* passed as props (`title={() => s.value}` stays a render prop)
+- Nested function _values_ passed as props (`title={() => s.value}` stays a render prop)
 - Functions stored as object/array values (`{ onClick: () => s.value }`) or returned from a factory (`const make = () => () => s.value`)
 - `useFetch` methods such as `abort` / `execute`
 - Static values the [analyzer](analyzer.md) proved never change
 
+## Derived locals (opt-in)
+
+JSX expressions containing reactive reads already stay live without an author-written arrow. By default, moving that read into `const open = count.value > 0` still takes a **setup snapshot**. Inline one-off expressions in JSX; use a getter or `computed()` for shared derivations when promotion is disabled.
+
+Enable `derivedLocals: true` in `transformJSX` or either plugin to promote eligible component-local constants:
+
+```tsx
+export function App() {
+  const count = signal(0);
+  const positive = count.value > 0;
+  const label = positive ? "positive" : "zero";
+  return (
+    <Show when={positive}>
+      <span title={label}>{label}</span>
+    </Show>
+  );
+}
+```
+
+The derived declarations become zero-argument getters, and references become value reads:
+
+```tsx
+const positive = () => count.value > 0;
+const label = () => (positive() ? "positive" : "zero");
+return (
+  <Show when={() => positive()}>
+    <span title={() => label()}>{() => label()}</span>
+  </Show>
+);
+```
+
+### Eligibility and semantics
+
+- Only referenced, identifier-named `const` declarations directly in a `cc` setup body (including auto-`cc` components) are candidates. Dependencies are processed in declaration order, including multiple declarators in one statement.
+- Pure read expressions are supported: member/index/optional access, arithmetic, comparisons, boolean/conditional expressions, template strings, object/array literals, and TypeScript expression annotations. Direct imported `useState` getter calls and unshadowed single-argument `Boolean`, `Number`, and `String` coercions are also supported. Property reads and coercions must be free of user-defined side effects.
+- Calls to arbitrary helpers, hooks, factories or methods, assignments, updates, allocations, destructuring, `let`/`var`, mutable captures, and forward/TDZ references remain eager — **unless** the callee is an imported function annotated with `/** @sinwan-pure */` (see [`@sinwan-pure` JSDoc contract](#sinwan-pure-jsdoc-contract) below). Explicit getter and `computed` initializers are unchanged. Module, event-handler, render-callback, loop and nested-block declarations are not promoted.
+- Bare signal/store containers still pass through unchanged. Bare component prop-bag aliases retain their ordinary JavaScript value semantics. References are resolved by lexical binding, so shadowed locals and object keys are not rewritten.
+- Every ordinary value use is called, including chained initializers, closures, event bodies, shorthand object values and setup `if` tests. A boolean does **not** become an accidentally truthy function. Setup control flow still runs once; use `Show`/`Switch` for reactive branches.
+- Variables used as JSX tag names, in type queries, or as mutation/method-call receivers are left eager. Components containing direct `eval` are excluded.
+- Getters are lazy, not cached. Use explicit `computed()` when caching matters. This is not whole-program dataflow, and does not turn arbitrary setup side effects into effects.
+
+### Intentional snapshots and diagnostics
+
+Put `/* sinwan-snapshot */` immediately before a declaration or its initializer to retain a one-shot read:
+
+```tsx
+/* sinwan-snapshot */ const initial = count.value;
+const alsoInitial = /* sinwan-snapshot */ count.value;
+```
+
+A declaration-level pragma applies to all its declarators. A snapshot can read another promoted local: the compiler calls that dependency once at the snapshot declaration.
+
+With `dev: true`, the compiler warns when an eligible unpromoted derivation is used in JSX while promotion is disabled. It also warns about a promoted local used directly as a setup `if` test, explaining that the value is read once even though the compiler preserves boolean semantics. Intentional snapshot pragmas suppress the snapshot diagnostic; production (`dev: false`) is quiet.
+
+### `@sinwan-pure` JSDoc contract
+
+The compiler can promote derived `const` initializers that call imported utility functions when those functions are annotated with `/** @sinwan-pure */` in their source file. This eliminates the need for manual `() =>` wrappers around common utilities like className mergers.
+
+**Annotation:**
+
+```ts
+/** @sinwan-pure */
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
+```
+
+Both `export function` and `export const` declarations are recognized. The annotation must be a block comment (`/** */`) immediately before the `export` keyword.
+
+**What the compiler guarantees:**
+
+- When `derivedLocals: true` is enabled, calls to `@sinwan-pure`-annotated imported functions are treated as safe expressions. The containing `const` initializer is promoted to a zero-argument getter, and references inside the function arguments are rewritten (e.g. `seamInactive` → `seamInactive()`).
+- The compiler resolves the import path, reads the source file, parses it, and checks for `/** @sinwan-pure */` on exported declarations. Results are cached per resolved file path, so each file is read at most once per compilation process.
+- All import types are scanned: relative imports (`./`, `../`), bare specifiers (`clsx`, `sinwan/reactivity`), scoped packages (`@scope/utils`), and subpath imports (`@scope/utils/merge`). The compiler walks up the directory tree to find `node_modules/<pkg>`, reads `package.json`, and resolves the entry point via `exports`, `module`, `main`, `source`, or `index` files.
+- If the `resolveImport` callback is provided by the plugin, it is used for path resolution (handles tsconfig paths, bunfig aliases, workspace packages, and Bun/Vite module resolution). Otherwise, the compiler falls back to direct filesystem resolution with common extensions (`.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.mts`, `.cts`) and `index` files.
+
+**Supported export forms (annotate with `/** @sinwan-pure \*/`):\*\*
+
+| Export form            | Example                                                     | Call shape           |
+| ---------------------- | ----------------------------------------------------------- | -------------------- |
+| Named function         | `/** @sinwan-pure */ export function cn()`                  | `cn(...)`            |
+| Named const (function) | `/** @sinwan-pure */ export const merge = () =>`            | `merge(...)`         |
+| Named const (object)   | `/** @sinwan-pure */ export const helpers = { ... }`        | `helpers.merge(...)` |
+| Named class            | `/** @sinwan-pure */ export class Utils { static merge() }` | `Utils.merge(...)`   |
+| Default function       | `/** @sinwan-pure */ export default function helper()`      | `helper(...)`        |
+| Default arrow          | `/** @sinwan-pure */ export default () =>`                  | `helper(...)`        |
+| Default class          | `/** @sinwan-pure */ export default class {}`               | `helper.merge(...)`  |
+
+**Supported import forms:**
+
+| Import form            | Example                                 | Call shape    |
+| ---------------------- | --------------------------------------- | ------------- |
+| Named import           | `import { cn } from "./utils"`          | `cn(...)`     |
+| Named import (aliased) | `import { cn as merge } from "./utils"` | `merge(...)`  |
+| Default import         | `import helper from "./utils"`          | `helper(...)` |
+| Namespace import       | `import * as ns from "./utils"`         | `ns.cn(...)`  |
+
+**Supported re-export forms:**
+
+| Re-export form            | Example                                      |
+| ------------------------- | -------------------------------------------- |
+| Named re-export           | `export { cn } from "./utils"`               |
+| Aliased re-export         | `export { cn as merge } from "./utils"`      |
+| Default re-export         | `export { default } from "./utils"`          |
+| Aliased default re-export | `export { default as merge } from "./utils"` |
+| Namespace re-export       | `export * from "./utils"`                    |
+
+For class and object exports, any static method or property call on the imported binding is treated as pure (e.g. `Utils.merge(...)`, `Utils.format(...)`, `helpers.merge(...)`, `helpers.format(...)`).
+
+**What the annotation author is responsible for:**
+
+- **Purity:** The function must not produce side effects — no signal writes, no DOM mutations, no I/O, no global state changes. Calling the function with the same arguments must always return the same value. The compiler does not verify this; it trusts the annotation.
+- **No hidden reactivity:** The function must not read signals, stores, or other reactive sources internally. If it does, those reads will not be tracked because the function is called inside a getter that the runtime evaluates in an effect — but only the arguments passed to the function are tracked, not reads inside the function body.
+- **Export visibility:** The annotation must be on an exported declaration (`export function`, `export const`, `export class`, `export default`). Re-exports are followed recursively — the compiler resolves the re-export source and scans it for the annotation. Named, aliased, default, and `export *` re-exports are all supported. Circular re-exports are handled with a depth limit to prevent infinite loops.
+- **Import resolvability:** The annotated file must be reachable via any import (relative, bare specifier, scoped package, or subpath). The compiler resolves `node_modules` packages via `package.json` `exports`/`module`/`main`/`source` fields and walks up the directory tree.
+
+**What happens when the annotation is wrong:**
+
+- **Annotated a non-pure function:** The compiler will promote the containing `const` to a getter. If the function has side effects, those side effects will run on every re-evaluation of the getter (whenever its tracked dependencies change), not just once at setup. This will not crash, but may cause unexpected repeated side effects.
+- **Annotated a function that reads signals internally:** Those internal signal reads will not be tracked as dependencies of the promoted getter. The getter will not re-evaluate when those internal signals change, producing stale values. No crash, but incorrect reactivity.
+- **Forgot to annotate a pure function:** The compiler will reject the containing `const` initializer as unsafe. The value will be a one-shot setup snapshot. No crash, but the value will not update when its dependencies change. The `dev: true` diagnostic will warn about eligible unpromoted derivations used in JSX.
+- **Annotation on a non-exported function:** The annotation is ignored. Only exported declarations are scanned.
+- **Import path unresolvable:** The annotation is not found. The function is treated as a non-pure call. No crash, but the containing `const` will not be promoted. This can happen if the package's `package.json` entry points don't lead to a source file, or if the `node_modules` directory is not in the expected location.
+
+**Plugin forwarding:**
+
+Both `bun-plugin-sinwan` and `vite-plugin-sinwan` forward the `resolveImport` callback to the compiler when the analyzer cache is enabled (`cache: true`, the default). This uses the plugin's module resolver, which handles workspace packages, tsconfig paths, and Bun/Vite resolution. When the cache is disabled or the minimal preload is used, the compiler falls back to direct filesystem resolution, which works for relative imports in a standard project layout.
+
+**What is not scanned (by design):**
+
+- **Dynamic imports** (`const { cn } = await import("./utils")`) — the binding is established at runtime, not compile time. The compiler cannot statically resolve which module a dynamic import loads, so it cannot scan the source for `@sinwan-pure` annotations. Use a static import instead.
+- **`require()`** (`const { cn } = require("./utils")`) — CommonJS, not used in Sinwan's ESM target. Bun and Vite both use ESM for application code. Annotate the function and import it via a static ESM import.
+- **Computed member access with non-literal keys** (`ns[key]()` where `key` is a variable, or `ns[\`cn`]()` with template literals) — the compiler cannot statically determine which property is being accessed. Use direct member access (`ns.cn()`) or string literal access (`ns["cn"]()`) instead.
+
+### Workarounds for unsupported patterns
+
+When the compiler cannot auto-promote a derived local (dynamic import, `require()`, or computed member access), use one of these workarounds to preserve reactivity.
+
+#### 1. Replace dynamic import with static import (recommended)
+
+If the module is available at startup, use a static ESM import instead of `await import()`. The compiler can then scan the source file for `@sinwan-pure` annotations and auto-promote the derived local.
+
+```ts
+// ❌ Does NOT work — dynamic import, binding is runtime
+const { cn } = await import("./utils");
+const cls = cn("base", size.value > 50 && "big");
+
+// ✅ Works — static import, compiler auto-promotes
+import { cn } from "./utils"; // /** @sinwan-pure */ export function cn(...)
+const cls = cn("base", size.value > 50 && "big");
+
+// Compiled output:
+// const cls = () => cn("base", size.value > 50 && "big");
+```
+
+#### 2. Replace `require()` with static ESM import (recommended)
+
+Sinwan targets ESM. Use a static ESM import instead of `require()`.
+
+```ts
+// ❌ Does NOT work — CommonJS require(), not ESM
+const { cn } = require("./utils");
+const cls = cn("base", size.value > 50 && "big");
+
+// ✅ Works — static ESM import, compiler auto-promotes
+import { cn } from "./utils";
+const cls = cn("base", size.value > 50 && "big");
+```
+
+#### 3. Replace computed member access with direct or string literal access (recommended)
+
+If you control the call site, use direct member access (`ns.cn()`) or string literal access (`ns["cn"]()`) instead of a variable key.
+
+```ts
+import * as ns from "./utils";
+
+// ❌ Does NOT work — variable key, compiler can't resolve
+const key = "cn";
+const cls = ns[key]("base", size.value > 50 && "big");
+
+// ❌ Does NOT work — template literal key, compiler can't resolve
+const cls = ns[`cn`]("base", size.value > 50 && "big");
+
+// ✅ Works — direct member access, compiler auto-promotes
+const cls = ns.cn("base", size.value > 50 && "big");
+
+// ✅ Works — string literal key, compiler auto-promotes
+const cls = ns["cn"]("base", size.value > 50 && "big");
+```
+
+#### 4. Use a manual `() =>` getter (fallback for truly dynamic patterns)
+
+If you genuinely need dynamic import (e.g. for code-splitting) or computed member access with a variable key, wrap the expression in a manual `() =>` getter. The runtime will re-evaluate it in an effect whenever its tracked dependencies change.
+
+```ts
+import * as ns from "./utils";
+import { computed } from "sinwan/reactivity";
+
+// Manual getter — the compiler does not promote it, but the runtime
+// wraps it in an effect so it stays reactive.
+const cls = () => {
+  const key = "cn";
+  return ns[key]("base", size.value > 50 && "big");
+};
+
+// Or use computed() for a memoized version (re-evaluates only when
+// size.value changes, not on every access):
+const clsMemo = computed(() => {
+  const key = "cn";
+  return ns[key]("base", size.value > 50 && "big");
+});
+```
+
+#### 5. Use `computed()` for expensive dynamic patterns
+
+If the dynamic expression is expensive (e.g. involves an `await import()`), use `computed()` to memoize the result. The computation runs once and caches until a dependency changes.
+
+```ts
+import { computed } from "sinwan/reactivity";
+
+// computed() runs the async import lazily and caches the result.
+// The compiler does not promote this (it's already a getter),
+// but the runtime tracks size.value as a dependency.
+const cls = computed(() => {
+  // For dynamic import, you would need to resolve the module
+  // outside the computed() and only use the dynamic key inside:
+  const key = "cn";
+  return ns[key]("base", size.value > 50 && "big");
+});
+```
+
+#### Complete demo
+
+```ts
+// lib/utils.ts
+/** @sinwan-pure */
+export function cn(...inputs: unknown[]): string {
+  return String(inputs);
+}
+
+/** @sinwan-pure */
+export const helpers = {
+  merge: (...inputs: unknown[]): string => String(inputs),
+};
+
+// comp.tsx
+import { cc } from "sinwan/component";
+import { signal, computed } from "sinwan/reactivity";
+import { cn, helpers } from "../lib/utils";
+import * as ns from "../lib/utils";
+
+export const App = cc(() => {
+  const size = signal(30);
+
+  // ✅ Auto-promoted — static import + @sinwan-pure
+  const a = cn("base", size.value > 50 && "big");
+
+  // ✅ Auto-promoted — namespace import + direct member access
+  const b = ns.cn("base", size.value > 50 && "big");
+
+  // ✅ Auto-promoted — string literal key
+  const c = ns["cn"]("base", size.value > 50 && "big");
+
+  // ✅ Auto-promoted — object member call
+  const d = helpers.merge("base", size.value > 50 && "big");
+
+  // ✅ Manual getter — for computed member access with variable key
+  const e = () => {
+    const key = "cn";
+    return ns[key]("base", size.value > 50 && "big");
+  };
+
+  // ✅ computed() — memoized, re-evaluates only when size.value changes
+  const f = computed(() => ns.cn("base", size.value > 50 && "big"));
+
+  return <div class={a} data-b={b} data-c={c} data-d={d} data-e={e} data-f={f} />;
+});
+```
+
+Compiled output:
+
+```ts
+const a = () => cn("base", size.value > 50 && "big");
+const b = () => ns.cn("base", size.value > 50 && "big");
+const c = () => ns["cn"]("base", size.value > 50 && "big");
+const d = () => helpers.merge("base", size.value > 50 && "big");
+const e = () => {
+  // manual getter — preserved as-is
+  const key = "cn";
+  return ns[key]("base", size.value > 50 && "big");
+};
+const f = computed(() => ns.cn("base", size.value > 50 && "big")); // already a getter
+```
+
+### Client, SSR and hydration
+
+Generated getter calls use the existing JSX wrapping and explicit-binding rules; manual getter identifiers do not need a new blanket wrapping policy. Native attributes must use a runtime build with plain zero-argument getter hydration support. Text, attributes and `Show` remain reactive after hydration; event handlers and nonzero-arity callbacks are not invoked as getters.
+
+The runtime's existing complex-template hydration fallback can replace a hoisted server subtree during initial hydration. Promotion does not change that policy; subsequent signal updates do not remount the native shell. Non-hoisted attribute hydration binds to the existing DOM in place.
+
 ## DOM vs component JSX
 
 **Native elements** (`div`, `p`, `button`, …): wrap reactive children and attributes.
@@ -110,18 +410,18 @@ Not wrapped:
 **User components** (`<Label>`, `<Child title={…} />`):
 
 - **Children:** wrap reactive reads the same way as DOM text (`{count.value}`, `{checked.value ? "On" : "Off"}`) so `cc()` parents do not snapshot the value. Use a getter (`() => …`), never `_$bindText`, because the child may render nodes as well as strings. Render-prop functions (`{(v) => …}`) stay untouched.
-- **Props:** wrap a prop if it is known-reactive for that component (built-in registry, local call graph, analyzer metadata). For *unknown* imported components, still wrap **derived reads** (`htmlFor={id.value}`, `disabled={off.value}`) and leave **container pass-through** alone (`checked={checked}`, `user={user}`) so the child receives the signal or store proxy. With `explicitBindings`, component props stay **getters** (`each={() => …}`), never `_$bindAttr` — `For` / `Show` / `Label` call `resolve(prop)`, which does not unwrap bind descriptors.
+- **Props:** wrap a prop if it is known-reactive for that component (built-in registry, local call graph, analyzer metadata). For _unknown_ imported components, still wrap **derived reads** (`htmlFor={id.value}`, `disabled={off.value}`) and leave **container pass-through** alone (`checked={checked}`, `user={user}`) so the child receives the signal or store proxy. With `explicitBindings`, component props stay **getters** (`each={() => …}`), never `_$bindAttr` — `For` / `Show` / `Label` call `resolve(prop)`, which does not unwrap bind descriptors.
 
 **Built-in control-flow** components wrap specific props, and they wrap reactive expression children (those children render directly):
 
-| Component | Reactive props |
-| --------- | -------------- |
-| `For`, `Index`, `Virtual` | `each` |
-| `Show`, `Switch`, `Match`, `Key` | `when` |
-| `Dynamic` | `component` |
-| `Visible` | `when`, `style` |
-| `Portal` | `mount` |
-| `Activity` | `mode` |
+| Component                        | Reactive props  |
+| -------------------------------- | --------------- |
+| `For`, `Index`, `Virtual`        | `each`          |
+| `Show`, `Switch`, `Match`, `Key` | `when`          |
+| `Dynamic`                        | `component`     |
+| `Visible`                        | `when`, `style` |
+| `Portal`                         | `mount`         |
+| `Activity`                       | `mode`          |
 
 `Suspense` is not in this list; its props are left alone.
 
@@ -131,12 +431,12 @@ Static native trees become a module-level template plus `_$createTemplate(tmpl,
 
 Slots:
 
-| Type | When |
-| ---- | ---- |
+| Type    | When                                       |
+| ------- | ------------------------------------------ |
 | `child` | `{expr}`, or a capitalized child component |
-| `attr` | Dynamic attribute (not `on*`) |
-| `event` | `onClick={…}` and other `on*` handlers |
-| `ref` | `ref={fn}` or `ref={object}` |
+| `attr`  | Dynamic attribute (not `on*`)              |
+| `event` | `onClick={…}` and other `on*` handlers     |
+| `ref`   | `ref={fn}` or `ref={object}`               |
 
 Static `style` objects and strings are written into the HTML (`backgroundColor` → `background-color`). Quoted style strings that contain `${…}` log a warning in the compiler: use a template literal, `style={\`…${x}\`}`.
 
@@ -150,6 +450,7 @@ The slot marker format is `COMPILER_TEMPLATE_SLOT_PROTOCOL` (`s:0`, `s:1`, …).
 
 ```ts
 transformJSX(code, "src/App.tsx", {
+  derivedLocals: false,
   hoist: true, // default true
   dev: false, // warn when hoisting is skipped
   explicitBindings: false, // emit _$bindText / _$bindAttr / …

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,13 +42,13 @@
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@babel/core": "^7.24.0",
-    "@babel/generator": "^7.24.0",
-    "@babel/parser": "^7.24.0",
-    "@babel/traverse": "^7.24.0",
-    "@babel/types": "^7.24.0"
+    "@babel/core": "^7.29.7",
+    "@babel/generator": "^7.29.8",
+    "@babel/parser": "^7.29.8",
+    "@babel/traverse": "^7.29.8",
+    "@babel/types": "^7.29.8"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": ">=5.0.0 <8.0.0"
   }
 }