@vureact/compiler-core 1.8.5 → 1.10.0

package/lib/{chunk-FWYPSB43.esm.js → chunk-ZTNVNBKF.esm.js}

@@ -1,5 +1,5 @@
 /**
- * @vureact/compiler-core v1.8.5
+ * @vureact/compiler-core v1.10.0
  * (c) 2025-present Ruihong Zhong (Ryan John)
  * @license MIT
  */
@@ -48,7 +48,9 @@ var MACRO_API_NAMES = {
   emits: "defineEmits",
   slots: "defineSlots",
   options: "defineOptions",
-  expose: "defineExpose"
+  expose: "defineExpose",
+  model: "defineModel",
+  defaults: "withDefaults"
 };
 var DOLLAR_IDENTIFIERS = [
   "$data",
@@ -402,6 +404,11 @@ var ADAPTER_RULES = {
     }
   }
 };
+var AUTO_IMPORTED_APIS = new Set(
+  Object.entries(ADAPTER_RULES).flatMap(
+    ([_, rules]) => Object.keys(rules).filter((key) => !key.startsWith("dir"))
+  )
+);
 
 // src/consts/vue-api-map.ts
 var VUE_API_MAP = {
@@ -950,21 +957,21 @@ var Logger = class {
   }
   printAll(opts) {
     if (this.logs.length === 0) {
-      console.log("No logs to display.");
+      !opts?._testMode && console.log("No logs to display.");
       return;
     }
     const orderedLogs = this.getOrderedLogs(opts);
     for (const log of orderedLogs) {
-      console.log();
+      !opts?._testMode && console.log();
       console.log(this.formatHeader(log));
       const context = this.formatContext(log);
       if (context) {
         console.log(context);
       }
-      console.log();
+      !opts?._testMode && console.log();
     }
     this.printSummary();
-    console.log();
+    !opts?._testMode && console.log();
   }
   clear() {
     this.logs = [];
@@ -1060,7 +1067,7 @@ function buildStandardProp(nodeIR) {
     babelExp: { ast: keyAST },
     value: {
       content,
-      isStringLiteral: isStringLiteral14,
+      isStringLiteral: isStringLiteral16,
       babelExp: { ast: valueAST }
     }
   } = nodeIR;
@@ -1069,7 +1076,7 @@ function buildStandardProp(nodeIR) {
   }
   let value;
   if (content !== "true") {
-    value = isStringLiteral14 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
+    value = isStringLiteral16 ? t9.stringLiteral(content) : buildJsxExpressionNode(valueAST);
   }
   return t9.jsxAttribute(keyAST, value);
 }
@@ -1266,6 +1273,7 @@ var REACT_API_MAP = {
   memo: "memo",
   useRef: "useRef",
   useMemo: "useMemo",
+  useEffect: "useEffect",
   ReactNode: "ReactNode",
   forwardRef: "forwardRef",
   useCallback: "useCallback",
@@ -1642,11 +1650,11 @@ function replaceIdName(id, newName) {
     id.loc.identifierName = newName;
   }
 }
-function stringValueToTSType(ctx, input, tsTypeAnnotation7) {
+function stringValueToTSType(ctx, input, tsTypeAnnotation8) {
   const { filename, scriptData } = ctx;
   const exp = stringToExpr(input, scriptData.lang, filename);
   const ts = expressionToTSType(exp);
-  return tsTypeAnnotation7 ? t15.tsTypeAnnotation(ts) : ts;
+  return tsTypeAnnotation8 ? t15.tsTypeAnnotation(ts) : ts;
 }
 function expressionToTSType(exp) {
   if (t15.isStringLiteral(exp)) return t15.tsStringKeyword();
@@ -1740,6 +1748,28 @@ function cleanNodeComments(node) {
   node.innerComments = null;
   node.trailingComments = null;
 }
+function mapRuntimeTypeToTSType(value) {
+  switch (value.name) {
+    case "String":
+      return t15.tsStringKeyword();
+    case "Number":
+      return t15.tsNumberKeyword();
+    case "Boolean":
+      return t15.tsBooleanKeyword();
+    case "Object":
+      return t15.tsTypeLiteral([]);
+    case "Array":
+      return t15.tsArrayType(t15.tsAnyKeyword());
+    case "Function":
+      return t15.tsFunctionType(null, [], t15.tsTypeAnnotation(t15.tsAnyKeyword()));
+    case "Symbol":
+      return t15.tsSymbolKeyword();
+    case "BigInt":
+      return t15.tsBigIntKeyword();
+    default:
+      return t15.tsAnyKeyword();
+  }
+}
 
 // src/core/parse/sfc/postprocess/resolve-script-metadata/resolve-declared-options.ts
 function resolveDeclaredOptions(path8, ctx) {
@@ -2218,6 +2248,7 @@ var REACTIVE_TYPE_MAP = {
   toRefs: "ref",
   customRef: "ref",
   shallowRef: "ref",
+  defineModel: "ref",
   reactive: "reactive",
   shallowReactive: "reactive",
   computed: "ref",
@@ -2257,7 +2288,7 @@ function resolveReactiveBindings(node, ctx) {
     source: callName,
     reactiveType: getReactiveType(callName)
   };
-  if (callName === MACRO_API_NAMES.props) {
+  if (callName === MACRO_API_NAMES.props || callName === MACRO_API_NAMES.defaults) {
     ctx.propField = varName;
   }
 }
@@ -3277,8 +3308,236 @@ function isVueImport(id, path8) {
   return VUE_PACKAGES.some((pkg) => moduleName.includes(pkg));
 }
 
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-with-defaults.ts
+import * as t28 from "@babel/types";
+
+// src/core/transform/sfc/script/shared/hook-creator.ts
 import * as t26 from "@babel/types";
+function createUseCallback(body, deps) {
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useCallback), [
+    body,
+    deps ?? t26.arrayExpression([])
+  ]);
+}
+function createUseMemo(body, deps) {
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useMemo), [
+    t26.arrowFunctionExpression([], body),
+    deps ?? t26.arrayExpression([])
+  ]);
+}
+function createUseImperativeHandle(refId, init) {
+  return t26.callExpression(t26.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
+}
+function createUseUpdated(body, deps) {
+  const adapter = ADAPTER_RULES.runtime.onUpdated;
+  return t26.callExpression(t26.identifier(adapter.target), [
+    t26.arrowFunctionExpression([], body),
+    deps ?? t26.identifier("undefined")
+  ]);
+}
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-with-defaults.ts
+import * as t27 from "@babel/types";
+var WITH_DEFAULTS_PLACEHOLDER = " from withDefaults ";
+function resolveWithDefaultsOptions(ctx, ast) {
+  if (ctx.inputType !== "sfc") return {};
+  return {
+    CallExpression(path8) {
+      const { node } = path8;
+      const { filename, scriptData } = ctx;
+      if (!isCalleeNamed(node, MACRO_API_NAMES.defaults)) {
+        return;
+      }
+      const declaratorPath = getVariableDeclaratorPath(path8);
+      if (!declaratorPath) {
+        logger.error(
+          `withDefaults() must be assigned to a variable (e.g., const props = withDefaults(...)).`,
+          { file: filename, source: scriptData.source, loc: node.loc }
+        );
+        return;
+      }
+      const varName = t27.isIdentifier(declaratorPath.node.id) ? declaratorPath.node.id.name : void 0;
+      if (!varName) {
+        logger.error("withDefaults() could not determine the variable name from the declaration.", {
+          file: filename,
+          source: scriptData.source,
+          loc: node.loc
+        });
+        return;
+      }
+      ctx.propField = `vr${capitalize(ctx.propField)}`;
+      const [defineProps, defaults] = node.arguments;
+      if (!node.arguments.length) {
+        logger.error("withDefaults() requires at least one argument (defineProps call).", {
+          file: filename,
+          source: scriptData.source,
+          loc: node.loc
+        });
+        return;
+      }
+      if (!t27.isCallExpression(defineProps)) {
+        logger.error(
+          "withDefaults() first argument must be a call to defineProps (e.g., defineProps({...})).",
+          { file: filename, source: scriptData.source, loc: defineProps?.loc }
+        );
+        return;
+      }
+      if (defaults && !t27.isObjectExpression(defaults)) {
+        logger.error(
+          'withDefaults() second argument must be an object literal (e.g., { msg: "hello" }).',
+          { file: filename, source: scriptData.source, loc: defaults?.loc }
+        );
+        return;
+      }
+      recordPropsWithDefaults(ctx, varName, defineProps, defaults, node);
+      declaratorPath.parentPath.insertAfter(createPlaceholder(node));
+      replaceNode(path8, defineProps, node);
+    }
+  };
+}
+function recordPropsWithDefaults(ctx, varName, defineProps, defaults, withDefaults) {
+  const { scriptData } = ctx;
+  const { start, end, loc, leadingComments, innerComments, trailingComments } = withDefaults;
+  const values = flattenDefaultValues(defaults);
+  const getTypeParameters = () => {
+    if (!scriptData.lang.startsWith("ts")) {
+      return;
+    }
+    const { propsTypes } = scriptData.propsTSIface;
+    const typeParameters = defineProps.typeParameters || (propsTypes.length ? t27.tSTypeParameterInstantiation(propsTypes) : void 0);
+    if (typeParameters) {
+      return t27.tsTypeParameterInstantiation([
+        t27.tsTypeReference(t27.identifier("Readonly"), typeParameters)
+      ]);
+    }
+  };
+  scriptData.propsWithDefaults = {
+    varName,
+    values,
+    start,
+    end,
+    loc,
+    leadingComments,
+    innerComments,
+    trailingComments,
+    typeParameters: getTypeParameters()
+  };
+}
+function flattenDefaultValues(expr) {
+  if (!expr) return;
+  if (!t27.isObjectExpression(expr)) {
+    return expr;
+  }
+  const properties = expr.properties.map((prop) => {
+    if (!t27.isObjectProperty(prop)) {
+      return prop;
+    }
+    const value = prop.value;
+    if (t27.isArrowFunctionExpression(value) && t27.isBlockStatement(value.body)) {
+      const returnStmt = value.body.body.find(
+        (stmt) => t27.isReturnStatement(stmt)
+      );
+      if (returnStmt?.argument) {
+        return t27.objectProperty(prop.key, returnStmt.argument, prop.computed);
+      }
+    }
+    if (t27.isArrowFunctionExpression(value) && !t27.isBlockStatement(value.body)) {
+      return t27.objectProperty(prop.key, value.body, prop.computed);
+    }
+    return prop;
+  });
+  return t27.objectExpression(properties);
+}
+function createPlaceholder(node) {
+  const placeholder = t27.emptyStatement();
+  const leadingComments = [
+    {
+      type: "CommentBlock",
+      value: WITH_DEFAULTS_PLACEHOLDER,
+      start: node.start,
+      end: node.end
+    }
+  ];
+  placeholder.leadingComments = leadingComments;
+  return placeholder;
+}
+
+// src/core/transform/sfc/script/syntax-processor/postprocess/resolve-with-defaults.ts
+function resolveWithDefaults(ctx) {
+  const { inputType, scriptData } = ctx;
+  const propsWithDefaults = scriptData.propsWithDefaults;
+  if (inputType !== "sfc" || !propsWithDefaults?.values) return {};
+  return {
+    Program: {
+      exit(programPath) {
+        const { body } = programPath.node;
+        const placeholderIndex = findPlaceholderIndex(body);
+        if (placeholderIndex === -1) return;
+        const placeholder = body[placeholderIndex];
+        const { varName, values, typeParameters } = propsWithDefaults;
+        const varDeclaration = createVarDeclaration(
+          varName,
+          values,
+          typeParameters,
+          ctx.propField,
+          propsWithDefaults
+        );
+        varDeclaration.leadingComments = placeholder.leadingComments;
+        body.splice(placeholderIndex, 0, varDeclaration);
+        recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useMemo);
+      }
+    }
+  };
+}
+function findPlaceholderIndex(body) {
+  return body.findIndex((stmt) => {
+    if (!t28.isEmptyStatement(stmt) || !stmt.leadingComments) {
+      return false;
+    }
+    return stmt.leadingComments.some(
+      (comment) => comment.type === "CommentBlock" && comment.value === WITH_DEFAULTS_PLACEHOLDER
+    );
+  });
+}
+function createVarDeclaration(varName, values, typeParameters, propField, sourceInfo) {
+  const { mergeMembers } = buildMergeLogic(values, propField);
+  const deps = t28.arrayExpression([t28.identifier(propField)]);
+  const useMemoCall = createUseMemo(t28.objectExpression(mergeMembers), deps);
+  if (typeParameters) {
+    useMemoCall.typeParameters = typeParameters;
+  }
+  useMemoCall.start = sourceInfo.start;
+  useMemoCall.end = sourceInfo.end;
+  useMemoCall.loc = sourceInfo.loc;
+  useMemoCall.leadingComments = sourceInfo.leadingComments;
+  useMemoCall.innerComments = sourceInfo.innerComments;
+  useMemoCall.trailingComments = sourceInfo.trailingComments;
+  const varDeclarator = t28.variableDeclarator(t28.identifier(varName), useMemoCall);
+  return t28.variableDeclaration("const", [varDeclarator]);
+}
+function buildMergeLogic(values, propField) {
+  const mergeMembers = [];
+  const propFieldIdent = t28.identifier(propField);
+  mergeMembers.push(t28.spreadElement(propFieldIdent));
+  for (const defaultProp of values.properties) {
+    if (!t28.isObjectProperty(defaultProp)) continue;
+    const key = defaultProp.key;
+    if (!t28.isIdentifier(key) && !t28.isStringLiteral(key)) continue;
+    const keyName = t28.isIdentifier(key) ? key.name : key.value;
+    const propAccess = t28.memberExpression(propFieldIdent, t28.identifier(keyName), false);
+    const logicalExpr = t28.logicalExpression("??", propAccess, defaultProp.value);
+    mergeMembers.push(
+      t28.objectProperty(
+        t28.isIdentifier(key) ? t28.identifier(keyName) : t28.stringLiteral(keyName),
+        logicalExpr
+      )
+    );
+  }
+  return { mergeMembers };
+}
+
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-async-component.ts
+import * as t29 from "@babel/types";
 function resolveDefineAsyncComponent(ctx) {
   return {
     CallExpression(path8) {
@@ -3287,11 +3546,11 @@ function resolveDefineAsyncComponent(ctx) {
         return;
       }
       const [arg] = node.arguments;
-      if (!t26.isObjectExpression(arg)) {
+      if (!t29.isObjectExpression(arg)) {
         return;
       }
       for (const prop of arg.properties) {
-        if (!t26.isObjectProperty(prop) || !t26.isIdentifier(prop.key) || prop.key.name !== "hydrate") {
+        if (!t29.isObjectProperty(prop) || !t29.isIdentifier(prop.key) || prop.key.name !== "hydrate") {
           continue;
         }
         logger.warn('Unsupported option "hydrate"', {
@@ -3306,27 +3565,7 @@ function resolveDefineAsyncComponent(ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
-import * as t28 from "@babel/types";
-
-// src/core/transform/sfc/script/shared/hook-creator.ts
-import * as t27 from "@babel/types";
-function createUseCallback(body, deps) {
-  return t27.callExpression(t27.identifier(REACT_API_MAP.useCallback), [
-    body,
-    deps ?? t27.arrayExpression([])
-  ]);
-}
-function createUseMemo(body, deps) {
-  return t27.callExpression(t27.identifier(REACT_API_MAP.useMemo), [
-    t27.arrowFunctionExpression([], body),
-    deps ?? t27.arrayExpression([])
-  ]);
-}
-function createUseImperativeHandle(refId, init) {
-  return t27.callExpression(t27.identifier(REACT_API_MAP.useImperativeHandle), [refId, init]);
-}
-
-// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-expose.ts
+import * as t30 from "@babel/types";
 function resolveDefineExpose(ctx) {
   if (ctx.inputType !== "sfc") return {};
   return {
@@ -3344,22 +3583,242 @@ function resolveDefineExpose(ctx) {
       const adapter = ADAPTER_RULES.react[MACRO_API_NAMES.expose];
       recordImport(ctx, adapter.package, REACT_API_MAP.forwardRef);
       recordImport(ctx, adapter.package, adapter.target);
-      if (!t28.isObjectExpression(expose) && !t28.isFunction(expose)) {
+      if (!t30.isObjectExpression(expose) && !t30.isFunction(expose)) {
         logger.warn("Non-deterministic object literal may cause unknown risks.", {
           file: filename,
           loc: expose.loc,
           source: scriptData.source
         });
       }
-      const init = !t28.isFunction(expose) ? t28.arrowFunctionExpression([], expose) : expose;
+      const init = !t30.isFunction(expose) ? t30.arrowFunctionExpression([], expose) : expose;
       const { forwardRef } = scriptData;
-      const newNode = createUseImperativeHandle(t28.identifier(forwardRef.refField), init);
+      const newNode = createUseImperativeHandle(t30.identifier(forwardRef.refField), init);
       forwardRef.enabled = true;
       replaceNode(path8, newNode, node);
     }
   };
 }
 
+// src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-model.ts
+import * as t31 from "@babel/types";
+function resolveDefineModel(ctx, ast) {
+  if (ctx.inputType !== "sfc") return {};
+  return {
+    CallExpression(path8) {
+      const { node } = path8;
+      if (!isCalleeNamed(node, MACRO_API_NAMES.model)) {
+        return;
+      }
+      if (!validateDefineModelUsage(path8, ctx)) {
+        return;
+      }
+      const propInfo = extractPropInfo(node, ctx);
+      replaceToUseVRef(node, propInfo, ctx);
+      resolveAutoUpdate(ast, path8, propInfo, ctx);
+      resolveInterface(propInfo, ctx);
+    }
+  };
+}
+function validateDefineModelUsage(path8, ctx) {
+  const { node, parent } = path8;
+  const { filename, scriptData } = ctx;
+  const [arg1, arg2] = node.arguments;
+  if (!t31.isObjectExpression(arg1) && !t31.isStringLiteral(arg1)) {
+    logger.error(`Invalid argument type for defineModel. Expected a string.`, {
+      file: filename,
+      source: scriptData.source,
+      loc: arg1?.loc
+    });
+    return false;
+  }
+  const hasUnsupportedOption = (arg) => {
+    if (!t31.isObjectExpression(arg)) {
+      return false;
+    }
+    const result = arg.properties.some((prop) => {
+      if ((t31.isObjectProperty(prop) || t31.isObjectMethod(prop)) && t31.isIdentifier(prop.key)) {
+        const keyName = prop.key.name;
+        if (keyName === "get" || keyName === "set" || keyName === "validator") {
+          logger.error(`defineModel does not support '${keyName}' option.`, {
+            file: filename,
+            source: scriptData.source,
+            loc: prop.key.loc
+          });
+          return true;
+        }
+      }
+    });
+    return !!result;
+  };
+  const isValidVariableAssignment = () => {
+    const varDeclaration = path8.parentPath.parentPath;
+    if (varDeclaration?.isVariableDeclaration() && varDeclaration.node.declarations.length === 1 && t31.isArrayPattern(varDeclaration.node.declarations[0]?.id)) {
+      logger.error(
+        `defineModel return value cannot be destructured with array pattern. Please use single variable assignment.`,
+        {
+          file: filename,
+          source: scriptData.source,
+          loc: varDeclaration.node.loc
+        }
+      );
+      return false;
+    }
+    return true;
+  };
+  return !hasUnsupportedOption(arg1) && !hasUnsupportedOption(arg2) && isValidVariableAssignment();
+}
+function extractPropInfo(node, ctx) {
+  const [arg1, arg2] = node.arguments;
+  const propInfo = {
+    name: "modelValue",
+    updateEventName: "onUpdateModelValue",
+    type: void 0,
+    required: false,
+    default: void 0
+  };
+  const findObjectProperty = (objExpr, propName) => {
+    return objExpr.properties.find(
+      (prop) => t31.isObjectProperty(prop) && t31.isIdentifier(prop.key) && prop.key.name === propName
+    );
+  };
+  const setPropName = (info, value) => {
+    if (!value.trim()) return;
+    info.name = value;
+    info.updateEventName = `onUpdate${capitalize(camelCase(value))}`;
+  };
+  const extractPropInfoFromObject = (objExpr) => {
+    const result = {};
+    const nameProp = findObjectProperty(objExpr, "name");
+    const typeProp = findObjectProperty(objExpr, "type");
+    const defaultProp = findObjectProperty(objExpr, "default");
+    const requiredProp = findObjectProperty(objExpr, "required");
+    if (nameProp && t31.isStringLiteral(nameProp.value)) {
+      setPropName(result, nameProp.value.value);
+    }
+    if (defaultProp) {
+      result.default = defaultProp.value;
+    }
+    if (requiredProp && t31.isBooleanLiteral(requiredProp.value)) {
+      result.required = requiredProp.value.value;
+    }
+    if (typeProp && t31.isIdentifier(typeProp.value)) {
+      result.type = mapRuntimeTypeToTSType(typeProp.value);
+    } else if (node.typeParameters) {
+      const [typeParam] = node.typeParameters.params;
+      if (t31.isTSType(typeParam)) {
+        result.type = typeParam;
+      }
+    } else if (defaultProp) {
+      result.type = expressionToTSType(defaultProp.value);
+    }
+    return result;
+  };
+  const safeAssign = (target, source) => {
+    if (source.name !== void 0) {
+      target.name = source.name;
+    }
+    if (source.updateEventName !== void 0) {
+      target.updateEventName = source.updateEventName;
+    }
+    if (source.type !== void 0) {
+      target.type = source.type;
+    }
+    if (source.required !== void 0) {
+      target.required = source.required;
+    }
+    if (source.default !== void 0) {
+      target.default = source.default;
+    }
+  };
+  const extractTypeFromTypeParams = (info) => {
+    if (!node.typeParameters) return;
+    const isDefaultAny = !info.type || t31.isTSAnyKeyword(info.type);
+    if (!isDefaultAny) return;
+    const [typeParam] = node.typeParameters.params;
+    if (t31.isTSType(typeParam)) {
+      info.type = typeParam;
+    }
+  };
+  if (t31.isStringLiteral(arg1)) {
+    setPropName(propInfo, arg1.value);
+    extractTypeFromTypeParams(propInfo);
+  } else if (t31.isObjectExpression(arg1)) {
+    safeAssign(propInfo, extractPropInfoFromObject(arg1));
+  }
+  if (!t31.isObjectExpression(arg1) && t31.isObjectExpression(arg2)) {
+    safeAssign(propInfo, extractPropInfoFromObject(arg2));
+  }
+  return propInfo;
+}
+function replaceToUseVRef(node, propInfo, ctx) {
+  const refAdapter = ADAPTER_RULES.runtime.ref;
+  replaceCallName(node, refAdapter.target);
+  recordImport(ctx, refAdapter.package, refAdapter.target);
+  const defaultValue = propInfo.default;
+  const propRef = t31.identifier(`${ctx.propField}.${propInfo.name}`);
+  if (!defaultValue) {
+    node.arguments = [propRef];
+  } else {
+    node.arguments = [t31.logicalExpression("??", propRef, defaultValue)];
+  }
+  if (ctx.scriptData.lang.startsWith("ts") && !node.typeParameters && propInfo.type) {
+    node.typeParameters = t31.tsTypeParameterInstantiation([propInfo.type]);
+  }
+}
+function resolveAutoUpdate(ast, path8, propInfo, ctx) {
+  const { parent } = path8;
+  if (!t31.isVariableDeclarator(parent)) {
+    return;
+  }
+  const modelId = parent.id;
+  if (!t31.isIdentifier(modelId)) {
+    return;
+  }
+  const memberAccess = t31.memberExpression(
+    t31.identifier(ctx.propField),
+    t31.identifier(propInfo.updateEventName)
+  );
+  const dep = t31.memberExpression(modelId, t31.identifier("value"));
+  const updateCall = t31.optionalCallExpression(memberAccess, [dep], true);
+  const callExpr = createUseUpdated(
+    t31.blockStatement([t31.expressionStatement(updateCall)]),
+    t31.arrayExpression([dep])
+  );
+  ast.program.body.push(t31.expressionStatement(callExpr));
+  const adapter = ADAPTER_RULES.runtime.onUpdated;
+  recordImport(ctx, adapter.package, adapter.target);
+}
+function resolveInterface(propInfo, ctx) {
+  const { name, updateEventName, required } = propInfo;
+  const { lang, propsTSIface } = ctx.scriptData;
+  if (!lang.startsWith("ts")) {
+    return;
+  }
+  const propType = propInfo.type || t31.tsAnyKeyword();
+  const propSignature = t31.tsPropertySignature(
+    t31.isValidIdentifier(name) ? t31.identifier(name) : t31.stringLiteral(name),
+    t31.tsTypeAnnotation(propType)
+  );
+  propSignature.optional = !required;
+  const emitArg = t31.identifier("arg");
+  emitArg.typeAnnotation = t31.tsTypeAnnotation(propType);
+  const emitSignature = t31.tsPropertySignature(
+    t31.isValidIdentifier(updateEventName) ? t31.identifier(updateEventName) : t31.stringLiteral(updateEventName),
+    t31.tsTypeAnnotation(t31.tsFunctionType(null, [emitArg], t31.tsTypeAnnotation(t31.tsVoidKeyword())))
+  );
+  emitSignature.optional = true;
+  const appendToTypeLiteral = (list, member) => {
+    const existing = list.find((item) => t31.isTSTypeLiteral(item));
+    if (existing) {
+      existing.members.push(member);
+    } else {
+      list.push(t31.tsTypeLiteral([member]));
+    }
+  };
+  appendToTypeLiteral(propsTSIface.propsTypes, propSignature);
+  appendToTypeLiteral(propsTSIface.emitTypes, emitSignature);
+}
+
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-define-options.ts
 function resolveDefineOptions(ctx) {
   return {
@@ -3374,7 +3833,7 @@ function resolveDefineOptions(ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-emit-calls.ts
-import * as t29 from "@babel/types";
+import * as t32 from "@babel/types";
 function resolveEmitCalls(ctx) {
   const formatEmitEventName = (raw) => {
     if (raw.startsWith("update:")) {
@@ -3388,7 +3847,7 @@ function resolveEmitCalls(ctx) {
     CallExpression(path8) {
       const { node } = path8;
       const { filename, templateData, scriptData } = ctx;
-      if (!t29.isIdentifier(node.callee)) return;
+      if (!t32.isIdentifier(node.callee)) return;
       const { name } = node.callee;
       const checkIfFromDefineEmits = () => {
         let result = false;
@@ -3400,7 +3859,7 @@ function resolveEmitCalls(ctx) {
           const binding = path8.scope.getBinding(name);
           if (binding) {
             const parent = binding.path.node;
-            if (t29.isVariableDeclarator(parent) && t29.isCallExpression(parent.init) && t29.isIdentifier(parent.init.callee)) {
+            if (t32.isVariableDeclarator(parent) && t32.isCallExpression(parent.init) && t32.isIdentifier(parent.init.callee)) {
               result = parent.init.callee.name === MACRO_API_NAMES.emits;
             }
           }
@@ -3410,9 +3869,9 @@ function resolveEmitCalls(ctx) {
       if (!checkIfFromDefineEmits()) return;
       const [callee, ...args] = node.arguments;
       let propCall;
-      if (t29.isStringLiteral(callee)) {
+      if (t32.isStringLiteral(callee)) {
         const eventName = formatEmitEventName(callee.value);
-        propCall = createPropCall(ctx.propField, t29.identifier(eventName), args);
+        propCall = createPropCall(ctx.propField, t32.identifier(eventName), args);
       } else {
         propCall = createPropCall(ctx.propField, callee, args, true);
         logger.error(
@@ -3429,38 +3888,38 @@ function resolveEmitCalls(ctx) {
   };
 }
 function createPropCall(rootName, callee, args, computed = false) {
-  return t29.optionalCallExpression(
-    t29.memberExpression(t29.identifier(rootName), callee, computed),
+  return t32.optionalCallExpression(
+    t32.memberExpression(t32.identifier(rootName), callee, computed),
     args,
     true
   );
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/index.ts
-import * as t37 from "@babel/types";
+import * as t40 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-emits.ts
-import * as t31 from "@babel/types";
+import * as t34 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/shared.ts
-import * as t30 from "@babel/types";
+import * as t33 from "@babel/types";
 function cloneCallableParams(params) {
   const cloneCallableParam = (param, index) => {
-    if (t30.isRestElement(param)) {
+    if (t33.isRestElement(param)) {
       const arg = param.argument;
-      const name = t30.isIdentifier(arg) ? arg.name : `args${index}`;
-      const rest = t30.restElement(t30.identifier(name));
-      rest.typeAnnotation = param.typeAnnotation || (t30.isIdentifier(arg) ? arg.typeAnnotation : null) || t30.tsTypeAnnotation(t30.tsArrayType(t30.tsAnyKeyword()));
+      const name = t33.isIdentifier(arg) ? arg.name : `args${index}`;
+      const rest = t33.restElement(t33.identifier(name));
+      rest.typeAnnotation = param.typeAnnotation || (t33.isIdentifier(arg) ? arg.typeAnnotation : null) || t33.tsTypeAnnotation(t33.tsArrayType(t33.tsAnyKeyword()));
       return rest;
     }
-    if (t30.isIdentifier(param)) {
-      const id = t30.identifier(param.name || `arg${index}`);
+    if (t33.isIdentifier(param)) {
+      const id = t33.identifier(param.name || `arg${index}`);
       id.optional = param.optional;
-      id.typeAnnotation = param.typeAnnotation || t30.tsTypeAnnotation(t30.tsAnyKeyword());
+      id.typeAnnotation = param.typeAnnotation || t33.tsTypeAnnotation(t33.tsAnyKeyword());
       return id;
     }
-    const fallback = t30.identifier(`arg${index}`);
-    fallback.typeAnnotation = t30.tsTypeAnnotation(t30.tsAnyKeyword());
+    const fallback = t33.identifier(`arg${index}`);
+    fallback.typeAnnotation = t33.tsTypeAnnotation(t33.tsAnyKeyword());
     return fallback;
   };
   return params.map(cloneCallableParam);
@@ -3470,18 +3929,18 @@ function cloneCallableParams(params) {
 function resolveEmitsTopLevelTypes(ctx) {
   return {
     "TSInterfaceDeclaration|TSTypeAliasDeclaration"(path8) {
-      if (!t31.isProgram(path8.parent)) return;
+      if (!t34.isProgram(path8.parent)) return;
       const { node } = path8;
-      if (t31.isTSInterfaceDeclaration(node)) {
-        const typeLiteral = t31.tsTypeLiteral(node.body.body);
+      if (t34.isTSInterfaceDeclaration(node)) {
+        const typeLiteral = t34.tsTypeLiteral(node.body.body);
         if (!hasEmitsSignatureInType(typeLiteral)) return;
         const resolved = resolveTopLevelEmitType(typeLiteral);
-        if (resolved && t31.isTSTypeLiteral(resolved)) {
+        if (resolved && t34.isTSTypeLiteral(resolved)) {
           node.body.body = resolved.members;
         }
         return;
       }
-      if (t31.isTSTypeAliasDeclaration(node)) {
+      if (t34.isTSTypeAliasDeclaration(node)) {
         if (!hasEmitsSignatureInType(node.typeAnnotation)) return;
         const resolved = resolveTopLevelEmitType(node.typeAnnotation);
         if (resolved) {
@@ -3492,47 +3951,47 @@ function resolveEmitsTopLevelTypes(ctx) {
   };
 }
 function resolveTopLevelEmitType(tsType) {
-  if (t31.isTSParenthesizedType(tsType)) {
+  if (t34.isTSParenthesizedType(tsType)) {
     return resolveTopLevelEmitType(tsType.typeAnnotation);
   }
-  if (t31.isTSTypeReference(tsType)) {
+  if (t34.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveTopLevelEmitType(param)).filter(Boolean);
-    return t31.tsTypeReference(
+    return t34.tsTypeReference(
       tsType.typeName,
-      t31.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t34.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t31.isTSIntersectionType(tsType)) {
+  if (t34.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t31.tsIntersectionType(types);
+    return t34.tsIntersectionType(types);
   }
-  if (t31.isTSUnionType(tsType)) {
+  if (t34.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveTopLevelEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t31.tsUnionType(types);
+    return t34.tsUnionType(types);
   }
-  if (t31.isTSTypeLiteral(tsType)) {
+  if (t34.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t31.isTSCallSignatureDeclaration(member)) {
+      if (t34.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
       members.push(member);
     }
     if (!members.length) return null;
-    return t31.tsTypeLiteral(members);
+    return t34.tsTypeLiteral(members);
   }
-  if (t31.isTSFunctionType(tsType)) {
+  if (t34.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t31.tsTypeLiteral(props);
+    return t34.tsTypeLiteral(props);
   }
   return tsType;
 }
@@ -3553,41 +4012,41 @@ function processInferredTypes(ctx, runtimeArg) {
     propsTSIface: { emitTypes }
   } = ctx.scriptData;
   const members = [];
-  if (t31.isArrayExpression(runtimeArg)) {
+  if (t34.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t31.isStringLiteral(element)) continue;
+      if (!element || !t34.isStringLiteral(element)) continue;
       const handlerName = resolveEmitHandlerName(element.value);
       const key = buildKey(handlerName);
-      const fnType = t31.tsFunctionType(
+      const fnType = t34.tsFunctionType(
         null,
         [createRestAnyParam("args")],
-        t31.tsTypeAnnotation(t31.tsAnyKeyword())
+        t34.tsTypeAnnotation(t34.tsAnyKeyword())
       );
-      const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
+      const prop = t34.tsPropertySignature(key, t34.tsTypeAnnotation(fnType));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      emitTypes.push(t31.tsTypeLiteral(members));
+      emitTypes.push(t34.tsTypeLiteral(members));
     }
     return;
   }
-  if (t31.isObjectExpression(runtimeArg)) {
+  if (t34.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t31.isObjectProperty(prop)) continue;
-      if (t31.isSpreadElement(prop)) continue;
+      if (!t34.isObjectProperty(prop)) continue;
+      if (t34.isSpreadElement(prop)) continue;
       const rawName = resolvePropName(prop.key);
       if (!rawName) continue;
       const handlerName = resolveEmitHandlerName(rawName);
       const key = buildKey(handlerName);
-      const params = t31.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
-      const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(t31.tsAnyKeyword()));
-      const propSig = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
+      const params = t34.isArrayExpression(prop.value) ? resolveRuntimeTupleParams(prop.value) : [createRestAnyParam("args")];
+      const fnType = t34.tsFunctionType(null, params, t34.tsTypeAnnotation(t34.tsAnyKeyword()));
+      const propSig = t34.tsPropertySignature(key, t34.tsTypeAnnotation(fnType));
       propSig.optional = true;
       members.push(propSig);
     }
     if (members.length) {
-      emitTypes.push(t31.tsTypeLiteral(members));
+      emitTypes.push(t34.tsTypeLiteral(members));
     }
   }
 }
@@ -3608,129 +4067,129 @@ function resolveEmitHandlerName(rawName) {
   return `on${name}`;
 }
 function resolvePropName(key) {
-  if (t31.isIdentifier(key)) return key.name;
-  if (t31.isStringLiteral(key)) return key.value;
-  if (t31.isNumericLiteral(key)) return String(key.value);
+  if (t34.isIdentifier(key)) return key.name;
+  if (t34.isStringLiteral(key)) return key.value;
+  if (t34.isNumericLiteral(key)) return String(key.value);
   return null;
 }
 function buildKey(name) {
-  return t31.isValidIdentifier(name) ? t31.identifier(name) : t31.stringLiteral(name);
+  return t34.isValidIdentifier(name) ? t34.identifier(name) : t34.stringLiteral(name);
 }
 function createRestAnyParam(name) {
-  const id = t31.identifier(name);
-  const rest = t31.restElement(id);
-  rest.typeAnnotation = t31.tsTypeAnnotation(t31.tsArrayType(t31.tsAnyKeyword()));
+  const id = t34.identifier(name);
+  const rest = t34.restElement(id);
+  rest.typeAnnotation = t34.tsTypeAnnotation(t34.tsArrayType(t34.tsAnyKeyword()));
   return rest;
 }
 function resolveRuntimeTupleParams(value) {
   const params = [];
   value.elements.forEach((element, index) => {
     if (!element) return;
-    if (t31.isSpreadElement(element)) {
+    if (t34.isSpreadElement(element)) {
       params.push(createRestAnyParam(`args${index}`));
       return;
     }
-    if (t31.isIdentifier(element)) {
-      const id = t31.identifier(element.name);
-      id.typeAnnotation = element.typeAnnotation || t31.tsTypeAnnotation(t31.tsAnyKeyword());
+    if (t34.isIdentifier(element)) {
+      const id = t34.identifier(element.name);
+      id.typeAnnotation = element.typeAnnotation || t34.tsTypeAnnotation(t34.tsAnyKeyword());
       params.push(id);
       return;
     }
-    if (t31.isTSAsExpression(element)) {
-      const id = t31.identifier(`arg${index}`);
-      id.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
+    if (t34.isTSAsExpression(element)) {
+      const id = t34.identifier(`arg${index}`);
+      id.typeAnnotation = t34.tsTypeAnnotation(element.typeAnnotation);
       params.push(id);
       return;
     }
-    const fallback = t31.identifier(`arg${index}`);
-    fallback.typeAnnotation = t31.tsTypeAnnotation(t31.tsAnyKeyword());
+    const fallback = t34.identifier(`arg${index}`);
+    fallback.typeAnnotation = t34.tsTypeAnnotation(t34.tsAnyKeyword());
     params.push(fallback);
   });
   return params;
 }
 function resolveExplicitEmitType(tsType) {
-  if (t31.isTSParenthesizedType(tsType)) {
+  if (t34.isTSParenthesizedType(tsType)) {
     return resolveExplicitEmitType(tsType.typeAnnotation);
   }
-  if (t31.isTSTypeReference(tsType)) {
+  if (t34.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return tsType;
     }
     const params = tsType.typeParameters.params.map((param) => resolveExplicitEmitType(param)).filter(Boolean);
-    return t31.tsTypeReference(
+    return t34.tsTypeReference(
       tsType.typeName,
-      t31.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
+      t34.tsTypeParameterInstantiation(params.length ? params : tsType.typeParameters.params)
     );
   }
-  if (t31.isTSIntersectionType(tsType)) {
+  if (t34.isTSIntersectionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t31.tsIntersectionType(types);
+    return t34.tsIntersectionType(types);
   }
-  if (t31.isTSUnionType(tsType)) {
+  if (t34.isTSUnionType(tsType)) {
     const types = tsType.types.map(resolveExplicitEmitType).filter(Boolean);
     if (!types.length) return null;
     if (types.length === 1) return types[0];
-    return t31.tsUnionType(types);
+    return t34.tsUnionType(types);
   }
-  if (t31.isTSTypeLiteral(tsType)) {
+  if (t34.isTSTypeLiteral(tsType)) {
     const members = [];
     for (const member of tsType.members) {
-      if (t31.isTSPropertySignature(member)) {
+      if (t34.isTSPropertySignature(member)) {
         const prop = resolveEmitPropFromPropertySignature(member);
         if (prop) members.push(prop);
         continue;
       }
-      if (t31.isTSCallSignatureDeclaration(member)) {
+      if (t34.isTSCallSignatureDeclaration(member)) {
         members.push(...resolveEmitPropsFromCallSignature(member));
         continue;
       }
     }
     if (!members.length) return null;
-    return t31.tsTypeLiteral(members);
+    return t34.tsTypeLiteral(members);
   }
-  if (t31.isTSFunctionType(tsType)) {
+  if (t34.isTSFunctionType(tsType)) {
     const props = resolveEmitPropsFromCallable(tsType.parameters, tsType.typeAnnotation);
     if (!props.length) return null;
-    return t31.tsTypeLiteral(props);
+    return t34.tsTypeLiteral(props);
   }
   return tsType;
 }
 function hasEmitsSignatureInType(tsType) {
-  if (t31.isTSParenthesizedType(tsType)) {
+  if (t34.isTSParenthesizedType(tsType)) {
     return hasEmitsSignatureInType(tsType.typeAnnotation);
   }
-  if (t31.isTSTypeReference(tsType)) {
+  if (t34.isTSTypeReference(tsType)) {
     if (!tsType.typeParameters || !tsType.typeParameters.params.length) {
       return false;
     }
     return tsType.typeParameters.params.some(hasEmitsSignatureInType);
   }
-  if (t31.isTSIntersectionType(tsType) || t31.isTSUnionType(tsType)) {
+  if (t34.isTSIntersectionType(tsType) || t34.isTSUnionType(tsType)) {
     return tsType.types.some(hasEmitsSignatureInType);
   }
-  if (t31.isTSTypeLiteral(tsType)) {
+  if (t34.isTSTypeLiteral(tsType)) {
     return tsType.members.some(hasEmitsSignatureInMember);
   }
-  if (t31.isTSFunctionType(tsType)) {
+  if (t34.isTSFunctionType(tsType)) {
     return isEmitsCallable(tsType.parameters);
   }
   return false;
 }
 function hasEmitsSignatureInMember(member) {
-  if (t31.isTSCallSignatureDeclaration(member)) {
+  if (t34.isTSCallSignatureDeclaration(member)) {
     return isEmitsCallable(member.parameters);
   }
   return false;
 }
 function isEmitsCallable(parameters) {
   const [eventParam] = parameters;
-  if (!eventParam || !t31.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t34.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return false;
   }
   const { typeAnnotation } = eventParam;
-  if (t31.isNoop(typeAnnotation)) return false;
+  if (t34.isNoop(typeAnnotation)) return false;
   return resolveEventNames(typeAnnotation.typeAnnotation).length > 0;
 }
 function resolveEmitPropFromPropertySignature(member) {
@@ -3740,19 +4199,19 @@ function resolveEmitPropFromPropertySignature(member) {
   const key = buildKey(handlerName);
   const typeAnnotation = member.typeAnnotation?.typeAnnotation;
   let params = [];
-  let returnType = t31.tsAnyKeyword();
-  if (typeAnnotation && t31.isTSFunctionType(typeAnnotation)) {
+  let returnType = t34.tsAnyKeyword();
+  if (typeAnnotation && t34.isTSFunctionType(typeAnnotation)) {
     params = cloneCallableParams(typeAnnotation.parameters);
     returnType = typeAnnotation.typeAnnotation?.typeAnnotation ?? returnType;
-  } else if (typeAnnotation && t31.isTSTupleType(typeAnnotation)) {
+  } else if (typeAnnotation && t34.isTSTupleType(typeAnnotation)) {
     params = resolveTupleTypeParams(typeAnnotation);
   } else if (typeAnnotation) {
-    const id = t31.identifier("value");
-    id.typeAnnotation = t31.tsTypeAnnotation(typeAnnotation);
+    const id = t34.identifier("value");
+    id.typeAnnotation = t34.tsTypeAnnotation(typeAnnotation);
     params = [id];
   }
-  const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(returnType));
-  const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
+  const fnType = t34.tsFunctionType(null, params, t34.tsTypeAnnotation(returnType));
+  const prop = t34.tsPropertySignature(key, t34.tsTypeAnnotation(fnType));
   prop.optional = !!member.optional;
   return prop;
 }
@@ -3761,32 +4220,32 @@ function resolveEmitPropsFromCallSignature(member) {
 }
 function resolveEmitPropsFromCallable(parameters, typeAnnotation) {
   const [eventParam, ...restParams] = parameters;
-  if (!eventParam || !t31.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
+  if (!eventParam || !t34.isIdentifier(eventParam) || !eventParam.typeAnnotation) {
     return [];
   }
   const { typeAnnotation: paramTypeAnnotation } = eventParam;
-  if (t31.isNoop(paramTypeAnnotation)) return [];
+  if (t34.isNoop(paramTypeAnnotation)) return [];
   const eventNames = resolveEventNames(paramTypeAnnotation.typeAnnotation);
   if (!eventNames.length) return [];
-  const returnType = typeAnnotation?.typeAnnotation ?? t31.tsAnyKeyword();
+  const returnType = typeAnnotation?.typeAnnotation ?? t34.tsAnyKeyword();
   return eventNames.map((eventName) => {
     const handlerName = resolveEmitHandlerName(eventName);
     const key = buildKey(handlerName);
     const params = cloneCallableParams(restParams);
-    const fnType = t31.tsFunctionType(null, params, t31.tsTypeAnnotation(returnType));
-    const prop = t31.tsPropertySignature(key, t31.tsTypeAnnotation(fnType));
+    const fnType = t34.tsFunctionType(null, params, t34.tsTypeAnnotation(returnType));
+    const prop = t34.tsPropertySignature(key, t34.tsTypeAnnotation(fnType));
     prop.optional = true;
     return prop;
   });
 }
 function resolveEventNames(type) {
-  if (t31.isTSLiteralType(type) && t31.isStringLiteral(type.literal)) {
+  if (t34.isTSLiteralType(type) && t34.isStringLiteral(type.literal)) {
     return [type.literal.value];
   }
-  if (t31.isTSUnionType(type)) {
+  if (t34.isTSUnionType(type)) {
     return type.types.flatMap(resolveEventNames);
   }
-  if (t31.isTSParenthesizedType(type)) {
+  if (t34.isTSParenthesizedType(type)) {
     return resolveEventNames(type.typeAnnotation);
   }
   return [];
@@ -3799,44 +4258,44 @@ function resolveTupleTypeParams(tuple) {
   return params;
 }
 function resolveTupleElementParam(element, index) {
-  const isNamedTuple = typeof t31.isTSNamedTupleMember === "function" && t31.isTSNamedTupleMember(element);
+  const isNamedTuple = typeof t34.isTSNamedTupleMember === "function" && t34.isTSNamedTupleMember(element);
   if (isNamedTuple) {
     const tupleMember = element;
     const name = tupleMember.label?.name || `arg${index}`;
     let innerType = tupleMember.elementType;
     let optional = tupleMember.optional;
-    if (t31.isTSOptionalType(innerType)) {
+    if (t34.isTSOptionalType(innerType)) {
       optional = true;
       innerType = innerType.typeAnnotation;
     }
-    if (t31.isTSRestType(innerType)) {
-      const rest = t31.restElement(t31.identifier(name));
-      rest.typeAnnotation = t31.tsTypeAnnotation(innerType.typeAnnotation);
+    if (t34.isTSRestType(innerType)) {
+      const rest = t34.restElement(t34.identifier(name));
+      rest.typeAnnotation = t34.tsTypeAnnotation(innerType.typeAnnotation);
       return rest;
     }
-    const id2 = t31.identifier(name);
+    const id2 = t34.identifier(name);
     id2.optional = optional;
-    id2.typeAnnotation = t31.tsTypeAnnotation(innerType);
+    id2.typeAnnotation = t34.tsTypeAnnotation(innerType);
     return id2;
   }
-  if (t31.isTSRestType(element)) {
-    const rest = t31.restElement(t31.identifier(`args${index}`));
-    rest.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
+  if (t34.isTSRestType(element)) {
+    const rest = t34.restElement(t34.identifier(`args${index}`));
+    rest.typeAnnotation = t34.tsTypeAnnotation(element.typeAnnotation);
     return rest;
   }
-  if (t31.isTSOptionalType(element)) {
-    const id2 = t31.identifier(`arg${index}`);
+  if (t34.isTSOptionalType(element)) {
+    const id2 = t34.identifier(`arg${index}`);
     id2.optional = true;
-    id2.typeAnnotation = t31.tsTypeAnnotation(element.typeAnnotation);
+    id2.typeAnnotation = t34.tsTypeAnnotation(element.typeAnnotation);
     return id2;
   }
-  const id = t31.identifier(`arg${index}`);
-  id.typeAnnotation = t31.tsTypeAnnotation(element);
+  const id = t34.identifier(`arg${index}`);
+  id.typeAnnotation = t34.tsTypeAnnotation(element);
   return id;
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-props.ts
-import * as t32 from "@babel/types";
+import * as t35 from "@babel/types";
 function resolveDefinePropsIface(path8, ctx) {
   const { node } = path8;
   const [runtimeArg] = node.arguments;
@@ -3856,38 +4315,38 @@ function processInferredTypes2(ctx, runtimeArg) {
   } = scriptData;
   if (!runtimeArg) return;
   const members = [];
-  if (t32.isArrayExpression(runtimeArg)) {
+  if (t35.isArrayExpression(runtimeArg)) {
     for (const element of runtimeArg.elements) {
-      if (!element || !t32.isStringLiteral(element)) continue;
-      const key = t32.isValidIdentifier(element.value) ? t32.identifier(element.value) : t32.stringLiteral(element.value);
-      const prop = t32.tsPropertySignature(key, t32.tsTypeAnnotation(t32.tsAnyKeyword()));
+      if (!element || !t35.isStringLiteral(element)) continue;
+      const key = t35.isValidIdentifier(element.value) ? t35.identifier(element.value) : t35.stringLiteral(element.value);
+      const prop = t35.tsPropertySignature(key, t35.tsTypeAnnotation(t35.tsAnyKeyword()));
       prop.optional = true;
       members.push(prop);
     }
     if (members.length) {
-      propsTypes.push(t32.tsTypeLiteral(members));
+      propsTypes.push(t35.tsTypeLiteral(members));
     }
     return;
   }
-  if (t32.isObjectExpression(runtimeArg)) {
+  if (t35.isObjectExpression(runtimeArg)) {
     for (const prop of runtimeArg.properties) {
-      if (!t32.isObjectProperty(prop)) continue;
-      if (t32.isSpreadElement(prop)) continue;
+      if (!t35.isObjectProperty(prop)) continue;
+      if (t35.isSpreadElement(prop)) continue;
       const key = prop.key;
       let propName = null;
-      if (t32.isIdentifier(key)) propName = key.name;
-      if (t32.isStringLiteral(key)) propName = key.value;
-      if (t32.isNumericLiteral(key)) propName = String(key.value);
+      if (t35.isIdentifier(key)) propName = key.name;
+      if (t35.isStringLiteral(key)) propName = key.value;
+      if (t35.isNumericLiteral(key)) propName = String(key.value);
       if (!propName) continue;
       const { type, required } = resolveRuntimePropMeta(prop.value);
-      const tsType = type ?? t32.tsAnyKeyword();
-      const tsKey = t32.isValidIdentifier(propName) ? t32.identifier(propName) : t32.stringLiteral(propName);
-      const tsProp = t32.tsPropertySignature(tsKey, t32.tsTypeAnnotation(tsType));
+      const tsType = type ?? t35.tsAnyKeyword();
+      const tsKey = t35.isValidIdentifier(propName) ? t35.identifier(propName) : t35.stringLiteral(propName);
+      const tsProp = t35.tsPropertySignature(tsKey, t35.tsTypeAnnotation(tsType));
       tsProp.optional = !required;
       members.push(tsProp);
     }
     if (members.length) {
-      propsTypes.push(t32.tsTypeLiteral(members));
+      propsTypes.push(t35.tsTypeLiteral(members));
     }
     return;
   }
@@ -3901,42 +4360,42 @@ function processInferredTypes2(ctx, runtimeArg) {
   );
 }
 function resolveRuntimePropMeta(value) {
-  if (t32.isIdentifier(value)) {
+  if (t35.isIdentifier(value)) {
     return {
       type: mapRuntimeTypeToTSType(value),
       required: false
     };
   }
-  if (t32.isArrayExpression(value)) {
+  if (t35.isArrayExpression(value)) {
     return {
       type: resolveRuntimeUnionType(value),
       required: false
     };
   }
-  if (!t32.isObjectExpression(value)) {
+  if (!t35.isObjectExpression(value)) {
     return { required: false };
   }
   let type;
   let required = false;
   for (const prop of value.properties) {
-    if (!t32.isObjectProperty(prop)) continue;
-    if (t32.isSpreadElement(prop)) continue;
+    if (!t35.isObjectProperty(prop)) continue;
+    if (t35.isSpreadElement(prop)) continue;
     const key = prop.key;
-    const propName = t32.isIdentifier(key) ? key.name : t32.isStringLiteral(key) ? key.value : null;
+    const propName = t35.isIdentifier(key) ? key.name : t35.isStringLiteral(key) ? key.value : null;
     if (!propName) continue;
     if (propName === "type") {
       const valueNode = prop.value;
-      if (t32.isArrayExpression(valueNode)) {
+      if (t35.isArrayExpression(valueNode)) {
         type = resolveRuntimeUnionType(valueNode);
         continue;
       }
-      if (t32.isIdentifier(valueNode)) {
+      if (t35.isIdentifier(valueNode)) {
         type = mapRuntimeTypeToTSType(valueNode);
         continue;
       }
     }
     if (propName === "required") {
-      if (t32.isBooleanLiteral(prop.value)) {
+      if (t35.isBooleanLiteral(prop.value)) {
         required = prop.value.value;
       }
     }
@@ -3946,80 +4405,58 @@ function resolveRuntimePropMeta(value) {
 function resolveRuntimeUnionType(value) {
   const types = [];
   for (const element of value.elements) {
-    if (!element || !t32.isIdentifier(element)) continue;
+    if (!element || !t35.isIdentifier(element)) continue;
     const resolved = mapRuntimeTypeToTSType(element);
     if (resolved) types.push(resolved);
   }
-  if (!types.length) return t32.tsAnyKeyword();
+  if (!types.length) return t35.tsAnyKeyword();
   if (types.length === 1) return types[0];
-  return t32.tsUnionType(types);
-}
-function mapRuntimeTypeToTSType(value) {
-  switch (value.name) {
-    case "String":
-      return t32.tsStringKeyword();
-    case "Number":
-      return t32.tsNumberKeyword();
-    case "Boolean":
-      return t32.tsBooleanKeyword();
-    case "Object":
-      return t32.tsTypeLiteral([]);
-    case "Array":
-      return t32.tsArrayType(t32.tsAnyKeyword());
-    case "Function":
-      return t32.tsFunctionType(null, [], t32.tsTypeAnnotation(t32.tsAnyKeyword()));
-    case "Symbol":
-      return t32.tsSymbolKeyword();
-    case "BigInt":
-      return t32.tsBigIntKeyword();
-    default:
-      return t32.tsAnyKeyword();
-  }
+  return t35.tsUnionType(types);
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
-import * as t35 from "@babel/types";
+import * as t38 from "@babel/types";
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/slot-builder.ts
-import * as t33 from "@babel/types";
+import * as t36 from "@babel/types";
 var SLOT_DEFAULT_NAME = "default";
 var SLOT_CHILDREN_NAME = "children";
 var SLOT_FN_PARAM_NAME = "props";
 function buildSlotPropSignature(rawName, params, optional) {
   const propName = rawName === SLOT_DEFAULT_NAME ? SLOT_CHILDREN_NAME : rawName;
-  const key = t33.isValidIdentifier(propName) ? t33.identifier(propName) : t33.stringLiteral(propName);
-  const reactNodeType = t33.tsTypeAnnotation(
-    t33.tsTypeReference(t33.identifier(REACT_API_MAP.ReactNode))
+  const key = t36.isValidIdentifier(propName) ? t36.identifier(propName) : t36.stringLiteral(propName);
+  const reactNodeType = t36.tsTypeAnnotation(
+    t36.tsTypeReference(t36.identifier(REACT_API_MAP.ReactNode))
   );
   let typeAnnotation;
   if (rawName === SLOT_DEFAULT_NAME && params.length === 0 || params.length === 0) {
     typeAnnotation = reactNodeType;
   } else {
-    const fnType = t33.tsFunctionType(null, params, reactNodeType);
-    typeAnnotation = t33.tsTypeAnnotation(fnType);
+    const fnType = t36.tsFunctionType(null, params, reactNodeType);
+    typeAnnotation = t36.tsTypeAnnotation(fnType);
   }
-  const prop = t33.tsPropertySignature(key, typeAnnotation);
+  const prop = t36.tsPropertySignature(key, typeAnnotation);
   prop.optional = optional;
   return prop;
 }
 function createSlotScopeParam(props, ctx) {
-  const paramId = t33.identifier(SLOT_FN_PARAM_NAME);
+  const paramId = t36.identifier(SLOT_FN_PARAM_NAME);
   const propsSigns = [];
   const { reactiveBindings } = ctx.templateData;
   props.forEach(({ prop, tsType }) => {
     const foundBindingValue = reactiveBindings[prop]?.value;
     const foundBindingTypes = foundBindingValue ? expressionToTSType(foundBindingValue) : null;
-    const typeAnnotation = foundBindingTypes ? t33.tsTypeAnnotation(foundBindingTypes) : tsType;
-    const key = t33.isValidIdentifier(prop) ? t33.identifier(prop) : t33.stringLiteral(prop);
-    const propSign = t33.tsPropertySignature(key, typeAnnotation);
+    const typeAnnotation = foundBindingTypes ? t36.tsTypeAnnotation(foundBindingTypes) : tsType;
+    const key = t36.isValidIdentifier(prop) ? t36.identifier(prop) : t36.stringLiteral(prop);
+    const propSign = t36.tsPropertySignature(key, typeAnnotation);
     propsSigns.push(propSign);
   });
-  paramId.typeAnnotation = t33.tsTypeAnnotation(t33.tsTypeLiteral(propsSigns));
+  paramId.typeAnnotation = t36.tsTypeAnnotation(t36.tsTypeLiteral(propsSigns));
   return paramId;
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/utils.ts
-import * as t34 from "@babel/types";
+import * as t37 from "@babel/types";
 function recordReactNode(ctx) {
   if (!ctx.scriptData.lang.startsWith("ts")) {
     return;
@@ -4035,16 +4472,16 @@ function collectLocalTypeDeclarations(path8) {
     return declarations;
   }
   for (const statement of programPath.node.body) {
-    if (t34.isTSInterfaceDeclaration(statement)) {
+    if (t37.isTSInterfaceDeclaration(statement)) {
       declarations.set(statement.id.name, {
-        type: t34.tsTypeLiteral(statement.body.body),
+        type: t37.tsTypeLiteral(statement.body.body),
         // 将接口体转换为类型字面量
         hasTypeParameters: !!statement.typeParameters?.params.length
         // 检查是否有泛型参数
       });
       continue;
     }
-    if (t34.isTSTypeAliasDeclaration(statement)) {
+    if (t37.isTSTypeAliasDeclaration(statement)) {
       declarations.set(statement.id.name, {
         type: statement.typeAnnotation,
         // 直接使用类型注解
@@ -4053,16 +4490,16 @@ function collectLocalTypeDeclarations(path8) {
       });
       continue;
     }
-    if (t34.isExportNamedDeclaration(statement) && statement.declaration) {
+    if (t37.isExportNamedDeclaration(statement) && statement.declaration) {
       const declaration = statement.declaration;
-      if (t34.isTSInterfaceDeclaration(declaration)) {
+      if (t37.isTSInterfaceDeclaration(declaration)) {
         declarations.set(declaration.id.name, {
-          type: t34.tsTypeLiteral(declaration.body.body),
+          type: t37.tsTypeLiteral(declaration.body.body),
           // 将接口体转换为类型字面量
           hasTypeParameters: !!declaration.typeParameters?.params.length
           // 检查是否有泛型参数
         });
-      } else if (t34.isTSTypeAliasDeclaration(declaration)) {
+      } else if (t37.isTSTypeAliasDeclaration(declaration)) {
         declarations.set(declaration.id.name, {
           type: declaration.typeAnnotation,
           // 直接使用类型注解
@@ -4075,22 +4512,22 @@ function collectLocalTypeDeclarations(path8) {
   return declarations;
 }
 function resolvePropName2(key) {
-  if (t34.isIdentifier(key)) {
+  if (t37.isIdentifier(key)) {
     return key.name;
   }
-  if (t34.isStringLiteral(key)) {
+  if (t37.isStringLiteral(key)) {
     return key.value;
   }
-  if (t34.isNumericLiteral(key)) {
+  if (t37.isNumericLiteral(key)) {
     return String(key.value);
   }
   return null;
 }
 function resolveCallableType(tsType) {
-  if (t34.isTSFunctionType(tsType)) {
+  if (t37.isTSFunctionType(tsType)) {
     return tsType;
   }
-  if (t34.isTSParenthesizedType(tsType)) {
+  if (t37.isTSParenthesizedType(tsType)) {
     return resolveCallableType(tsType.typeAnnotation);
   }
   return null;
@@ -4099,10 +4536,10 @@ function resolveCallableType(tsType) {
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/type-resolver.ts
 var SLOT_DEFAULT_NAME2 = "default";
 function resolveSlotType(tsType, options) {
-  if (t35.isTSParenthesizedType(tsType)) {
+  if (t38.isTSParenthesizedType(tsType)) {
     return resolveSlotType(tsType.typeAnnotation, options);
   }
-  if (t35.isTSTypeReference(tsType)) {
+  if (t38.isTSTypeReference(tsType)) {
     let shouldRecordReactNode = false;
     if (tsType.typeParameters?.params.length) {
       const params = [];
@@ -4118,11 +4555,11 @@ function resolveSlotType(tsType, options) {
         };
       }
       return {
-        type: t35.tsTypeReference(tsType.typeName, t35.tsTypeParameterInstantiation(params)),
+        type: t38.tsTypeReference(tsType.typeName, t38.tsTypeParameterInstantiation(params)),
         shouldRecordReactNode
       };
     }
-    if (!t35.isIdentifier(tsType.typeName)) {
+    if (!t38.isIdentifier(tsType.typeName)) {
       return {
         type: tsType,
         shouldRecordReactNode: false
@@ -4153,7 +4590,7 @@ function resolveSlotType(tsType, options) {
     }
     return resolved;
   }
-  if (t35.isTSIntersectionType(tsType)) {
+  if (t38.isTSIntersectionType(tsType)) {
     const types = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.types) {
@@ -4176,11 +4613,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t35.tsIntersectionType(types),
+      type: t38.tsIntersectionType(types),
       shouldRecordReactNode
     };
   }
-  if (t35.isTSUnionType(tsType)) {
+  if (t38.isTSUnionType(tsType)) {
     const types = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.types) {
@@ -4203,11 +4640,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t35.tsUnionType(types),
+      type: t38.tsUnionType(types),
       shouldRecordReactNode
     };
   }
-  if (t35.isTSTypeLiteral(tsType)) {
+  if (t38.isTSTypeLiteral(tsType)) {
     const members = [];
     let shouldRecordReactNode = false;
     for (const item of tsType.members) {
@@ -4222,11 +4659,11 @@ function resolveSlotType(tsType, options) {
       };
     }
     return {
-      type: t35.tsTypeLiteral(members),
+      type: t38.tsTypeLiteral(members),
       shouldRecordReactNode
     };
   }
-  if (t35.isTSFunctionType(tsType)) {
+  if (t38.isTSFunctionType(tsType)) {
     const props = buildSlotPropSignature(
       SLOT_DEFAULT_NAME2,
       cloneCallableParams(tsType.parameters),
@@ -4234,7 +4671,7 @@ function resolveSlotType(tsType, options) {
       // 默认插槽不是可选的
     );
     return {
-      type: t35.tsTypeLiteral([props]),
+      type: t38.tsTypeLiteral([props]),
       shouldRecordReactNode: true
       // 函数类型总是需要记录 ReactNode
     };
@@ -4245,7 +4682,7 @@ function resolveSlotType(tsType, options) {
   };
 }
 function resolveSlotPropFromMember(member) {
-  if (t35.isTSMethodSignature(member)) {
+  if (t38.isTSMethodSignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) {
       return {
@@ -4260,7 +4697,7 @@ function resolveSlotPropFromMember(member) {
       // 方法签名总是可调用，需要记录 ReactNode
     };
   }
-  if (t35.isTSPropertySignature(member)) {
+  if (t38.isTSPropertySignature(member)) {
     const rawName = resolvePropName2(member.key);
     if (!rawName) {
       return {
@@ -4283,7 +4720,7 @@ function resolveSlotPropFromMember(member) {
       // 可调用属性需要记录 ReactNode
     };
   }
-  if (t35.isTSCallSignatureDeclaration(member)) {
+  if (t38.isTSCallSignatureDeclaration(member)) {
     const params = cloneCallableParams(member.parameters);
     return {
       member: buildSlotPropSignature(SLOT_DEFAULT_NAME2, params, true),
@@ -4323,7 +4760,7 @@ function resolveDefineSlotsIface(path8, ctx) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-props-interface/resolve-slot/template-slots.ts
-import * as t36 from "@babel/types";
+import * as t39 from "@babel/types";
 function resolveTemplateSlotIface(ctx) {
   if (ctx.inputType !== "sfc") return;
   const {
@@ -4341,7 +4778,7 @@ function resolveTemplateSlotIface(ctx) {
   }
   if (tsMembers.length) {
     recordReactNode(ctx);
-    slotTypes.push(t36.tsTypeLiteral(tsMembers));
+    slotTypes.push(t39.tsTypeLiteral(tsMembers));
   }
 }
 
@@ -4393,9 +4830,9 @@ function resolveCompIProps(ctx, ast) {
   }
   const n = declaredOptions.name || "Comp";
   const ns = `I${camelCase(capitalize(n))}Props`;
-  const typeNode = t37.tsIntersectionType(tsTypes);
-  const typeAliasDecl = t37.tsTypeAliasDeclaration(t37.identifier(ns), null, typeNode);
-  const exportDecl = t37.exportNamedDeclaration(typeAliasDecl);
+  const typeNode = t40.tsIntersectionType(tsTypes);
+  const typeAliasDecl = t40.tsTypeAliasDeclaration(t40.identifier(ns), null, typeNode);
+  const exportDecl = t40.exportNamedDeclaration(typeAliasDecl);
   propsTSIface.name = ns;
   const scriptIR = getScriptIR(ctx);
   scriptIR.exports.push(exportDecl);
@@ -4403,15 +4840,15 @@ function resolveCompIProps(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/preprocess/resolve-use-attrs.ts
-import * as t38 from "@babel/types";
+import * as t41 from "@babel/types";
 function resolveUseAttrs(ctx) {
   return {
     VariableDeclarator(path8) {
       const { init, id } = path8.node;
       if (!init) return;
       const initPath = path8.get("init");
-      const propsIdentifier = t38.identifier(ctx.propField);
-      if (t38.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
+      const propsIdentifier = t41.identifier(ctx.propField);
+      if (t41.isTSAsExpression(init) && isUseAttrsCall(init.expression)) {
         const typeAssertion = createPropsTypeAssertion(propsIdentifier, init.typeAnnotation);
         replaceNode(initPath, typeAssertion, init);
         return;
@@ -4422,13 +4859,13 @@ function resolveUseAttrs(ctx) {
       const isTS = ctx.scriptData.lang.startsWith("ts");
       if (isTS) {
         let typeAnnotation = null;
-        if (t38.isIdentifier(id) && t38.isTSTypeAnnotation(id.typeAnnotation)) {
+        if (t41.isIdentifier(id) && t41.isTSTypeAnnotation(id.typeAnnotation)) {
           typeAnnotation = id.typeAnnotation.typeAnnotation;
           id.typeAnnotation = null;
         } else {
-          typeAnnotation = t38.tsTypeReference(
-            t38.identifier("Record"),
-            t38.tsTypeParameterInstantiation([t38.tsStringKeyword(), t38.tsUnknownKeyword()])
+          typeAnnotation = t41.tsTypeReference(
+            t41.identifier("Record"),
+            t41.tsTypeParameterInstantiation([t41.tsStringKeyword(), t41.tsUnknownKeyword()])
           );
         }
         const propsTypeAssertion = createPropsTypeAssertion(propsIdentifier, typeAnnotation);
@@ -4440,18 +4877,18 @@ function resolveUseAttrs(ctx) {
   };
 }
 function isUseAttrsCall(expr) {
-  return t38.isCallExpression(expr) && isCalleeNamed(expr, VUE_API_MAP.useAttrs);
+  return t41.isCallExpression(expr) && isCalleeNamed(expr, VUE_API_MAP.useAttrs);
 }
 function createPropsTypeAssertion(propsIdentifier, typeAnnotation) {
-  return t38.tsAsExpression(propsIdentifier, typeAnnotation);
+  return t41.tsAsExpression(propsIdentifier, typeAnnotation);
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-import * as t44 from "@babel/types";
+import * as t48 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 import { traverse as traverse2 } from "@babel/core";
-import * as t43 from "@babel/types";
+import * as t46 from "@babel/types";
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/binding-utils.ts
 function isBindingDeclaredInsideBoundary(binding, boundary) {
@@ -4470,7 +4907,7 @@ function isReactiveBinding(node) {
 }
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-checker.ts
-import * as t39 from "@babel/types";
+import * as t42 from "@babel/types";
 function isEligibleBindingSource(binding) {
   if (binding.kind === "param") {
     return false;
@@ -4480,57 +4917,57 @@ function isEligibleBindingSource(binding) {
   const declaratorPath = getVariableDeclaratorPath(bindingPath);
   const isReactiveVarBinding = !!declaratorPath && isReactiveBinding(declaratorPath.node);
   const nodeInit = declaratorPath?.node.init;
-  const isReactiveApiCallVarBinding = !!declaratorPath && t39.isCallExpression(nodeInit) && t39.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
-  const isHookCallVarBinding = !!declaratorPath && t39.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
-  const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t39.isArrowFunctionExpression(nodeInit) || t39.isFunctionExpression(nodeInit));
+  const isReactiveApiCallVarBinding = !!declaratorPath && t42.isCallExpression(nodeInit) && t42.isIdentifier(nodeInit.callee) && reactiveStateApis.has(nodeInit.callee.name);
+  const isHookCallVarBinding = !!declaratorPath && t42.isCallExpression(nodeInit) && isHookLikeCallee(nodeInit.callee);
+  const isFunctionBinding = bindingPath.isFunctionDeclaration() || !!declaratorPath && !!nodeInit && (t42.isArrowFunctionExpression(nodeInit) || t42.isFunctionExpression(nodeInit));
   const isReactiveFunctionBinding = isFunctionBinding && (isReactiveBinding(declaratorPath?.node) || isReactiveBinding(bindingPath.node));
   return isReactiveVarBinding || isReactiveApiCallVarBinding || isHookCallVarBinding || isReactiveFunctionBinding;
 }
 function isReactValidDependencyExpr(node) {
-  if (t39.isIdentifier(node)) {
+  if (t42.isIdentifier(node)) {
     return true;
   }
-  if (t39.isMemberExpression(node) || t39.isOptionalMemberExpression(node)) {
+  if (t42.isMemberExpression(node) || t42.isOptionalMemberExpression(node)) {
     return isStaticMemberChain(node);
   }
   return false;
 }
 function isStaticMemberChain(node) {
   let current = node;
-  while (t39.isMemberExpression(current) || t39.isOptionalMemberExpression(current)) {
-    if (!current.computed && !t39.isIdentifier(current.property)) {
+  while (t42.isMemberExpression(current) || t42.isOptionalMemberExpression(current)) {
+    if (!current.computed && !t42.isIdentifier(current.property)) {
       return false;
     }
-    if (current.computed && !t39.isStringLiteral(current.property) && !t39.isNumericLiteral(current.property)) {
+    if (current.computed && !t42.isStringLiteral(current.property) && !t42.isNumericLiteral(current.property)) {
       return false;
     }
     current = current.object;
   }
-  return t39.isIdentifier(current);
+  return t42.isIdentifier(current);
 }
 function isHookLikeCallee(callee) {
-  if (t39.isIdentifier(callee)) {
+  if (t42.isIdentifier(callee)) {
     return callee.name.startsWith("use");
   }
-  if (t39.isMemberExpression(callee) && !callee.computed && t39.isIdentifier(callee.property)) {
+  if (t42.isMemberExpression(callee) && !callee.computed && t42.isIdentifier(callee.property)) {
     return callee.property.name.startsWith("use");
   }
   return false;
 }
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-key.ts
-import * as t40 from "@babel/types";
+import * as t43 from "@babel/types";
 function getDependencyKey(exp) {
-  if (t40.isIdentifier(exp)) {
+  if (t43.isIdentifier(exp)) {
     return exp.name;
   }
-  if (t40.isMemberExpression(exp) || t40.isOptionalMemberExpression(exp)) {
+  if (t43.isMemberExpression(exp) || t43.isOptionalMemberExpression(exp)) {
     const objectKey = getDependencyKey(exp.object);
     const opt = exp.optional ? "?" : "";
-    if (!exp.computed && t40.isIdentifier(exp.property)) {
+    if (!exp.computed && t43.isIdentifier(exp.property)) {
       return `${objectKey}${opt}.${exp.property.name}`;
     }
-    if (t40.isStringLiteral(exp.property) || t40.isNumericLiteral(exp.property)) {
+    if (t43.isStringLiteral(exp.property) || t43.isNumericLiteral(exp.property)) {
       return `${objectKey}${opt}[${JSON.stringify(exp.property.value)}]`;
     }
     return `${objectKey}${opt}[*]`;
@@ -4539,40 +4976,40 @@ function getDependencyKey(exp) {
 }
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/dep-normalizer.ts
-import * as t41 from "@babel/types";
+import * as t44 from "@babel/types";
 function normalizeDependencyExpr(path8, rootName, ctx) {
-  if (t41.isIdentifier(path8.node)) {
-    return t41.identifier(path8.node.name);
+  if (t44.isIdentifier(path8.node)) {
+    return t44.identifier(path8.node.name);
   }
-  if (t41.isMemberExpression(path8.node) || t41.isOptionalMemberExpression(path8.node)) {
+  if (t44.isMemberExpression(path8.node) || t44.isOptionalMemberExpression(path8.node)) {
     if (rootName === ctx.propField) {
       const safePropsExp = ensureOptionalForMemberChain(path8.node);
       if (isReactValidDependencyExpr(safePropsExp)) {
-        return t41.cloneNode(safePropsExp, true);
+        return t44.cloneNode(safePropsExp, true);
       }
-      return t41.identifier(rootName);
+      return t44.identifier(rootName);
     }
     const normalizedExp = normalizeMemberForCallSite(path8, path8.node);
-    const safeExp = t41.isMemberExpression(normalizedExp) || t41.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
+    const safeExp = t44.isMemberExpression(normalizedExp) || t44.isOptionalMemberExpression(normalizedExp) ? ensureOptionalForMemberChain(normalizedExp) : normalizedExp;
     if (isReactValidDependencyExpr(safeExp)) {
-      return t41.cloneNode(safeExp, true);
+      return t44.cloneNode(safeExp, true);
     }
-    return t41.identifier(rootName);
+    return t44.identifier(rootName);
   }
   return null;
 }
 function normalizeSourcedDependency(exp) {
-  if (t41.isIdentifier(exp)) {
-    return t41.identifier(exp.name);
+  if (t44.isIdentifier(exp)) {
+    return t44.identifier(exp.name);
   }
-  if (t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp)) {
+  if (t44.isMemberExpression(exp) || t44.isOptionalMemberExpression(exp)) {
     const root = findRootIdentifier(exp);
     if (!root) return null;
-    const safeExp = t41.isMemberExpression(exp) || t41.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
+    const safeExp = t44.isMemberExpression(exp) || t44.isOptionalMemberExpression(exp) ? ensureOptionalForMemberChain(exp) : exp;
     if (isReactValidDependencyExpr(safeExp)) {
-      return t41.cloneNode(safeExp, true);
+      return t44.cloneNode(safeExp, true);
     }
-    return t41.identifier(root.name);
+    return t44.identifier(root.name);
   }
   return null;
 }
@@ -4582,7 +5019,7 @@ function normalizeMemberForCallSite(path8, node) {
   if (!isDirectCallee) {
     return node;
   }
-  if (!t41.isExpression(node.object)) {
+  if (!t44.isExpression(node.object)) {
     return node;
   }
   return node.object;
@@ -4594,20 +5031,20 @@ function ensureOptionalForMemberChain(node) {
   const rebuildWithOptionalChain = (node2) => {
     const safeObject = ensureOptionalForMemberChain(node2.object);
     if (safeObject !== node2.object) {
-      const property = t41.cloneNode(node2.property, true);
-      return t41.optionalMemberExpression(safeObject, property, node2.computed, true);
+      const property = t44.cloneNode(node2.property, true);
+      return t44.optionalMemberExpression(safeObject, property, node2.computed, true);
     }
-    if (t41.isMemberExpression(node2)) {
-      const object = t41.cloneNode(node2.object, true);
-      const property = t41.cloneNode(node2.property, true);
-      return t41.optionalMemberExpression(object, property, node2.computed, true);
+    if (t44.isMemberExpression(node2)) {
+      const object = t44.cloneNode(node2.object, true);
+      const property = t44.cloneNode(node2.property, true);
+      return t44.optionalMemberExpression(object, property, node2.computed, true);
     }
     return node2;
   };
   return rebuildWithOptionalChain(node);
 }
 function hasTrailingMemberAccess(node) {
-  return t41.isMemberExpression(node.object) || t41.isOptionalMemberExpression(node.object);
+  return t44.isMemberExpression(node.object) || t44.isOptionalMemberExpression(node.object);
 }
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/shared-utils.ts
@@ -4622,7 +5059,7 @@ function isNestedMemberObject(path8) {
 }
 
 // src/core/transform/sfc/script/shared/dependency-analyzer/trace-utils.ts
-import * as t42 from "@babel/types";
+import * as t45 from "@babel/types";
 function traceBindingSource(binding, seen, depth) {
   if (depth <= 0) return null;
   const declaratorPath = getVariableDeclaratorPath(binding.path);
@@ -4634,7 +5071,7 @@ function traceBindingSource(binding, seen, depth) {
 }
 function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
   if (depth <= 0) return null;
-  if (t42.isIdentifier(exp)) {
+  if (t45.isIdentifier(exp)) {
     const sourceBinding = scope.getBinding(exp.name);
     if (!sourceBinding) return null;
     if (isEligibleBindingSource(sourceBinding)) {
@@ -4642,13 +5079,13 @@ function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
     }
     return traceBindingSource(sourceBinding, seen, depth - 1);
   }
-  if (t42.isMemberExpression(exp) || t42.isOptionalMemberExpression(exp)) {
+  if (t45.isMemberExpression(exp) || t45.isOptionalMemberExpression(exp)) {
     const root = findRootIdentifier(exp);
     if (!root) return null;
     const sourceBinding = scope.getBinding(root.name);
     if (!sourceBinding) return null;
     if (isEligibleBindingSource(sourceBinding)) {
-      return t42.cloneNode(exp);
+      return t45.cloneNode(exp);
     }
     const sourcedRoot = traceBindingSource(sourceBinding, seen, depth - 1);
     if (sourcedRoot) {
@@ -4656,17 +5093,17 @@ function isExpressionSourcedFromEligibleBinding(exp, scope, seen, depth) {
       if (rebuilt) {
         return rebuilt;
       }
-      return t42.cloneNode(sourcedRoot, true);
+      return t45.cloneNode(sourcedRoot, true);
     }
   }
   return null;
 }
 function rebuildMemberWithNewRoot(node, nextRoot) {
   const replacedObject = (() => {
-    if (t42.isIdentifier(node.object)) {
-      return t42.cloneNode(nextRoot, true);
+    if (t45.isIdentifier(node.object)) {
+      return t45.cloneNode(nextRoot, true);
     }
-    if (t42.isMemberExpression(node.object) || t42.isOptionalMemberExpression(node.object)) {
+    if (t45.isMemberExpression(node.object) || t45.isOptionalMemberExpression(node.object)) {
       return rebuildMemberWithNewRoot(node.object, nextRoot);
     }
     return null;
@@ -4674,15 +5111,15 @@ function rebuildMemberWithNewRoot(node, nextRoot) {
   if (!replacedObject) {
     return null;
   }
-  const property = t42.cloneNode(node.property, true);
-  if (t42.isMemberExpression(node)) {
-    return t42.memberExpression(
+  const property = t45.cloneNode(node.property, true);
+  if (t45.isMemberExpression(node)) {
+    return t45.memberExpression(
       replacedObject,
       property,
       node.computed
     );
   }
-  return t42.optionalMemberExpression(
+  return t45.optionalMemberExpression(
     replacedObject,
     property,
     node.computed,
@@ -4693,9 +5130,9 @@ function rebuildMemberWithNewRoot(node, nextRoot) {
 // src/core/transform/sfc/script/shared/dependency-analyzer/index.ts
 function analyzeDeps(node, ctx, parentPath) {
   if (!parentPath) {
-    return t43.arrayExpression([]);
+    return t46.arrayExpression([]);
   }
-  const isFnExpr = t43.isArrowFunctionExpression(node) || t43.isFunctionExpression(node);
+  const isFnExpr = t46.isArrowFunctionExpression(node) || t46.isFunctionExpression(node);
   const analyzeTarget = isFnExpr ? node.body : node;
   const bindingLocalBoundary = isFnExpr ? node : analyzeTarget;
   const deps = /* @__PURE__ */ new Map();
@@ -4705,13 +5142,13 @@ function analyzeDeps(node, ctx, parentPath) {
   }
   const analyzeTargetPath = parentPath && parentPath.node === analyzeTarget ? parentPath : null;
   if (analyzeTargetPath) {
-    if (t43.isMemberExpression(analyzeTarget) || t43.isOptionalMemberExpression(analyzeTarget)) {
+    if (t46.isMemberExpression(analyzeTarget) || t46.isOptionalMemberExpression(analyzeTarget)) {
       const rootId = findRootIdentifier(analyzeTarget);
       if (rootId) {
         tryAddDependency(analyzeTargetPath, rootId.name, analyzeTargetPath.scope);
         processedIdentifiers.add(rootId);
       }
-    } else if (t43.isIdentifier(analyzeTarget)) {
+    } else if (t46.isIdentifier(analyzeTarget)) {
       tryAddDependency(analyzeTargetPath, analyzeTarget.name, analyzeTargetPath.scope);
     }
   }
@@ -4763,55 +5200,54 @@ function analyzeDeps(node, ctx, parentPath) {
       }
     }
   }
-  return t43.arrayExpression(Array.from(deps.values()));
+  return t46.arrayExpression(Array.from(deps.values()));
 }
 
-// src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
-function resolveAnalysisOnlyAdapter(ctx) {
+// src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
+import * as t47 from "@babel/types";
+function resolveRenameAdapter(ctx) {
   return {
     "CallExpression|Identifier"(path8) {
       const node = path8.node;
-      const apiName = getApiName(node);
-      const adapter = ADAPTER_RULES.runtime[apiName];
-      if (!adapter || adapter.type !== "analyzed-deps") {
+      const isCallNode = t47.isCallExpression(node);
+      let apiName = "";
+      if (t47.isIdentifier(node)) {
+        apiName = node.name;
+      } else if (isCallNode && t47.isIdentifier(node.callee)) {
+        apiName = node.callee.name;
+      }
+      if (!apiName) {
+        return;
+      }
+      const runtimeAdapter = ADAPTER_RULES.runtime[apiName];
+      const routerAdapter = ADAPTER_RULES.router[apiName];
+      const adapter = runtimeAdapter || routerAdapter;
+      if (!adapter || adapter.type !== "rename") {
         return;
       }
       if (!isVueApiReference(path8, apiName)) {
         return;
       }
-      if (t44.isCallExpression(node)) {
-        resolveCallNode(path8, adapter, ctx);
+      if (adapter.isTrackable) {
+        const reactiveType = getReactiveType(apiName);
+        const declaratorPath = getVariableDeclaratorPath(path8);
+        setScriptNodeMeta(declaratorPath?.node, {
+          is_reactive: true,
+          reactive_type: reactiveType
+        });
+      }
+      if (isCallNode) {
+        replaceCallName(node, adapter.target);
       } else {
         replaceIdName(node, adapter.target);
       }
+      if (adapter.package === PACKAGE_NAME.router && !ctx.route) {
+        ctx.route = true;
+      }
       recordImport(ctx, adapter.package, adapter.target);
     }
   };
 }
-function getApiName(node) {
-  const isCallNode = t44.isCallExpression(node);
-  let apiName = "";
-  if (t44.isIdentifier(node)) {
-    apiName = node.name;
-  } else if (isCallNode && t44.isIdentifier(node.callee)) {
-    apiName = node.callee.name;
-  }
-  return apiName;
-}
-function resolveCallNode(path8, adapter, ctx) {
-  const { node } = path8;
-  const { arguments: args } = node;
-  if (!args.length) return;
-  const fn = args[0];
-  if (!t44.isArrowFunctionExpression(fn) && !t44.isFunctionExpression(fn)) {
-    return;
-  }
-  const fnPath = path8.get("arguments")[0];
-  const deps = analyzeDeps(fn, ctx, fnPath);
-  args.push(deps);
-  replaceCallName(node, adapter.target);
-  recordImport(ctx, adapter.package, adapter.target);
-}
 function isVueApiReference(path8, apiName) {
   if (path8.isIdentifier()) {
     if (path8.parentPath.isCallExpression() && path8.parentPath.node.callee === path8.node) {
@@ -4821,12 +5257,11 @@ function isVueApiReference(path8, apiName) {
       return false;
     }
   }
-  if (path8.isCallExpression()) {
-    const callee = path8.get("callee");
-    if (!callee.isIdentifier()) return false;
-    return isVueImportBinding(callee.scope.getBinding(apiName));
+  const binding = path8.isCallExpression() ? path8.get("callee").scope.getBinding(apiName) : path8.scope.getBinding(apiName);
+  if (binding) {
+    return isVueImportBinding(binding);
   }
-  return isVueImportBinding(path8.scope.getBinding(apiName));
+  return AUTO_IMPORTED_APIS.has(apiName);
 }
 function isVueImportBinding(binding) {
   if (!binding) return false;
@@ -4835,7 +5270,7 @@ function isVueImportBinding(binding) {
     return false;
   }
   const parent = bindingPath.parentPath?.node;
-  if (!parent || !t44.isImportDeclaration(parent)) {
+  if (!parent || !t47.isImportDeclaration(parent)) {
     return false;
   }
   const source = parent.source.value.toLowerCase();
@@ -4848,6 +5283,53 @@ function isVueImportBinding(binding) {
   return VUE_PACKAGES.some((name) => source === name || source.startsWith(`${name}/`));
 }
 
+// src/core/transform/sfc/script/syntax-processor/process/resolve-analysis-only-adapter.ts
+function resolveAnalysisOnlyAdapter(ctx) {
+  return {
+    "CallExpression|Identifier"(path8) {
+      const node = path8.node;
+      const apiName = getApiName(node);
+      const adapter = ADAPTER_RULES.runtime[apiName];
+      if (!adapter || adapter.type !== "analyzed-deps") {
+        return;
+      }
+      if (!isVueApiReference(path8, apiName)) {
+        return;
+      }
+      if (t48.isCallExpression(node)) {
+        resolveCallNode(path8, adapter, ctx);
+      } else {
+        replaceIdName(node, adapter.target);
+      }
+      recordImport(ctx, adapter.package, adapter.target);
+    }
+  };
+}
+function getApiName(node) {
+  const isCallNode = t48.isCallExpression(node);
+  let apiName = "";
+  if (t48.isIdentifier(node)) {
+    apiName = node.name;
+  } else if (isCallNode && t48.isIdentifier(node.callee)) {
+    apiName = node.callee.name;
+  }
+  return apiName;
+}
+function resolveCallNode(path8, adapter, ctx) {
+  const { node } = path8;
+  const { arguments: args } = node;
+  if (!args.length) return;
+  const fn = args[0];
+  if (!t48.isArrowFunctionExpression(fn) && !t48.isFunctionExpression(fn)) {
+    return;
+  }
+  const fnPath = path8.get("arguments")[0];
+  const deps = analyzeDeps(fn, ctx, fnPath);
+  args.push(deps);
+  replaceCallName(node, adapter.target);
+  recordImport(ctx, adapter.package, adapter.target);
+}
+
 // src/core/transform/sfc/script/syntax-processor/process/resolve-arrow-deps.ts
 function resolveArrowFnDeps(ctx, ast) {
   return {
@@ -4903,7 +5385,7 @@ function isSkip(path8) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-element-ref.ts
-import * as t45 from "@babel/types";
+import * as t49 from "@babel/types";
 function resolveElementRef(ctx) {
   return {
     CallExpression(path8) {
@@ -4921,14 +5403,14 @@ function resolveElementRef(ctx) {
       }
       if (isCompRefBindings) {
         const varDeclaratorPath = getVariableDeclaratorPath(path8)?.node;
-        if (!t45.isIdentifier(varDeclaratorPath?.id)) {
+        if (!t49.isIdentifier(varDeclaratorPath?.id)) {
           return;
         }
         const varName = varDeclaratorPath.id.name;
         const compRef = refBindings.componentRefs[varName];
         if (!compRef) return;
       }
-      node.arguments[0] = t45.identifier("null");
+      node.arguments[0] = t49.identifier("null");
       resolveTypeParameters(ctx, path8);
       replaceCallName(node, REACT_API_MAP.useRef);
       recordImport(ctx, PACKAGE_NAME.react, REACT_API_MAP.useRef);
@@ -4953,27 +5435,27 @@ function resolveTypeParameters(ctx, path8) {
   const compBindingMeta = refBindings.componentRefs[idName];
   if (!node.typeParameters && (domBindingMeta || compBindingMeta)) {
     const type = compBindingMeta ? "any" : domBindingMeta.htmlType;
-    node.typeParameters = t45.tsTypeParameterInstantiation([t45.tsTypeReference(t45.identifier(type))]);
+    node.typeParameters = t49.tsTypeParameterInstantiation([t49.tsTypeReference(t49.identifier(type))]);
   }
 }
 function resolveRefValueToCurrent(path8) {
   const { node } = path8;
-  if (node.computed || !t45.isIdentifier(node.property) || node.property.name !== "value") {
+  if (node.computed || !t49.isIdentifier(node.property) || node.property.name !== "value") {
     return;
   }
   const rootPath = findRootVariablePath(path8);
-  if (!rootPath?.node || !t45.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
+  if (!rootPath?.node || !t49.isCallExpression(rootPath.node.init) || !isCalleeNamed(rootPath.node.init, REACT_API_MAP.useRef)) {
     return;
   }
   const rootId = findRootIdentifier(node);
-  if (!t45.isIdentifier(node.object) || node.object.name !== rootId?.name) {
+  if (!t49.isIdentifier(node.object) || node.object.name !== rootId?.name) {
     return;
   }
   node.property.name = "current";
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-expression-memo.ts
-import * as t46 from "@babel/types";
+import * as t50 from "@babel/types";
 function resolveExprMemo(ctx, ast) {
   const isScriptFile = ctx.inputType !== "sfc";
   return {
@@ -4985,11 +5467,11 @@ function resolveExprMemo(ctx, ast) {
         if (!atComponentOrHookRoot(path8, ast.program, isScriptFile)) {
           return false;
         }
-        if (!t46.isVariableDeclaration(path8.parent) || path8.parent.kind !== "const") {
+        if (!t50.isVariableDeclaration(path8.parent) || path8.parent.kind !== "const") {
           return false;
         }
-        if (t46.isFunction(init)) return false;
-        if (t46.isCallExpression(init) && t46.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
+        if (t50.isFunction(init)) return false;
+        if (t50.isCallExpression(init) && t50.isIdentifier(init.callee) && init.callee.name.startsWith("use")) {
           return false;
         }
         return true;
@@ -5008,16 +5490,16 @@ function resolveExprMemo(ctx, ast) {
 }
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-lint-rules.ts
-import * as t47 from "@babel/types";
+import * as t51 from "@babel/types";
 function resolveLintRules(ctx, ast) {
   const inScriptFile = ctx.inputType !== "sfc";
   return {
     CallExpression(path8) {
       const { node, parentPath } = path8;
-      if (!t47.isIdentifier(node.callee)) return;
+      if (!t51.isIdentifier(node.callee)) return;
       const { name: callName } = node.callee;
-      const addLog = (t53) => {
-        logger.error(t53, {
+      const addLog = (t56) => {
+        logger.error(t56, {
           file: ctx.filename,
           source: ctx.scriptData.source,
           loc: node.loc
@@ -5062,7 +5544,7 @@ function resolveLintRules(ctx, ast) {
 
 // src/core/transform/sfc/script/syntax-processor/process/resolve-provide.ts
 import { generate as generate2 } from "@babel/generator";
-import * as t48 from "@babel/types";
+import * as t52 from "@babel/types";
 function resolveProvide(ctx) {
   const { filename, scriptData, inputType } = ctx;
   if (inputType !== "sfc") {
@@ -5105,13 +5587,13 @@ function findOrCreateCtxProvider(root) {
 function assignProviderValue(target, key, value) {
   const getRawExp = (exp) => {
     if (!exp) return "''";
-    if (t48.isStringLiteral(exp)) {
+    if (t52.isStringLiteral(exp)) {
       return JSON.stringify(exp.value);
     }
-    if (t48.isNumericLiteral(exp)) {
+    if (t52.isNumericLiteral(exp)) {
       return exp.value.toString();
     }
-    if (t48.isIdentifier(exp)) {
+    if (t52.isIdentifier(exp)) {
       return exp.name;
     }
     try {
@@ -5126,96 +5608,13 @@ function assignProviderValue(target, key, value) {
   target.provide = {};
 }
 
-// src/core/transform/sfc/script/syntax-processor/process/resolve-rename-adapter.ts
-import * as t49 from "@babel/types";
-function resolveRenameAdapter(ctx) {
-  return {
-    "CallExpression|Identifier"(path8) {
-      const node = path8.node;
-      const isCallNode = t49.isCallExpression(node);
-      let apiName = "";
-      if (t49.isIdentifier(node)) {
-        apiName = node.name;
-      } else if (isCallNode && t49.isIdentifier(node.callee)) {
-        apiName = node.callee.name;
-      }
-      if (!apiName) {
-        return;
-      }
-      const runtimeAdapter = ADAPTER_RULES.runtime[apiName];
-      const routerAdapter = ADAPTER_RULES.router[apiName];
-      const adapter = runtimeAdapter || routerAdapter;
-      if (!adapter || adapter.type !== "rename") {
-        return;
-      }
-      if (!isVueApiReference2(path8, apiName)) {
-        return;
-      }
-      if (adapter.isTrackable) {
-        const reactiveType = getReactiveType(apiName);
-        const declaratorPath = getVariableDeclaratorPath(path8);
-        setScriptNodeMeta(declaratorPath?.node, {
-          is_reactive: true,
-          reactive_type: reactiveType
-        });
-      }
-      if (isCallNode) {
-        replaceCallName(node, adapter.target);
-      } else {
-        replaceIdName(node, adapter.target);
-      }
-      if (adapter.package === PACKAGE_NAME.router && !ctx.route) {
-        ctx.route = true;
-      }
-      recordImport(ctx, adapter.package, adapter.target);
-    }
-  };
-}
-function isVueApiReference2(path8, apiName) {
-  const whitelist = [VUE_API_MAP.defineAsyncComponent];
-  if (whitelist.includes(apiName)) {
-    return true;
-  }
-  if (path8.isIdentifier()) {
-    if (path8.parentPath.isCallExpression() && path8.parentPath.node.callee === path8.node) {
-      return false;
-    }
-    if (!path8.isReferencedIdentifier()) {
-      return false;
-    }
-  }
-  if (path8.isCallExpression()) {
-    const callee = path8.get("callee");
-    if (!callee.isIdentifier()) return false;
-    return isVueImportBinding2(callee.scope.getBinding(apiName));
-  }
-  return isVueImportBinding2(path8.scope.getBinding(apiName));
-}
-function isVueImportBinding2(binding) {
-  if (!binding) return false;
-  const bindingPath = binding.path;
-  if (!bindingPath.isImportSpecifier() && !bindingPath.isImportDefaultSpecifier() && !bindingPath.isImportNamespaceSpecifier()) {
-    return false;
-  }
-  const parent = bindingPath.parentPath?.node;
-  if (!parent || !t49.isImportDeclaration(parent)) {
-    return false;
-  }
-  const source = parent.source.value.toLowerCase();
-  if (source.startsWith("@vue/")) {
-    return true;
-  }
-  if (source === "vue-router" || source.startsWith("vue-router/")) {
-    return true;
-  }
-  return VUE_PACKAGES.some((name) => source === name || source.startsWith(`${name}/`));
-}
-
 // src/core/transform/sfc/script/syntax-processor/index.ts
 function processVueSyntax2(ast, ctx) {
   vueSyntaxProcessor2(ast, ctx, {
     preprocess: {
       applyBabel: [
+        // feature: https://github.com/vureact-js/core/issues/63
+        resolveWithDefaultsOptions,
         resolvePropsIface,
         resolveEmitsTopLevelTypes,
         resolveDefineOptions,
@@ -5223,7 +5622,9 @@ function processVueSyntax2(ast, ctx) {
         resolveDefineAsyncComponent,
         resolveEmitCalls,
         // feature: https://github.com/vureact-js/core/issues/6
-        resolveUseAttrs
+        resolveUseAttrs,
+        // feature: https://github.com/vureact-js/core/issues/56
+        resolveDefineModel
       ]
     },
     process: {
@@ -5242,6 +5643,8 @@ function processVueSyntax2(ast, ctx) {
     },
     postprocess: {
       applyBabel: [
+        // feature: https://github.com/vureact-js/core/issues/63
+        resolveWithDefaults,
         // 该 resolver 需确保放在所有类型处理之后，移除之前
         resolveVueTypeAsAny,
         resolveRuntimeImports,
@@ -5266,7 +5669,6 @@ function vueSyntaxProcessor2(ast, ctx, options) {
 }
 
 // src/core/transform/sfc/script/index.ts
-var SCRIPT_IR_KEY = "__vureact_script_block_ir";
 function resolveScript2(ast, ctx) {
   const scriptIR = createScriptIR();
   setScriptIR(ctx, scriptIR);
@@ -5280,14 +5682,14 @@ function resolveScript2(ast, ctx) {
   return scriptIR;
 }
 function getScriptIR(ctx) {
-  const ir = ctx.scriptData[SCRIPT_IR_KEY];
+  const ir = ctx.scriptData.__vureact_script_block_ir;
   if (!ir) {
     throw new Error("Script IR is not initialized for current compilation context");
   }
   return ir;
 }
 function setScriptIR(ctx, ir) {
-  ctx.scriptData[SCRIPT_IR_KEY] = ir;
+  ctx.scriptData.__vureact_script_block_ir = ir;
 }
 function createScriptIR() {
   return {
@@ -5339,15 +5741,15 @@ function isRouterLinkBooleanCustomProp(prop) {
 }
 
 // src/core/transform/sfc/template/shared/prop-ir-utils.ts
-import * as t51 from "@babel/types";
+import * as t54 from "@babel/types";
 
 // src/shared/string-code-types.ts
 import { parseExpression as parseExpression3 } from "@babel/parser";
-import * as t50 from "@babel/types";
+import * as t53 from "@babel/types";
 var strCodeTypes = {
-  isIdentifier: isIdentifier29,
+  isIdentifier: isIdentifier32,
   isSimpleExpression,
-  isStringLiteral: isStringLiteral13
+  isStringLiteral: isStringLiteral15
 };
 function isSimpleExpression(code, excludeVar = false) {
   let node;
@@ -5356,38 +5758,38 @@ function isSimpleExpression(code, excludeVar = false) {
   } catch {
     return false;
   }
-  if (t50.isLiteral(node)) {
+  if (t53.isLiteral(node)) {
     return true;
   }
-  if (!excludeVar && t50.isIdentifier(node)) {
+  if (!excludeVar && t53.isIdentifier(node)) {
     return true;
   }
-  if (t50.isMemberExpression(node)) {
-    return isSimpleExpression(node.object) && t50.isIdentifier(node.property);
+  if (t53.isMemberExpression(node)) {
+    return isSimpleExpression(node.object) && t53.isIdentifier(node.property);
   }
-  if (t50.isObjectExpression(node) || t50.isArrayExpression(node)) {
+  if (t53.isObjectExpression(node) || t53.isArrayExpression(node)) {
     return false;
   }
-  if (t50.isCallExpression(node) || t50.isAssignmentExpression(node)) {
+  if (t53.isCallExpression(node) || t53.isAssignmentExpression(node)) {
     return false;
   }
-  if (t50.isBinaryExpression(node) || t50.isUnaryExpression(node)) {
+  if (t53.isBinaryExpression(node) || t53.isUnaryExpression(node)) {
     return true;
   }
   return false;
 }
-function isIdentifier29(code) {
+function isIdentifier32(code) {
   try {
     const node = parseExpression3(code);
-    return t50.isIdentifier(node);
+    return t53.isIdentifier(node);
   } catch {
     return false;
   }
 }
-function isStringLiteral13(code) {
+function isStringLiteral15(code) {
   try {
     const node = parseExpression3(code);
-    return t50.isStringLiteral(node);
+    return t53.isStringLiteral(node);
   } catch {
     return false;
   }
@@ -5530,11 +5932,11 @@ function resolvePropAsBabelExp(ir, ctx) {
   const rule = ADAPTER_RULES.runtime;
   const setNameIdentifier = (target, valueName) => {
     target.content = valueName;
-    target.ast = t51.jsxIdentifier(valueName);
+    target.ast = t54.jsxIdentifier(valueName);
   };
-  const setValueExpression = (target, content, isStringLiteral14) => {
+  const setValueExpression = (target, content, isStringLiteral16) => {
     target.content = content;
-    target.ast = resolveStringExpr(content, ctx, isStringLiteral14);
+    target.ast = resolveStringExpr(content, ctx, isStringLiteral16);
   };
   const createRuntimeCall = (fnName, args) => {
     const fnArgs = args.filter(Boolean).join(",");
@@ -5543,13 +5945,13 @@ function resolvePropAsBabelExp(ir, ctx) {
     const safeTypeAssertion = isTs ? valIsUndef ? "as never" : "" : "";
     return `${fnName}(${fnArgs}) ${safeTypeAssertion}`;
   };
-  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral14) => {
+  const applyRuntimeExpression = (expression, setName = false, nameIdentifier, isStringLiteral16) => {
     if (setName && nameIdentifier) {
       setNameIdentifier(nameExp, nameIdentifier);
     }
     const dir = rule.dir;
     recordImport(ctx, dir.package, dir.target);
-    setValueExpression(value.babelExp, expression, isStringLiteral14);
+    setValueExpression(value.babelExp, expression, isStringLiteral16);
   };
   if (ir.isKeyLessVBind) {
     const dirKeyless = rule.dirKeyless;
@@ -5970,12 +6372,12 @@ function resolvePropertyIR(propsIR, ir, ctx, nodeIR, isDynamic = false) {
     content = propsIR.value.content = parseStyleString(content);
   }
   if (isDynamic) {
-    const isStringLiteral14 = strCodeTypes.isStringLiteral(content);
-    if (isStringLiteral14) {
+    const isStringLiteral16 = strCodeTypes.isStringLiteral(content);
+    if (isStringLiteral16) {
       content = normalizeString(content);
       propsIR.value.content = content;
     }
-    propsIR.value.isStringLiteral = isStringLiteral14;
+    propsIR.value.isStringLiteral = isStringLiteral16;
   }
   const existing = findSameProp(nodeIR.props, propsIR);
   if (existing) {
@@ -6280,7 +6682,7 @@ function applyValueModifiers(valueExp, modifiers) {
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-on.ts
-import * as t52 from "@babel/types";
+import * as t55 from "@babel/types";
 function resolveVOn(directive, ir, ctx, nodeIR) {
   const arg = directive.arg;
   const exp = directive.exp;
@@ -6338,10 +6740,10 @@ function resolveHandler(handlerContent, ctx, modifiers) {
   return handler;
 }
 function isConsoleCall(expr) {
-  return t52.isCallExpression(expr) && t52.isMemberExpression(expr.callee) && t52.isIdentifier(expr.callee.object) && expr.callee.object.name === "console";
+  return t55.isCallExpression(expr) && t55.isMemberExpression(expr.callee) && t55.isIdentifier(expr.callee.object) && expr.callee.object.name === "console";
 }
 function isFnReference(expr) {
-  return t52.isIdentifier(expr) || t52.isMemberExpression(expr) || t52.isFunction(expr);
+  return t55.isIdentifier(expr) || t55.isMemberExpression(expr) || t55.isFunction(expr);
 }
 
 // src/core/transform/sfc/template/syntax-processor/process/props/resolve-v-show.ts
@@ -6694,7 +7096,7 @@ function transform(ast, ctx, options) {
 }
 
 // package.json
-var version = "1.8.5";
+var version = "1.10.0";
 var bin = {
   vureact: "bin/vureact.js"
 };
@@ -7248,7 +7650,8 @@ var CompilationContext = class {
           refField: "expose"
         },
         declaredOptions: {},
-        source: ""
+        source: "",
+        __vureact_script_block_ir: void 0
       },
       styleData: {
         filePath: ""
@@ -8376,9 +8779,11 @@ var FileCompiler = class extends BaseCompiler {
       startTime = performance.now();
       this.updateSpinner("Scanning files...");
       const scanFiles = fileProcessor.scanFiles();
-      this.updateSpinner("Compiling Vue to React...");
+      this.updateSpinner("Compiling components...");
       const sfcCount = await pipelineManager.runSFC(scanFiles.vue, cacheMap);
+      this.updateSpinner("Compiling scripts...");
       const scriptCount = await pipelineManager.runScript(scanFiles.script, cacheMap);
+      this.updateSpinner("Compiling styles...");
       const styleCount = await pipelineManager.runStyle(scanFiles.style, cacheMap);
       this.updateSpinner("Copying assets...");
       const assetCount = await assetManager.runAsset(scanFiles.assets, cacheMap);
@@ -8436,7 +8841,7 @@ var FileCompiler = class extends BaseCompiler {
     return await this.manager.cleanupManager.removeOutputPath(targetPath, type);
   }
   showCompileStats(endTime, sfcCount, scriptCount, styleCount, assetCount) {
-    this.spinner.succeed(`Build completed in ${endTime}`);
+    this.spinner.succeed(`Vue compiled to React in ${endTime}`);
     if (sfcCount || scriptCount || styleCount || assetCount) {
       const stats = [];
       if (sfcCount) stats.push(`${sfcCount} ${kleur8.dim("SFC(s)")}`);