sinwan-compiler 1.0.0 → 1.1.1

package/README.md

@@ -19,7 +19,7 @@ bun add -d sinwan-compiler
 
 App templates already depend on the Bun or Vite plugin. You only need this package if you call the compiler yourself.
 
-The plugins declare `sinwan-compiler` as `>=0.2.5 <1.0.0`. After you publish a new 0.x compiler, do **not** bump the plugins. Apps pick it up with a fresh install or `bun update sinwan-compiler`. Republish a plugin only if its own API changed.
+The plugins depend on `sinwan-compiler` `>=1.0.0 <2.0.0`. A new 1.x compiler is picked up with `bun update sinwan-compiler`. Publish a new plugin when its own API changes, or when the compiler reaches 2.0.
 
 ## Production analysis
 

package/dist/{chunk-rshqq0t3.js → chunk-52vtv5h0.js}

@@ -1156,6 +1156,38 @@ function unwrapFunctionPath(fnPath) {
 function ccCall(arg, ccName) {
   return callExpression(identifier(ccName), [arg]);
 }
+function withTypes(fn, from) {
+  fn.typeParameters = from.typeParameters;
+  fn.returnType = from.returnType;
+  return fn;
+}
+function isReadBeforeDeclaration(path, name) {
+  const start = path.node.start ?? 0;
+  return (path.parentPath.scope.getBinding(name)?.referencePaths ?? []).some((ref) => (ref.node.start ?? 0) < start && !ref.getFunctionParent() && ref.parent?.type !== "ExportSpecifier" && !ref.findParent((parent) => parent.isTSType()));
+}
+function collectSpecifierExports(ast) {
+  const exports = new Map;
+  traverse(ast, {
+    ExportNamedDeclaration(path) {
+      const node = path.node;
+      if (node.declaration || node.source || node.exportKind === "type")
+        return;
+      for (const spec of node.specifiers ?? []) {
+        if (!isExportSpecifier(spec) || spec.exportKind === "type")
+          continue;
+        if (!isIdentifier(spec.local) || !isIdentifier(spec.exported))
+          continue;
+        if (isComponentName(spec.exported.name)) {
+          exports.set(spec.local.name, spec.exported.name);
+        }
+      }
+    }
+  });
+  return exports;
+}
+function isTopLevel(path) {
+  return path.parent?.type === "Program";
+}
 function autoWrapComponents2(ast, filename) {
   const { aliases, alreadyImported } = collectCcAliases(ast);
   const ccName = aliases.values().next().value;
@@ -1170,6 +1202,24 @@ function autoWrapComponents2(ast, filename) {
       return false;
     return true;
   };
+  const wrapDeclarators = (declarators, componentName) => {
+    for (const dPath of declarators) {
+      const id = dPath.node.id;
+      if (!isIdentifier(id))
+        continue;
+      const name = componentName(id.name);
+      if (name === undefined || !dPath.node.init)
+        continue;
+      const initPath = unwrapFunctionPath(dPath.get("init"));
+      if (!isFunction(initPath.node))
+        continue;
+      if (!wrapIfCandidate(initPath, name))
+        continue;
+      dPath.node.init = ccCall(initPath.node, ccName ?? "cc");
+      changed = true;
+    }
+  };
+  const specifierExports = collectSpecifierExports(ast);
   traverse(ast, {
     ExportNamedDeclaration(path) {
       const decl = path.node.declaration;
@@ -1180,7 +1230,7 @@ function autoWrapComponents2(ast, filename) {
         const fnPath = path.get("declaration");
         if (!wrapIfCandidate(fnPath, name))
           return;
-        const fnExpr = functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const fnExpr = withTypes(functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async), decl);
         const varDecl = variableDeclaration("const", [
           variableDeclarator(identifier(name), ccCall(fnExpr, ccName ?? "cc"))
         ]);
@@ -1189,27 +1239,30 @@ function autoWrapComponents2(ast, filename) {
         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;
-        }
+        wrapDeclarators(path.get("declaration.declarations"), (name) => isComponentName(name) ? name : undefined);
         return;
       }
     },
+    FunctionDeclaration(path) {
+      const decl = path.node;
+      if (!isTopLevel(path) || !isIdentifier(decl.id))
+        return;
+      const exported = specifierExports.get(decl.id.name);
+      if (exported === undefined || !wrapIfCandidate(path, exported))
+        return;
+      if (isReadBeforeDeclaration(path, decl.id.name))
+        return;
+      const fnExpr = withTypes(functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async), decl);
+      path.replaceWith(variableDeclaration("const", [
+        variableDeclarator(identifier(decl.id.name), ccCall(fnExpr, ccName ?? "cc"))
+      ]));
+      changed = true;
+    },
+    VariableDeclaration(path) {
+      if (!isTopLevel(path))
+        return;
+      wrapDeclarators(path.get("declarations"), (name) => specifierExports.get(name));
+    },
     ExportDefaultDeclaration(path) {
       const decl = isNode(path.node.declaration) ? unwrapParens(path.node.declaration) : path.node.declaration;
       if (isFunctionDeclaration(decl) && isIdentifier(decl.id)) {
@@ -1217,7 +1270,7 @@ function autoWrapComponents2(ast, filename) {
         const fnPath = path.get("declaration");
         if (!wrapIfCandidate(fnPath, name))
           return;
-        const fnDecl = functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const fnDecl = withTypes(functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async), decl);
         const exportDefault = exportDefaultDeclaration(ccCall(identifier(name), ccName ?? "cc"));
         path.replaceWithMultiple([fnDecl, exportDefault]);
         changed = true;
@@ -1227,7 +1280,7 @@ function autoWrapComponents2(ast, filename) {
         const fnPath = path.get("declaration");
         if (!wrapIfCandidate(fnPath, null))
           return;
-        const fnExpr = functionExpression(null, decl.params, decl.body, decl.generator, decl.async);
+        const fnExpr = withTypes(functionExpression(null, decl.params, decl.body, decl.generator, decl.async), decl);
         path.node.declaration = ccCall(fnExpr, ccName ?? "cc");
         changed = true;
         return;
@@ -2236,7 +2289,7 @@ class AnalyzerCache2 {
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
-    fs.writeFileSync(this.cachePath, JSON.stringify(data, null, 2));
+    fs.writeFileSync(this.cachePath, JSON.stringify(data));
   }
   restore() {
     if (!this.cachePath || !fs.existsSync(this.cachePath))
@@ -2492,7 +2545,32 @@ function trackReactiveImports2(ast) {
   });
   return names;
 }
+function fileStamp(file) {
+  return fs2.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+}
+function freshScan(cache, file) {
+  const entry = cache.get(file);
+  if (!entry)
+    return;
+  for (const [stamped, mtime] of entry.stamps) {
+    if (fileStamp(stamped) !== mtime)
+      return;
+  }
+  return entry;
+}
+function mergeStamps(into, from) {
+  for (const [file, mtime] of from)
+    into.set(file, mtime);
+}
 var pureImportCache = new Map;
+function pureExportsOf(filePath, resolveImport, depth = 0) {
+  const cached = freshScan(pureImportCache, filePath);
+  if (cached)
+    return cached;
+  const scan = scanPureExports(filePath, resolveImport, depth);
+  pureImportCache.set(filePath, scan);
+  return scan;
+}
 var PURE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -2613,13 +2691,14 @@ function resolveAnyImport(source, fromFile, resolveImport) {
 }
 function scanPureExports(filePath, resolveImport, depth = 0) {
   const pure = new Map;
+  const scan = { value: pure, stamps: new Map([[filePath, fileStamp(filePath)]]) };
   if (depth > 10)
-    return pure;
+    return scan;
   let code;
   try {
     code = fs2.readFileSync(filePath, "utf-8");
   } catch {
-    return pure;
+    return scan;
   }
   let ast;
   try {
@@ -2629,7 +2708,7 @@ function scanPureExports(filePath, resolveImport, depth = 0) {
       sourceFilename: filePath
     });
   } catch {
-    return pure;
+    return scan;
   }
   const hasPureJSDoc = (node) => node?.leadingComments?.some((c) => c.type === "CommentBlock" && c.value.includes("@sinwan-pure")) ?? false;
   traverse(ast, {
@@ -2657,11 +2736,9 @@ function scanPureExports(filePath, resolveImport, depth = 0) {
       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);
-          }
+          const nested = pureExportsOf(resolved, resolveImport, depth + 1);
+          mergeStamps(scan.stamps, nested.stamps);
+          const reExportPure = nested.value;
           for (const spec of p.node.specifiers ?? []) {
             if (!isExportSpecifier(spec))
               continue;
@@ -2692,11 +2769,9 @@ function scanPureExports(filePath, resolveImport, depth = 0) {
       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);
-      }
+      const nested = pureExportsOf(resolved, resolveImport, depth + 1);
+      mergeStamps(scan.stamps, nested.stamps);
+      const reExportPure = nested.value;
       for (const [name, kind] of reExportPure) {
         if (name !== "default") {
           pure.set(name, kind);
@@ -2704,7 +2779,7 @@ function scanPureExports(filePath, resolveImport, depth = 0) {
       }
     }
   });
-  return pure;
+  return scan;
 }
 function collectPureImports(ast, filename, resolveImport) {
   const result = {
@@ -2725,11 +2800,7 @@ function collectPureImports(ast, filename, resolveImport) {
       const resolved = resolveAnyImport(source, absoluteFilename, resolveImport);
       if (!resolved)
         return;
-      let filePure = pureImportCache.get(resolved);
-      if (!filePure) {
-        filePure = scanPureExports(resolved, resolveImport);
-        pureImportCache.set(resolved, filePure);
-      }
+      const filePure = pureExportsOf(resolved, resolveImport).value;
       for (const spec of p.node.specifiers ?? []) {
         if (isImportSpecifier(spec)) {
           const imported = importedBindingName(spec.imported);
@@ -3684,11 +3755,16 @@ function hasSnapshotPragma(node) {
 function isTypePosition(ref) {
   return ref.findParent((parent) => parent.isTSType()) != null;
 }
+function hasPureJSDoc(node) {
+  return node?.leadingComments?.some((comment) => comment.type === "CommentBlock" && comment.value.includes("@sinwan-pure")) ?? false;
+}
 function canRewriteDerivedReference(ref) {
   if (!ref.isIdentifier() || !ref.isReferencedIdentifier())
     return false;
   if (isTypePosition(ref))
     return true;
+  if (isPureArrayReadReceiver(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;
@@ -3696,12 +3772,165 @@ function canRewriteDerivedReference(ref) {
   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())
+var ARRAY_RESULT_READS = new Set(["map", "filter", "flatMap", "flat", "slice", "concat"]);
+var CALLBACK_ARRAY_READS = new Set([
+  "map",
+  "filter",
+  "flatMap",
+  "find",
+  "findIndex",
+  "some",
+  "every",
+  "reduce"
+]);
+var PURE_ARRAY_READS = new Set([
+  ...ARRAY_RESULT_READS,
+  ...CALLBACK_ARRAY_READS,
+  "join",
+  "at",
+  "includes",
+  "indexOf",
+  "entries",
+  "keys",
+  "values"
+]);
+var DATE_READS = new Set([
+  "getFullYear",
+  "getMonth",
+  "getDate",
+  "getDay",
+  "getTime",
+  "getHours",
+  "getMinutes",
+  "getSeconds",
+  "getMilliseconds",
+  "valueOf"
+]);
+var PURE_METHOD_READS = new Set([...PURE_ARRAY_READS, ...DATE_READS]);
+function builtinKindOfType(node) {
+  const typeNode = unwrapTypeNode(node);
+  if (typeNode?.type === "TSArrayType")
+    return "array";
+  if (typeNode?.type !== "TSTypeReference")
+    return null;
+  const name = typeNode.typeName;
+  if (!isIdentifier(name))
+    return null;
+  if (name.name === "Array" || name.name === "ReadonlyArray")
+    return "array";
+  return name.name === "Date" ? "date" : null;
+}
+function isGlobalArrayFrom(callee, scope) {
+  return isMemberExpression(callee) && !callee.computed && isIdentifier(callee.object, { name: "Array" }) && isIdentifier(callee.property, { name: "from" }) && !scope.getBinding("Array");
+}
+function builtinKindOf(node, scope, seen = new Set) {
+  const expr = unwrapParens(node);
+  if (expr.type === "ArrayExpression")
+    return "array";
+  if (isCallExpression(expr)) {
+    const callee = unwrapParens(expr.callee);
+    if (isGlobalArrayFrom(callee, scope))
+      return "array";
+    if (isMemberExpression(callee)) {
+      return !callee.computed && isIdentifier(callee.property) && ARRAY_RESULT_READS.has(callee.property.name) && builtinKindOf(callee.object, scope, seen) === "array" ? "array" : null;
+    }
+    const fn = isIdentifier(callee) ? scope.getBinding(callee.name)?.path : undefined;
+    const declared = fn?.isVariableDeclarator() ? fn.node.init : fn?.node;
+    return functionParamCount(declared) === null ? null : builtinKindOfType(declared?.returnType);
+  }
+  if (!isIdentifier(expr))
+    return null;
+  const binding = scope.getBinding(expr.name);
+  if (!binding || binding.kind !== "const" || !binding.path.isVariableDeclarator() || seen.has(binding.path.node)) {
+    return null;
+  }
+  seen.add(binding.path.node);
+  const declarator = binding.path.node;
+  return builtinKindOfType(declarator.id?.typeAnnotation) ?? (declarator.init ? builtinKindOf(declarator.init, binding.path.scope, seen) : null);
+}
+function functionParamCount(node) {
+  if (!node || !isFunctionDeclaration(node) && !isFunctionExpression(node) && !isArrowFunctionExpression(node)) {
+    return null;
+  }
+  return node.params.length;
+}
+function isPureArrayReadReceiver(ref) {
+  const member = ref.parentPath;
+  if (!member || !member.isMemberExpression() && !member.isOptionalMemberExpression() || ref.key !== "object" || member.node.computed || !isIdentifier(member.node.property) || !PURE_METHOD_READS.has(member.node.property.name)) {
     return false;
+  }
+  const call = member.parentPath;
+  return !!call && (call.isCallExpression() || call.isOptionalCallExpression()) && member.key === "callee";
+}
+function callParts(path) {
   const call = unwrapCall(path.node);
-  const callee = unwrapParens(call.callee);
-  const args = call.arguments ?? [];
+  return { callee: unwrapParens(call.callee), args: call.arguments ?? [] };
+}
+function isSameFilePureFunction(binding) {
+  const owner = binding.path.parentPath?.node;
+  if (binding.path.isFunctionDeclaration()) {
+    return hasPureJSDoc(binding.path.node) || owner?.type === "ExportNamedDeclaration" && hasPureJSDoc(owner);
+  }
+  if (!binding.path.isVariableDeclarator())
+    return false;
+  const declarator = binding.path.node;
+  const exported = binding.path.parentPath?.parentPath?.node;
+  return functionParamCount(declarator.init) != null && (hasPureJSDoc(declarator) || hasPureJSDoc(declarator.init) || hasPureJSDoc(owner) || exported?.type === "ExportNamedDeclaration" && hasPureJSDoc(exported));
+}
+function isPureFunctionReference(node, path, pureImports) {
+  if (!isIdentifier(node))
+    return false;
+  const binding = path.scope.getBinding(node.name);
+  if (!binding)
+    return false;
+  return isSameFilePureFunction(binding) || (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && pureImports.direct.has(node.name);
+}
+function acceptCallback(arg, path, ctx) {
+  if (isArrowFunctionExpression(arg) || isFunctionExpression(arg)) {
+    ctx.callbacks.add(arg);
+    return true;
+  }
+  return isPureFunctionReference(arg, path, ctx.pureImports);
+}
+function isBuiltinReadCall(path, callee, args, ctx) {
+  if (isGlobalArrayFrom(callee, path.scope)) {
+    return args.length < 2 || acceptCallback(args[1], path, ctx);
+  }
+  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property)) {
+    return false;
+  }
+  const method = callee.property.name;
+  const kind = builtinKindOf(callee.object, path.scope);
+  if (kind === "date")
+    return DATE_READS.has(method);
+  if (kind !== "array" || !PURE_ARRAY_READS.has(method))
+    return false;
+  return !CALLBACK_ARRAY_READS.has(method) || acceptCallback(args[0], path, ctx);
+}
+function inspectLocalGetterCall(path, ctx) {
+  const { callee, args } = callParts(path);
+  if (args.length !== 0 || !isIdentifier(callee))
+    return null;
+  const binding = path.scope.getBinding(callee.name);
+  if (!binding?.path.isVariableDeclarator() || isSameFilePureFunction(binding)) {
+    return null;
+  }
+  const declarator = binding.path;
+  const getter = declarator.node.init;
+  if (functionParamCount(getter) !== 0)
+    return null;
+  if (!isArrowFunctionExpression(getter) || getter.async || isBlockStatement(getter.body) || ctx.visiting.has(getter)) {
+    return { safe: false, reactive: false };
+  }
+  ctx.visiting.add(getter);
+  const result = inspectDerivedExpression(singlePath(declarator.get("init.body")), declarator.node.start ?? Infinity, ctx);
+  ctx.visiting.delete(getter);
+  return result;
+}
+function isPureDerivedCall(path, ctx) {
+  const { callee, args } = callParts(path);
+  if (isBuiltinReadCall(path, callee, args, ctx))
+    return true;
   if (isMemberExpression(callee) || isOptionalMemberExpression(callee)) {
     const props = [];
     let node = unwrapParens(callee);
@@ -3726,10 +3955,10 @@ function isPureDerivedCall(path, names, pureImports) {
     if (!isIdentifier(node))
       return false;
     const root = node.name;
-    if (pureImports.member.has(root)) {
+    if (ctx.pureImports.member.has(root)) {
       return true;
     }
-    const nsMembers = pureImports.namespace.get(root);
+    const nsMembers = ctx.pureImports.namespace.get(root);
     if (nsMembers && props.some((p) => nsMembers.has(p))) {
       return true;
     }
@@ -3741,17 +3970,14 @@ function isPureDerivedCall(path, names, pureImports) {
   if (!binding) {
     return ["Boolean", "Number", "String"].includes(callee.name) && args.length === 1;
   }
-  if ((binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && pureImports.direct.has(callee.name)) {
+  if (isPureFunctionReference(callee, path, ctx.pureImports))
     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;
+  return isArrayPattern(id) && id.elements[0] === binding.identifier && isCallExpression(init) && isIdentifier(init.callee) && ctx.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();
+function inspectDerivedExpression(root, before, ctx) {
   let safe = true;
   let reactive = false;
   const inspect = (path) => {
@@ -3762,29 +3988,49 @@ function isDerivedInitializer(declaration, scope, names, derived, pureImports) {
     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))) {
+      if (binding && (!binding.constant || binding.kind === "let" || binding.kind === "var" || binding.path.isVariableDeclarator() && (binding.path.node.start ?? -1) >= before)) {
         safe = false;
         return;
       }
-      if (binding && derived.has(binding))
+      if (binding && ctx.derived.has(binding))
         reactive = true;
-      if (isReactiveRead(node, scope))
+      if (isReactiveRead(node, ctx.scope))
         reactive = true;
     } else if (path.isMemberExpression() || path.isOptionalMemberExpression()) {
-      if (isReactiveRead(node, scope))
+      if (isReactiveRead(node, ctx.scope))
         reactive = true;
     } else if (path.isCallExpression() || path.isOptionalCallExpression()) {
-      if (!isPureDerivedCall(path, names, pureImports))
+      const getter = inspectLocalGetterCall(path, ctx);
+      if (getter) {
+        if (!getter.safe)
+          safe = false;
+        if (getter.reactive)
+          reactive = true;
+      } else if (!isPureDerivedCall(path, ctx)) {
         safe = false;
-      if (isGetterCall(path.node, scope))
+      }
+      if (isGetterCall(path.node, ctx.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())) {
+    } else if ((path.isArrowFunctionExpression() || path.isFunctionExpression()) && ctx.callbacks.has(path.node)) {} 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);
+  inspect(root);
   if (safe)
-    init.traverse({ enter: inspect });
+    root.traverse({ enter: inspect });
+  return { safe, reactive };
+}
+function isDerivedInitializer(declaration, scope, names, derived, pureImports) {
+  const init = singlePath(declaration.get("init"));
+  init.assertExpression();
+  const { safe, reactive } = inspectDerivedExpression(init, declaration.node.start ?? Infinity, {
+    scope,
+    names,
+    derived,
+    pureImports,
+    callbacks: new Set,
+    visiting: new Set
+  });
   return safe && reactive;
 }
 function promoteReactiveConstInitializers(ast, options) {
@@ -3873,8 +4119,196 @@ function promoteReactiveConstInitializers(ast, options) {
     }
   });
 }
+var readerParamCache = new Map;
+function unwrapTypeNode(node) {
+  if (!node)
+    return null;
+  if (node.type === "TSTypeAnnotation" || node.type === "TSParenthesizedType") {
+    return unwrapTypeNode(node.typeAnnotation ?? null);
+  }
+  return node;
+}
+function typeReferencesLiveRead(node) {
+  const typeNode = unwrapTypeNode(node);
+  if (!typeNode)
+    return false;
+  if (typeNode.type === "TSTypeReference") {
+    const name = typeNode.typeName;
+    return isIdentifier(name) && name.name === "LiveRead";
+  }
+  if (typeNode.type === "TSUnionType" || typeNode.type === "TSIntersectionType") {
+    const types = typeNode.types ?? [];
+    return types.some((part) => typeReferencesLiveRead(part));
+  }
+  return false;
+}
+function readerParamIndexes(params) {
+  const indexes = [];
+  for (const [index, param] of (params ?? []).entries()) {
+    if (!param || param.type === "RestElement")
+      continue;
+    const annotated = param.type === "AssignmentPattern" ? param.left : param;
+    const annotation = param.typeAnnotation ?? annotated?.typeAnnotation;
+    if (typeReferencesLiveRead(annotation))
+      indexes.push(index);
+  }
+  return indexes;
+}
+function functionParamsOf(node) {
+  if (!node || !isFunctionDeclaration(node) && !isFunctionExpression(node) && !isArrowFunctionExpression(node)) {
+    return null;
+  }
+  return node.params;
+}
+function scanReaderExports(filePath, resolveImport, depth = 0) {
+  const cached = freshScan(readerParamCache, filePath);
+  if (cached)
+    return cached;
+  const found = new Map;
+  const scan = { value: found, stamps: new Map([[filePath, fileStamp(filePath)]]) };
+  readerParamCache.set(filePath, scan);
+  if (depth > 10)
+    return scan;
+  let code;
+  try {
+    code = fs2.readFileSync(filePath, "utf-8");
+  } catch {
+    return scan;
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      sourceFilename: filePath
+    });
+  } catch {
+    return scan;
+  }
+  const record = (name, params) => {
+    if (!params)
+      return;
+    const indexes = readerParamIndexes(params);
+    if (indexes.length > 0)
+      found.set(name, indexes);
+  };
+  traverse(ast, {
+    ExportNamedDeclaration(p) {
+      const decl = p.node.declaration;
+      if (isFunctionDeclaration(decl) && decl.id && isIdentifier(decl.id)) {
+        record(decl.id.name, decl.params);
+      } else if (decl && isVariableDeclaration(decl)) {
+        for (const declarator of decl.declarations) {
+          if (!isIdentifier(declarator.id))
+            continue;
+          record(declarator.id.name, functionParamsOf(declarator.init));
+        }
+      }
+      const source = moduleSourceValue(p.node.source);
+      if (!source)
+        return;
+      const resolved = resolveAnyImport(source, filePath, resolveImport);
+      if (!resolved)
+        return;
+      const nested = scanReaderExports(resolved, resolveImport, depth + 1);
+      mergeStamps(scan.stamps, nested.stamps);
+      for (const spec of p.node.specifiers ?? []) {
+        if (!isExportSpecifier(spec))
+          continue;
+        const exported = importedBindingName(spec.exported);
+        const local = importedBindingName(spec.local);
+        if (!exported || !local)
+          continue;
+        const indexes = nested.value.get(local);
+        if (indexes)
+          found.set(exported, indexes);
+      }
+    }
+  });
+  return scan;
+}
+function readerIndexesForCallee(path, imported) {
+  const callee = unwrapParens(path.node.callee);
+  if (!isIdentifier(callee))
+    return [];
+  const binding = path.scope.getBinding(callee.name);
+  if (!binding)
+    return [];
+  if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) {
+    return imported.get(callee.name) ?? [];
+  }
+  if (binding.path.isFunctionDeclaration()) {
+    return readerParamIndexes(binding.path.node.params);
+  }
+  if (binding.path.isVariableDeclarator()) {
+    return readerParamIndexes(functionParamsOf(binding.path.node.init) ?? []);
+  }
+  return [];
+}
+function wrapLiveReadArguments(ast, options) {
+  const names = trackReactiveImports2(ast);
+  const imported = new Map;
+  const filename = options.filename ? path2.resolve(options.filename) : "";
+  traverse(ast, {
+    ImportDeclaration(p) {
+      const source = moduleSourceValue(p.node.source);
+      if (!source || !filename)
+        return;
+      const resolved = resolveAnyImport(source, filename, options.resolveImport);
+      if (!resolved)
+        return;
+      const exports = scanReaderExports(resolved, options.resolveImport).value;
+      for (const spec of p.node.specifiers ?? []) {
+        if (isImportSpecifier(spec)) {
+          const exported = importedBindingName(spec.imported);
+          const indexes = exported ? exports.get(exported) : undefined;
+          if (indexes)
+            imported.set(spec.local.name, indexes);
+        } else if (isImportDefaultSpecifier(spec)) {
+          const indexes = exports.get("default");
+          if (indexes)
+            imported.set(spec.local.name, indexes);
+        }
+      }
+    }
+  });
+  const { functions } = collectComponentFunctions2(ast, names.cc);
+  const scopes = new Map;
+  traverse(ast, {
+    CallExpression(callPath) {
+      const indexes = readerIndexesForCallee(callPath, imported);
+      if (indexes.length === 0)
+        return;
+      const fnPath = callPath.getFunctionParent();
+      const fn = fnPath?.node;
+      if (!fnPath || !fn || !isFunction(fn) || !functions.has(fn))
+        return;
+      let scope = scopes.get(fn);
+      if (!scope) {
+        scope = { bindings: new Map };
+        trackPropBindings(scope, fn.params[0], getAllPropNames2(fn.params[0]));
+        trackLocalScopeBindings(fnPath, names, scope, true);
+        scopes.set(fn, scope);
+      }
+      const argPaths = callPath.get("arguments");
+      const args = Array.isArray(argPaths) ? argPaths : [argPaths];
+      for (const index of indexes) {
+        const argPath = args[index];
+        if (!argPath || argPath.node.type === "SpreadElement")
+          continue;
+        const expr = unwrapParens(argPath.node);
+        if (!isExpression(expr) || isFunctionLike(expr))
+          continue;
+        if (!containsReactiveRead(expr, scope))
+          continue;
+        argPath.replaceWith(arrowFunctionExpression([], argPath.node));
+      }
+    }
+  });
+}
 function wrapReactiveExpressions2(ast, options = {}) {
   promoteReactiveConstInitializers(ast, options);
+  wrapLiveReadArguments(ast, options);
   let metadata = null;
   if (options.analyzeMetadata) {
     metadata = options.analyzeMetadata;

package/dist/cli.js

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

package/dist/index.js

@@ -64,7 +64,7 @@ import {
   propagateReactiveProps2,
   wrapReactiveExpressions2,
   runAnalyzeCli2
-} from "./chunk-rshqq0t3.js";
+} from "./chunk-52vtv5h0.js";
 
 // src/live-cc-destructure.ts
 var CC_SOURCE_MODULES = new Set(["sinwan", "sinwan/component"]);
@@ -216,7 +216,7 @@ function hasLocalSpecifier(stmt, local) {
 function ensureComponentImport(ast, imported, local) {
   let target = null;
   for (const stmt of ast.program.body) {
-    if (!isImportDeclaration(stmt))
+    if (!isImportDeclaration(stmt) || stmt.importKind === "type")
       continue;
     if (hasLocalSpecifier(stmt, local))
       return;

package/docs/api.md

@@ -29,7 +29,7 @@ See [Transform](transform.md) for wrapping rules and options.
 
 ### `autoWrapComponents(ast, filename?)`
 
-Mutates an ESTree AST (oxc-parser): wrap exported component-like functions with `cc(...)`. Returns `true` if anything changed. `transformJSX` already runs this.
+Mutates an ESTree AST (oxc-parser): wrap exported component-like functions (including `function X` / `const X` exported through `export { X }`) with `cc(...)`. Returns `true` if anything changed. `transformJSX` already runs this.
 
 ### `rewriteLiveCcDestructure(ast)`
 

package/docs/transform.md

@@ -32,7 +32,7 @@ Exported functions that look like components are wrapped for you. You can write
 
 A candidate must be:
 
-- **Exported** (named or default)
+- **Exported** (named or default): `export function`, `export const`, `export default`, or a top-level `function` / `const` exported through `export { X }` or `export { X as Name }` (the exported name must be uppercase)
 - **Uppercase** (or an anonymous `export default function ()`)
 - **0 or 1 parameter**
 - **Returning JSX** in that function (not only in a nested helper)
@@ -50,7 +50,9 @@ export const App = cc(function App() {
 });
 ```
 
-Not wrapped: lowercase helpers, generators, multi-argument functions, or functions that never return JSX. If `cc` is not imported yet, the compiler adds `import { cc } from "sinwan/component"`.
+Not wrapped: lowercase helpers, generators, multi-argument functions, functions that never return JSX, type-only exports, re-exports (`export { X } from "./x"`), components that are not exported, and a `function X` exported through `export { X }` that module code reads before its declaration (for example `const Group = Object.assign(X, { Item })` above it), because turning it into `const X = cc(...)` would make that read throw. Reads inside functions, export specifiers and types do not count. A `cc` parent passes reactive props to child components as getters, so a non-exported component that receives props from one must be wrapped with `cc(...)` explicitly. If `cc` is not imported yet, the compiler adds `import { cc } from "sinwan/component"`.
+
+Type parameters and return types are kept on the wrapped function. A circular import that reads `X` at module load before this file finishes evaluating is not detected; `export function X` has the same limitation.
 
 `cc` may be imported from `sinwan` or `sinwan/component`.
 
@@ -138,7 +140,10 @@ return (
 
 - 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.
+- 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 a function annotated with `/** @sinwan-pure */` (imported, or declared in the same file), a local zero-arity arrow getter whose expression body is itself safe (`const yearNow = () => …`, then `props.fromYear ?? yearNow() - 10`), or a built-in read on a known array or `Date` (below). See [`@sinwan-pure` JSDoc contract](#sinwan-pure-jsdoc-contract) below. A getter with a block body, side effects (`() => count++`) or a call back into itself stays eager. Explicit getter and `computed` initializers are unchanged.
+- Built-in reads: `Array.from(...)`, non-mutating array reads (`map`, `filter`, `flatMap`, `flat`, `slice`, `concat`, `join`, `at`, `find`, `findIndex`, `some`, `every`, `reduce`, `includes`, `indexOf`, `entries`, `keys`, `values`) and `Date` getters (`getFullYear`, `getMonth`, `getDate`, `getDay`, `getTime`, `getHours`, `getMinutes`, `getSeconds`, `getMilliseconds`, `valueOf`) promote only on a receiver the compiler knows is an array or `Date`: an array literal, `Array.from(...)`, an array read that returns a new array, a `const` annotated `T[]` / `Array<T>` / `ReadonlyArray<T>` / `Date` or initialized from one of these, or a call to a same-file function with that return type annotation. A callback must be inline (its body is inspected) or a `@sinwan-pure` function; `items.map(track)` with an unannotated `track` stays eager. Reads on other values (`props.items.map(...)`, `props.query.filter(...)`) stay eager because the method may not be the built-in one; annotate a `const` (`const items: Item[] = props.items`) to opt in.
+- A pure method read on a promoted local such as `monthList.map(...)` or `today.getFullYear()` is rewritten to `monthList().map(...)` / `today().getFullYear()`. Mutating reads such as `list.push` and `date.setFullYear` stay snapshots. A promoted local that holds a function is still called: `const close = props.onClose; close()` becomes `close()()`. Module, event-handler, render-callback, loop and nested-block declarations are not promoted.
+- A reactive value passed to a parameter typed `LiveRead<T>` (`T | (() => T)`) is wrapped as `() => value`. An argument that is already a function is left alone. `createLiveState(..., props.selected)` therefore re-reads `props.selected` on each `state.value` access.
 - 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.
@@ -170,12 +175,12 @@ export function cn(...inputs: ClassValue[]): string {
 }
 ```
 
-Both `export function` and `export const` declarations are recognized. The annotation must be a block comment (`/** */`) immediately before the `export` keyword.
+Both `export function` and `export const` declarations are recognized. The annotation must be a block comment (`/** */`) immediately before the `export` keyword. A non-exported function in the same file is also recognized when the comment sits directly above `function` or `const`.
 
 **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.
+- 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 and reused while that file, and any file it re-exports from, keeps its modification time, so a dev server picks up a new or removed annotation without a restart. The same applies to the `LiveRead<T>` parameter scan.
 - 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",