diff --git a/crates/fervid/benches/codegen_bench.rs b/crates/fervid/benches/codegen_bench.rs
index 91ac838..fd0e17d 100644
--- a/crates/fervid/benches/codegen_bench.rs
+++ b/crates/fervid/benches/codegen_bench.rs
@@ -15,8 +15,8 @@ fn codegen_benchmark(c: &mut Criterion) {
                 panic!("Test component has no template block");
             };
 
-            let mut scope_helper = fervid_transform::structs::ScopeHelper::default();
-            fervid_transform::template::transform_and_record_template(template_block, &mut scope_helper);
+            let mut bindings_helper = fervid_transform::structs::BindingsHelper::default();
+            fervid_transform::template::transform_and_record_template(template_block, &mut bindings_helper);
 
             b.iter_batched(
                 || template_block.clone(),
diff --git a/crates/fervid_codegen/src/imports/mod.rs b/crates/fervid_codegen/src/imports/mod.rs
index 81817a1..b2ef00f 100644
--- a/crates/fervid_codegen/src/imports/mod.rs
+++ b/crates/fervid_codegen/src/imports/mod.rs
@@ -17,55 +17,14 @@ impl CodegenContext {
         self.used_imports |= vue_import;
     }
 
-    pub fn get_import_str(vue_import: VueImports) -> &'static str {
-        match vue_import {
-            VueImports::CreateBlock => "_createBlock",
-            VueImports::CreateCommentVNode => "_createCommentVNode",
-            VueImports::CreateElementBlock => "_createElementBlock",
-            VueImports::CreateElementVNode => "_createElementVNode",
-            VueImports::CreateTextVNode => "_createTextVNode",
-            VueImports::CreateVNode => "_createVNode",
-            VueImports::Fragment => "_Fragment",
-            VueImports::KeepAlive => "_KeepAlive",
-            VueImports::MergeModels => "_mergeModels",
-            VueImports::NormalizeClass => "_normalizeClass",
-            VueImports::NormalizeStyle => "_normalizeStyle",
-            VueImports::OpenBlock => "_openBlock",
-            VueImports::RenderList => "_renderList",
-            VueImports::RenderSlot => "_renderSlot",
-            VueImports::ResolveComponent => "_resolveComponent",
-            VueImports::ResolveDirective => "_resolveDirective",
-            VueImports::ResolveDynamicComponent => "_resolveDynamicComponent",
-            VueImports::Suspense => "_Suspense",
-            VueImports::Teleport => "_Teleport",
-            VueImports::ToDisplayString => "_toDisplayString",
-            VueImports::Transition => "_Transition",
-            VueImports::TransitionGroup => "_TransitionGroup",
-            VueImports::UseModel => "_useModel",
-            VueImports::VModelCheckbox => "_vModelCheckbox",
-            VueImports::VModelDynamic => "_vModelDynamic",
-            VueImports::VModelRadio => "_vModelRadio",
-            VueImports::VModelSelect => "_vModelSelect",
-            VueImports::VModelText => "_vModelText",
-            VueImports::VShow => "_vShow",
-            VueImports::WithCtx => "_withCtx",
-            VueImports::WithDirectives => "_withDirectives",
-            VueImports::WithModifiers => "_withModifiers",
-        }
-    }
-
-    pub fn get_import_ident(vue_import: VueImports) -> JsWord {
-        JsWord::from(Self::get_import_str(vue_import))
-    }
-
     pub fn get_and_add_import_str(&mut self, vue_import: VueImports) -> &'static str {
         self.add_to_imports(vue_import);
-        Self::get_import_str(vue_import)
+        vue_import.as_str()
     }
 
     pub fn get_and_add_import_ident(&mut self, vue_import: VueImports) -> JsWord {
         self.add_to_imports(vue_import);
-        Self::get_import_ident(vue_import)
+        vue_import.as_atom()
     }
 
     /// Generates all the imports used by template generation.
@@ -73,11 +32,11 @@ impl CodegenContext {
     pub fn generate_imports(&self) -> Vec<ImportSpecifier> {
         let mut result = Vec::new();
         for import in self.used_imports.into_iter() {
-            let import_raw = Self::get_import_str(import);
+            let import_raw = import.as_str();
 
             let import_local = Ident {
                 span: DUMMY_SP,
-                sym: JsWord::from(import_raw),
+                sym: import.as_atom(),
                 optional: false,
             };
 
diff --git a/crates/fervid_core/src/vue_imports.rs b/crates/fervid_core/src/vue_imports.rs
index 222abe8..624116a 100644
--- a/crates/fervid_core/src/vue_imports.rs
+++ b/crates/fervid_core/src/vue_imports.rs
@@ -1,5 +1,7 @@
 use flagset::{flags, FlagSet};
 
+use crate::FervidAtom;
+
 flags! {
     // #[derive(Clone, Copy)]
     pub enum VueImports: u64 {
@@ -25,6 +27,7 @@ flags! {
         ToDisplayString,
         Transition,
         TransitionGroup,
+        Unref,
         UseModel,
         VModelCheckbox,
         VModelDynamic,
@@ -38,4 +41,50 @@ flags! {
     }
 }
 
+impl VueImports {
+    #[inline]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            VueImports::CreateBlock => "_createBlock",
+            VueImports::CreateCommentVNode => "_createCommentVNode",
+            VueImports::CreateElementBlock => "_createElementBlock",
+            VueImports::CreateElementVNode => "_createElementVNode",
+            VueImports::CreateTextVNode => "_createTextVNode",
+            VueImports::CreateVNode => "_createVNode",
+            VueImports::Fragment => "_Fragment",
+            VueImports::KeepAlive => "_KeepAlive",
+            VueImports::MergeModels => "_mergeModels",
+            VueImports::NormalizeClass => "_normalizeClass",
+            VueImports::NormalizeStyle => "_normalizeStyle",
+            VueImports::OpenBlock => "_openBlock",
+            VueImports::RenderList => "_renderList",
+            VueImports::RenderSlot => "_renderSlot",
+            VueImports::ResolveComponent => "_resolveComponent",
+            VueImports::ResolveDirective => "_resolveDirective",
+            VueImports::ResolveDynamicComponent => "_resolveDynamicComponent",
+            VueImports::Suspense => "_Suspense",
+            VueImports::Teleport => "_Teleport",
+            VueImports::ToDisplayString => "_toDisplayString",
+            VueImports::Transition => "_Transition",
+            VueImports::TransitionGroup => "_TransitionGroup",
+            VueImports::Unref => "_unref",
+            VueImports::UseModel => "_useModel",
+            VueImports::VModelCheckbox => "_vModelCheckbox",
+            VueImports::VModelDynamic => "_vModelDynamic",
+            VueImports::VModelRadio => "_vModelRadio",
+            VueImports::VModelSelect => "_vModelSelect",
+            VueImports::VModelText => "_vModelText",
+            VueImports::VShow => "_vShow",
+            VueImports::WithCtx => "_withCtx",
+            VueImports::WithDirectives => "_withDirectives",
+            VueImports::WithModifiers => "_withModifiers",
+        }
+    }
+
+    #[inline]
+    pub fn as_atom(self) -> FervidAtom {
+        self.as_str().into()
+    }
+}
+
 pub type VueImportsSet = FlagSet<VueImports>;
diff --git a/crates/fervid_transform/src/lib.rs b/crates/fervid_transform/src/lib.rs
index 597739c..0edd9de 100644
--- a/crates/fervid_transform/src/lib.rs
+++ b/crates/fervid_transform/src/lib.rs
@@ -1,7 +1,7 @@
 use fervid_core::{SfcDescriptor, SfcTemplateBlock, VueImportsSet, BindingTypes, FervidAtom, TemplateGenerationMode};
 use fxhash::FxHashMap as HashMap;
 use script::transform_and_record_scripts;
-use structs::ScopeHelper;
+use structs::BindingsHelper;
 use swc_core::ecma::ast::{Module, ObjectLit, Function};
 use template::transform_and_record_template;
 
@@ -41,15 +41,15 @@ pub struct TransformSfcResult {
 pub fn transform_sfc(sfc_descriptor: SfcDescriptor) -> TransformSfcResult {
     let mut template_block = None;
 
-    let mut scope_helper = ScopeHelper::default();
+    let mut bindings_helper = BindingsHelper::default();
     let transform_result = transform_and_record_scripts(
         sfc_descriptor.script_setup,
         sfc_descriptor.script_legacy,
-        &mut scope_helper,
+        &mut bindings_helper,
     );
 
     if let Some(mut template) = sfc_descriptor.template {
-        transform_and_record_template(&mut template, &mut scope_helper);
+        transform_and_record_template(&mut template, &mut bindings_helper);
         template_block = Some(template);
     }
 
@@ -58,8 +58,8 @@ pub fn transform_sfc(sfc_descriptor: SfcDescriptor) -> TransformSfcResult {
         module: transform_result.module,
         setup_fn: transform_result.setup_fn,
         template_block,
-        template_generation_mode: scope_helper.template_generation_mode,
-        used_idents: scope_helper.used_idents,
-        used_vue_imports: transform_result.added_imports,
+        template_generation_mode: bindings_helper.template_generation_mode,
+        used_idents: bindings_helper.used_bindings,
+        used_vue_imports: bindings_helper.vue_imports,
     }
 }
diff --git a/crates/fervid_transform/src/script.rs b/crates/fervid_transform/src/script.rs
index 70cc92e..c9846cd 100644
--- a/crates/fervid_transform/src/script.rs
+++ b/crates/fervid_transform/src/script.rs
@@ -1,6 +1,6 @@
 //! Responsible for `<script>` and `<script setup>` transformations and analysis.
 
-use fervid_core::{SfcScriptBlock, VueImportsSet, TemplateGenerationMode};
+use fervid_core::{SfcScriptBlock, TemplateGenerationMode};
 use swc_core::{
     common::DUMMY_SP,
     ecma::ast::{
@@ -8,7 +8,7 @@ use swc_core::{
     },
 };
 
-use crate::structs::{ScopeHelper, TransformScriptsResult};
+use crate::structs::{BindingsHelper, TransformScriptsResult};
 
 use self::{
     options_api::{transform_and_record_script_options_api, AnalyzeOptions},
@@ -25,18 +25,18 @@ pub mod utils;
 ///
 /// Consumes both [`SfcScriptBlock`]s to avoid cloning.
 ///
-/// It will populate the provided [`ScopeHelper`] with the analysis information, such as:
+/// It will populate the provided [`BindingsHelper`] with the analysis information, such as:
 /// - Variable bindings (from `<script setup>` and from Options API);
 /// - Import bindings;
 /// - (TODO) Imported `.vue` component bindings;
 pub fn transform_and_record_scripts(
     script_setup: Option<SfcScriptBlock>,
     script_legacy: Option<SfcScriptBlock>,
-    scope_helper: &mut ScopeHelper,
+    bindings_helper: &mut BindingsHelper,
 ) -> TransformScriptsResult {
-    // Set inline flag in `ScopeHelper`
+    // Set inline flag in `BindingsHelper`
     if script_legacy.is_none() && script_setup.is_some() {
-        scope_helper.template_generation_mode = TemplateGenerationMode::Inline;
+        bindings_helper.template_generation_mode = TemplateGenerationMode::Inline;
     }
 
     //
@@ -56,7 +56,7 @@ pub fn transform_and_record_scripts(
         transform_and_record_script_options_api(&mut module, AnalyzeOptions::default());
 
     // Assign Options API bindings
-    scope_helper.options_api_vars = Some(script_options_transform_result.vars);
+    bindings_helper.options_api_bindings = Some(script_options_transform_result.vars);
 
     //
     // STEP 2: Prepare the exported object.
@@ -74,9 +74,8 @@ pub fn transform_and_record_scripts(
     //
 
     let mut setup_fn: Option<Box<Function>> = None;
-    let mut added_imports = VueImportsSet::default();
     if let Some(script_setup) = script_setup {
-        let setup_transform_result = transform_and_record_script_setup(script_setup, scope_helper);
+        let setup_transform_result = transform_and_record_script_setup(script_setup, bindings_helper);
 
         // TODO Push imports at module top or bottom? Or smart merge?
         // TODO Merge Vue imports produced by module transformation
@@ -86,7 +85,6 @@ pub fn transform_and_record_scripts(
         }
 
         // Merge fields into an SFC exported object
-        added_imports = setup_transform_result.sfc_object_helper.vue_imports;
         merge_sfc_helper(setup_transform_result.sfc_object_helper, &mut export_obj.props);
 
         // TODO Adding bindings to `setup()` in Options API will get overwritten in `<script setup>`
@@ -95,7 +93,6 @@ pub fn transform_and_record_scripts(
     }
 
     TransformScriptsResult {
-        added_imports,
         module,
         export_obj,
         setup_fn,
diff --git a/crates/fervid_transform/src/script/setup.rs b/crates/fervid_transform/src/script/setup.rs
index 00ab297..fe59a1c 100644
--- a/crates/fervid_transform/src/script/setup.rs
+++ b/crates/fervid_transform/src/script/setup.rs
@@ -2,14 +2,14 @@ use fervid_core::SfcScriptBlock;
 use swc_core::{
     common::DUMMY_SP,
     ecma::ast::{
-        BindingIdent, BlockStmt, Function, Id, Ident, KeyValuePatProp, ModuleDecl, ModuleItem,
-        ObjectPat, ObjectPatProp, Param, Pat, Stmt, PropOrSpread, KeyValueProp, Prop, PropName,
+        BindingIdent, BlockStmt, Function, Id, Ident, KeyValuePatProp, KeyValueProp, ModuleDecl,
+        ModuleItem, ObjectPat, ObjectPatProp, Param, Pat, Prop, PropName, PropOrSpread, Stmt,
     },
 };
 
 use crate::{
-    atoms::{EMIT, EMIT_HELPER, EXPOSE, EXPOSE_HELPER, PROPS_HELPER, EMITS, PROPS},
-    structs::{ScopeHelper, SfcExportedObjectHelper, VueResolvedImports},
+    atoms::{EMIT, EMITS, EMIT_HELPER, EXPOSE, EXPOSE_HELPER, PROPS, PROPS_HELPER},
+    structs::{BindingsHelper, SfcExportedObjectHelper, VueResolvedImports},
 };
 
 mod imports;
@@ -32,14 +32,14 @@ pub struct TransformScriptSetupResult {
 
 pub fn transform_and_record_script_setup(
     script_setup: SfcScriptBlock,
-    scope_helper: &mut ScopeHelper,
+    bindings_helper: &mut BindingsHelper,
 ) -> TransformScriptSetupResult {
     let span = DUMMY_SP; // TODO
 
     let mut module_decls = Vec::<ModuleDecl>::new();
     let mut sfc_object_helper = SfcExportedObjectHelper::default();
 
-    let mut vue_imports = VueResolvedImports::default();
+    let mut vue_user_imports = VueResolvedImports::default();
     let mut imports = Vec::<Id>::new();
     let mut setup_body_stmts = Vec::<Stmt>::new();
 
@@ -50,7 +50,7 @@ pub fn transform_and_record_script_setup(
                 // Collect Vue imports
                 // TODO And maybe non-Vue as well?
                 if let ModuleDecl::Import(ref import_decl) = decl {
-                    collect_imports(import_decl, &mut imports, &mut vue_imports);
+                    collect_imports(import_decl, &mut imports, &mut vue_user_imports);
                 }
 
                 module_decls.push(decl);
@@ -59,8 +59,8 @@ pub fn transform_and_record_script_setup(
             ModuleItem::Stmt(stmt) => {
                 if let Some(transformed_stmt) = transform_and_record_stmt(
                     stmt,
-                    &mut scope_helper.setup_bindings,
-                    &vue_imports,
+                    bindings_helper,
+                    &vue_user_imports,
                     &mut sfc_object_helper,
                 ) {
                     setup_body_stmts.push(transformed_stmt);
@@ -70,7 +70,7 @@ pub fn transform_and_record_script_setup(
     }
 
     // Post-process macros, e.g. merge models to `props` and `emits`
-    postprocess_macros(&mut sfc_object_helper);
+    postprocess_macros(bindings_helper, &mut sfc_object_helper);
 
     // Should we check that this function was not assigned anywhere else?
     let setup_fn = Some(Box::new(Function {
@@ -106,7 +106,7 @@ pub fn merge_sfc_helper(sfc_helper: SfcExportedObjectHelper, dest: &mut Vec<Prop
                     }),
                     value,
                 }))));
-            }        
+            }
         };
     }
 
@@ -118,7 +118,8 @@ pub fn merge_sfc_helper(sfc_helper: SfcExportedObjectHelper, dest: &mut Vec<Prop
 
 /// Used to populate the params to `setup()`, such as `__props`, `emit`, etc.
 fn get_setup_fn_params(sfc_object_helper: &SfcExportedObjectHelper) -> Vec<Param> {
-    let has_ctx_param = sfc_object_helper.is_setup_emit_referenced || sfc_object_helper.is_setup_expose_referenced;
+    let has_ctx_param =
+        sfc_object_helper.is_setup_emit_referenced || sfc_object_helper.is_setup_expose_referenced;
     let has_props = sfc_object_helper.is_setup_props_referenced || has_ctx_param;
 
     let result_len = (has_props as usize) + (has_ctx_param as usize);
@@ -187,178 +188,52 @@ fn get_setup_fn_params(sfc_object_helper: &SfcExportedObjectHelper) -> Vec<Param
 #[cfg(test)]
 mod tests {
     use crate::{
-        script::setup::{collect_imports, transform_and_record_stmt},
-        structs::{SetupBinding, VueResolvedImports},
+        structs::{BindingsHelper, SetupBinding},
         test_utils::parser::*,
     };
-    use fervid_core::BindingTypes;
-    use swc_core::{
-        common::SyntaxContext,
-        ecma::{
-            ast::{Id, Module, ModuleDecl, ModuleItem},
-            atoms::JsWord,
-        },
-    };
+    use fervid_core::{BindingTypes, SfcScriptBlock};
+    use swc_core::ecma::atoms::JsWord;
 
-    #[derive(Debug, Default, PartialEq)]
-    struct MockAnalysisResult {
-        imports: Vec<Id>,
-        vue_imports: VueResolvedImports,
-        setup: Vec<SetupBinding>,
-    }
+    use super::transform_and_record_script_setup;
 
-    fn analyze_mock(module: Module) -> MockAnalysisResult {
-        let mut imports = Vec::new();
-        let mut vue_imports = VueResolvedImports::default();
-        let mut setup = Vec::new();
-        let mut sfc_object = Default::default();
-
-        for module_item in module.body.into_iter() {
-            match module_item {
-                ModuleItem::ModuleDecl(ModuleDecl::Import(ref import_decl)) => {
-                    collect_imports(import_decl, &mut imports, &mut vue_imports)
-                }
+    fn analyze_bindings(script_setup: SfcScriptBlock) -> Vec<SetupBinding> {
+        let mut bindings_helper = BindingsHelper::default();
+        transform_and_record_script_setup(script_setup, &mut bindings_helper);
 
-                ModuleItem::Stmt(stmt) => {
-                    transform_and_record_stmt(stmt, &mut setup, &mut vue_imports, &mut sfc_object);
-                }
-
-                // Exports are ignored (ModuleDecl::Export* and ModuleDecl::Ts*)
-                _ => {}
-            }
-        }
-
-        MockAnalysisResult {
-            imports,
-            vue_imports,
-            setup,
-        }
+        bindings_helper.setup_bindings
     }
 
-    fn analyze_js(input: &str) -> MockAnalysisResult {
+    fn analyze_js_bindings(input: &str) -> Vec<SetupBinding> {
         let parsed = parse_javascript_module(input, 0, Default::default())
             .expect("analyze_js expects the input to be parseable")
             .0;
 
-        analyze_mock(parsed)
+        analyze_bindings(SfcScriptBlock {
+            content: Box::new(parsed),
+            lang: fervid_core::SfcScriptLang::Es,
+            is_setup: true,
+        })
     }
 
-    fn analyze_ts(input: &str) -> MockAnalysisResult {
+    fn analyze_ts_bindings(input: &str) -> Vec<SetupBinding> {
         let parsed = parse_typescript_module(input, 0, Default::default())
             .expect("analyze_ts expects the input to be parseable")
             .0;
 
-        analyze_mock(parsed)
+        analyze_bindings(SfcScriptBlock {
+            content: Box::new(parsed),
+            lang: fervid_core::SfcScriptLang::Typescript,
+            is_setup: true,
+        })
     }
 
     macro_rules! test_js_and_ts {
         ($input: expr, $expected: expr) => {
-            assert_eq!(analyze_js($input), $expected);
-            assert_eq!(analyze_ts($input), $expected);
+            assert_eq!(analyze_js_bindings($input), $expected);
+            assert_eq!(analyze_ts_bindings($input), $expected);
         };
     }
 
-    #[test]
-    fn it_collects_vue_imports() {
-        test_js_and_ts!(
-            r"
-            import { ref, computed, reactive } from 'vue'
-            ",
-            MockAnalysisResult {
-                vue_imports: VueResolvedImports {
-                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
-                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
-                    reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
-                },
-                ..Default::default()
-            }
-        );
-
-        // Aliased
-        test_js_and_ts!(
-            r"
-            import { ref as foo, computed as bar, reactive as baz } from 'vue'
-            ",
-            MockAnalysisResult {
-                vue_imports: VueResolvedImports {
-                    ref_import: Some((JsWord::from("foo"), SyntaxContext::default())),
-                    computed: Some((JsWord::from("bar"), SyntaxContext::default())),
-                    reactive: Some((JsWord::from("baz"), SyntaxContext::default()))
-                },
-                ..Default::default()
-            }
-        );
-    }
-
-    #[test]
-    fn it_collects_non_vue_imports() {
-        test_js_and_ts!(
-            r"
-            import { ref } from './vue'
-            import { computed } from 'vue-impostor'
-            import { reactive } from 'vue/internals'
-
-            import * as foo from './foo'
-            import Bar from 'bar-js'
-            import { baz, qux } from '@loremipsum/core'
-            ",
-            MockAnalysisResult {
-                imports: vec![
-                    (JsWord::from("ref"), SyntaxContext::default()),
-                    (JsWord::from("computed"), SyntaxContext::default()),
-                    (JsWord::from("reactive"), SyntaxContext::default()),
-                    (JsWord::from("foo"), SyntaxContext::default()),
-                    (JsWord::from("Bar"), SyntaxContext::default()),
-                    (JsWord::from("baz"), SyntaxContext::default()),
-                    (JsWord::from("qux"), SyntaxContext::default()),
-                ],
-                ..Default::default()
-            }
-        );
-    }
-
-    #[test]
-    fn it_collects_mixed_imports() {
-        test_js_and_ts!(
-            r"
-            import { ref, computed, reactive } from 'vue'
-
-            import * as foo from './foo'
-            import Bar from 'bar-js'
-            import { baz, qux } from '@loremipsum/core'
-            ",
-            MockAnalysisResult {
-                imports: vec![
-                    (JsWord::from("foo"), SyntaxContext::default()),
-                    (JsWord::from("Bar"), SyntaxContext::default()),
-                    (JsWord::from("baz"), SyntaxContext::default()),
-                    (JsWord::from("qux"), SyntaxContext::default()),
-                ],
-                vue_imports: VueResolvedImports {
-                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
-                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
-                    reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
-                },
-                ..Default::default()
-            }
-        );
-    }
-
-    #[test]
-    fn it_ignores_type_imports() {
-        assert_eq!(
-            analyze_ts(
-                r"
-            import type { ref } from 'vue'
-            import type { foo } from './foo'
-            import { type computed } from 'vue'
-            import { type baz, type qux } from 'baz'
-            "
-            ),
-            MockAnalysisResult::default()
-        )
-    }
-
     #[test]
     fn it_collects_refs() {
         test_js_and_ts!(
@@ -370,20 +245,17 @@ mod tests {
             const baz = computed()
             const qux = computed(() => 42)
             ",
-            MockAnalysisResult {
-                setup: vec![
-                    SetupBinding(JsWord::from("foo"), BindingTypes::SetupRef),
-                    SetupBinding(JsWord::from("bar"), BindingTypes::SetupRef),
-                    SetupBinding(JsWord::from("baz"), BindingTypes::SetupRef),
-                    SetupBinding(JsWord::from("qux"), BindingTypes::SetupRef),
-                ],
-                vue_imports: VueResolvedImports {
-                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
-                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
-                    reactive: None
-                },
-                ..Default::default()
-            }
+            vec![
+                SetupBinding(JsWord::from("foo"), BindingTypes::SetupRef),
+                SetupBinding(JsWord::from("bar"), BindingTypes::SetupRef),
+                SetupBinding(JsWord::from("baz"), BindingTypes::SetupRef),
+                SetupBinding(JsWord::from("qux"), BindingTypes::SetupRef),
+            ]
+            // vue_imports: VueResolvedImports {
+            //     ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
+            //     computed: Some((JsWord::from("computed"), SyntaxContext::default())),
+            //     reactive: None
+            // },
         );
     }
 
@@ -402,29 +274,26 @@ mod tests {
             const rea = reactive()
             const reb = reactive({})
             ",
-            MockAnalysisResult {
-                imports: vec![
-                    (JsWord::from("ref"), SyntaxContext::default()),
-                    (JsWord::from("computed"), SyntaxContext::default()),
-                    (JsWord::from("reactive"), SyntaxContext::default()),
-                ],
-                setup: vec![
-                    SetupBinding(JsWord::from("foo"), BindingTypes::SetupMaybeRef),
-                    SetupBinding(JsWord::from("bar"), BindingTypes::SetupMaybeRef),
-                    SetupBinding(JsWord::from("baz"), BindingTypes::SetupMaybeRef),
-                    SetupBinding(JsWord::from("qux"), BindingTypes::SetupMaybeRef),
-                    SetupBinding(JsWord::from("rea"), BindingTypes::SetupMaybeRef),
-                    SetupBinding(JsWord::from("reb"), BindingTypes::SetupMaybeRef),
-                ],
-                ..Default::default()
-            }
+            // imports: vec![
+            //     (JsWord::from("ref"), SyntaxContext::default()),
+            //     (JsWord::from("computed"), SyntaxContext::default()),
+            //     (JsWord::from("reactive"), SyntaxContext::default()),
+            // ],
+            vec![
+                SetupBinding(JsWord::from("foo"), BindingTypes::SetupMaybeRef),
+                SetupBinding(JsWord::from("bar"), BindingTypes::SetupMaybeRef),
+                SetupBinding(JsWord::from("baz"), BindingTypes::SetupMaybeRef),
+                SetupBinding(JsWord::from("qux"), BindingTypes::SetupMaybeRef),
+                SetupBinding(JsWord::from("rea"), BindingTypes::SetupMaybeRef),
+                SetupBinding(JsWord::from("reb"), BindingTypes::SetupMaybeRef),
+            ]
         );
     }
 
     #[test]
     fn it_supports_ts_enums() {
         assert_eq!(
-            analyze_ts(
+            analyze_ts_bindings(
                 r"
             enum Foo {}
             const enum Bar {
@@ -442,15 +311,12 @@ mod tests {
             }
             "
             ),
-            MockAnalysisResult {
-                setup: vec![
-                    SetupBinding(JsWord::from("Foo"), BindingTypes::LiteralConst),
-                    SetupBinding(JsWord::from("Bar"), BindingTypes::LiteralConst),
-                    SetupBinding(JsWord::from("Baz"), BindingTypes::LiteralConst),
-                    SetupBinding(JsWord::from("Qux"), BindingTypes::LiteralConst),
-                ],
-                ..Default::default()
-            }
+            vec![
+                SetupBinding(JsWord::from("Foo"), BindingTypes::LiteralConst),
+                SetupBinding(JsWord::from("Bar"), BindingTypes::LiteralConst),
+                SetupBinding(JsWord::from("Baz"), BindingTypes::LiteralConst),
+                SetupBinding(JsWord::from("Qux"), BindingTypes::LiteralConst),
+            ]
         )
     }
 
@@ -475,25 +341,22 @@ mod tests {
                 varBar = computed(() => 42),
                 varBaz = reactive({ qux: true })
             ",
-            MockAnalysisResult {
-                vue_imports: VueResolvedImports {
-                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
-                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
-                    reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
-                },
-                setup: vec![
-                    SetupBinding(JsWord::from("cstFoo"), BindingTypes::SetupRef),
-                    SetupBinding(JsWord::from("cstBar"), BindingTypes::SetupRef),
-                    SetupBinding(JsWord::from("cstBaz"), BindingTypes::SetupReactiveConst),
-                    SetupBinding(JsWord::from("letFoo"), BindingTypes::SetupLet),
-                    SetupBinding(JsWord::from("letBar"), BindingTypes::SetupLet),
-                    SetupBinding(JsWord::from("letBaz"), BindingTypes::SetupLet),
-                    SetupBinding(JsWord::from("varFoo"), BindingTypes::SetupLet),
-                    SetupBinding(JsWord::from("varBar"), BindingTypes::SetupLet),
-                    SetupBinding(JsWord::from("varBaz"), BindingTypes::SetupLet),
-                ],
-                ..Default::default()
-            }
+            // vue_imports: VueResolvedImports {
+            //     ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
+            //     computed: Some((JsWord::from("computed"), SyntaxContext::default())),
+            //     reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
+            // },
+            vec![
+                SetupBinding(JsWord::from("cstFoo"), BindingTypes::SetupRef),
+                SetupBinding(JsWord::from("cstBar"), BindingTypes::SetupRef),
+                SetupBinding(JsWord::from("cstBaz"), BindingTypes::SetupReactiveConst),
+                SetupBinding(JsWord::from("letFoo"), BindingTypes::SetupLet),
+                SetupBinding(JsWord::from("letBar"), BindingTypes::SetupLet),
+                SetupBinding(JsWord::from("letBaz"), BindingTypes::SetupLet),
+                SetupBinding(JsWord::from("varFoo"), BindingTypes::SetupLet),
+                SetupBinding(JsWord::from("varBar"), BindingTypes::SetupLet),
+                SetupBinding(JsWord::from("varBaz"), BindingTypes::SetupLet),
+            ]
         );
     }
 }
diff --git a/crates/fervid_transform/src/script/setup/imports.rs b/crates/fervid_transform/src/script/setup/imports.rs
index 94ad207..5a17fa9 100644
--- a/crates/fervid_transform/src/script/setup/imports.rs
+++ b/crates/fervid_transform/src/script/setup/imports.rs
@@ -67,3 +67,162 @@ fn collect_vue_import(imported_word: &JsWord, used_as: Id, vue_imports: &mut Vue
         vue_imports.reactive = Some(used_as)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use swc_core::{ecma::ast::{Module, ModuleDecl, ModuleItem}, common::SyntaxContext};
+
+    use crate::test_utils::parser::{parse_javascript_module, parse_typescript_module};
+
+    use super::*;
+
+    #[derive(Debug, Default, PartialEq)]
+    struct MockAnalysisResult {
+        imports: Vec<Id>,
+        vue_user_imports: VueResolvedImports,
+    }
+
+    fn analyze_mock(module: Module) -> MockAnalysisResult {
+        let mut imports = Vec::new();
+        let mut vue_user_imports = VueResolvedImports::default();
+
+        for module_item in module.body.into_iter() {
+            match module_item {
+                ModuleItem::ModuleDecl(ModuleDecl::Import(ref import_decl)) => {
+                    collect_imports(import_decl, &mut imports, &mut vue_user_imports)
+                }
+
+                _ => {}
+            }
+        }
+
+        MockAnalysisResult {
+            imports,
+            vue_user_imports,
+        }
+    }
+
+    fn analyze_js_imports(input: &str) -> MockAnalysisResult {
+        let parsed = parse_javascript_module(input, 0, Default::default())
+            .expect("analyze_js expects the input to be parseable")
+            .0;
+
+        analyze_mock(parsed)
+    }
+
+    fn analyze_ts_imports(input: &str) -> MockAnalysisResult {
+        let parsed = parse_typescript_module(input, 0, Default::default())
+            .expect("analyze_ts expects the input to be parseable")
+            .0;
+
+        analyze_mock(parsed)
+    }
+
+    macro_rules! test_js_and_ts {
+        ($input: expr, $expected: expr) => {
+            assert_eq!(analyze_js_imports($input), $expected);
+            assert_eq!(analyze_ts_imports($input), $expected);
+        };
+    }
+
+    #[test]
+    fn it_collects_vue_imports() {
+        test_js_and_ts!(
+            r"
+            import { ref, computed, reactive } from 'vue'
+            ",
+            MockAnalysisResult {
+                vue_user_imports: VueResolvedImports {
+                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
+                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
+                    reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
+                },
+                ..Default::default()
+            }
+        );
+
+        // Aliased
+        test_js_and_ts!(
+            r"
+            import { ref as foo, computed as bar, reactive as baz } from 'vue'
+            ",
+            MockAnalysisResult {
+                vue_user_imports: VueResolvedImports {
+                    ref_import: Some((JsWord::from("foo"), SyntaxContext::default())),
+                    computed: Some((JsWord::from("bar"), SyntaxContext::default())),
+                    reactive: Some((JsWord::from("baz"), SyntaxContext::default()))
+                },
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn it_collects_non_vue_imports() {
+        test_js_and_ts!(
+            r"
+            import { ref } from './vue'
+            import { computed } from 'vue-impostor'
+            import { reactive } from 'vue/internals'
+
+            import * as foo from './foo'
+            import Bar from 'bar-js'
+            import { baz, qux } from '@loremipsum/core'
+            ",
+            MockAnalysisResult {
+                imports: vec![
+                    (JsWord::from("ref"), SyntaxContext::default()),
+                    (JsWord::from("computed"), SyntaxContext::default()),
+                    (JsWord::from("reactive"), SyntaxContext::default()),
+                    (JsWord::from("foo"), SyntaxContext::default()),
+                    (JsWord::from("Bar"), SyntaxContext::default()),
+                    (JsWord::from("baz"), SyntaxContext::default()),
+                    (JsWord::from("qux"), SyntaxContext::default()),
+                ],
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn it_collects_mixed_imports() {
+        test_js_and_ts!(
+            r"
+            import { ref, computed, reactive } from 'vue'
+
+            import * as foo from './foo'
+            import Bar from 'bar-js'
+            import { baz, qux } from '@loremipsum/core'
+            ",
+            MockAnalysisResult {
+                imports: vec![
+                    (JsWord::from("foo"), SyntaxContext::default()),
+                    (JsWord::from("Bar"), SyntaxContext::default()),
+                    (JsWord::from("baz"), SyntaxContext::default()),
+                    (JsWord::from("qux"), SyntaxContext::default()),
+                ],
+                vue_user_imports: VueResolvedImports {
+                    ref_import: Some((JsWord::from("ref"), SyntaxContext::default())),
+                    computed: Some((JsWord::from("computed"), SyntaxContext::default())),
+                    reactive: Some((JsWord::from("reactive"), SyntaxContext::default()))
+                },
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn it_ignores_type_imports() {
+        assert_eq!(
+            analyze_ts_imports(
+                r"
+            import type { ref } from 'vue'
+            import type { foo } from './foo'
+            import { type computed } from 'vue'
+            import { type baz, type qux } from 'baz'
+            "
+            ),
+            MockAnalysisResult::default()
+        )
+    }
+}
diff --git a/crates/fervid_transform/src/script/setup/macros.rs b/crates/fervid_transform/src/script/setup/macros.rs
index 6bea55b..2757105 100644
--- a/crates/fervid_transform/src/script/setup/macros.rs
+++ b/crates/fervid_transform/src/script/setup/macros.rs
@@ -15,7 +15,7 @@ use crate::{
         DEFINE_EMITS, DEFINE_EXPOSE, DEFINE_MODEL, DEFINE_PROPS, EMIT_HELPER, EXPOSE_HELPER,
         MERGE_MODELS_HELPER, MODEL_VALUE, PROPS_HELPER, USE_MODEL_HELPER,
     },
-    structs::{SfcDefineModel, SfcExportedObjectHelper},
+    structs::{SfcDefineModel, SfcExportedObjectHelper, BindingsHelper},
 };
 
 /// Tries to transform a Vue compiler macro.\
@@ -25,6 +25,7 @@ use crate::{
 /// See https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits
 pub fn transform_script_setup_macro_expr(
     expr: &Expr,
+    bindings_helper: &mut BindingsHelper,
     sfc_object_helper: &mut SfcExportedObjectHelper,
     is_var_decl: bool,
 ) -> Option<Expr> {
@@ -112,7 +113,7 @@ pub fn transform_script_setup_macro_expr(
         let span = call_expr.span;
 
         // Add to imports
-        sfc_object_helper.vue_imports |= VueImports::UseModel;
+        bindings_helper.vue_imports |= VueImports::UseModel;
 
         let use_model_ident = Ident {
             span,
@@ -177,7 +178,7 @@ pub fn transform_script_setup_macro_expr(
 }
 
 /// Mainly used to process `models` by adding them to `props` and `emits`
-pub fn postprocess_macros(sfc_object_helper: &mut SfcExportedObjectHelper) {
+pub fn postprocess_macros(bindings_helper: &mut BindingsHelper, sfc_object_helper: &mut SfcExportedObjectHelper) {
     let len = sfc_object_helper.models.len();
     if len == 0 {
         return;
@@ -229,7 +230,7 @@ pub fn postprocess_macros(sfc_object_helper: &mut SfcExportedObjectHelper) {
                 sfc_object_helper.props = Some(existing_props);
             } else {
                 // Use `mergeModels` otherwise
-                sfc_object_helper.vue_imports |= VueImports::MergeModels;
+                bindings_helper.vue_imports |= VueImports::MergeModels;
                 let merge_models_ident = MERGE_MODELS_HELPER.to_owned();
 
                 let new_props = Expr::Call(CallExpr {
@@ -275,7 +276,7 @@ pub fn postprocess_macros(sfc_object_helper: &mut SfcExportedObjectHelper) {
                 sfc_object_helper.emits = Some(existing_emits);
             } else {
                 // Use `mergeModels` otherwise
-                sfc_object_helper.vue_imports |= VueImports::MergeModels;
+                bindings_helper.vue_imports |= VueImports::MergeModels;
                 let merge_models_ident = MERGE_MODELS_HELPER.to_owned();
 
                 let new_emits = Expr::Call(CallExpr {
diff --git a/crates/fervid_transform/src/script/setup/statements.rs b/crates/fervid_transform/src/script/setup/statements.rs
index bc87243..ac649b0 100644
--- a/crates/fervid_transform/src/script/setup/statements.rs
+++ b/crates/fervid_transform/src/script/setup/statements.rs
@@ -3,7 +3,7 @@ use swc_core::ecma::ast::{Decl, ExprStmt, Stmt, VarDeclKind};
 
 use crate::{
     script::common::{categorize_class, categorize_fn_decl, categorize_var_declarator},
-    structs::{SetupBinding, SfcExportedObjectHelper, VueResolvedImports},
+    structs::{BindingsHelper, SetupBinding, SfcExportedObjectHelper, VueResolvedImports},
 };
 
 use super::macros::transform_script_setup_macro_expr;
@@ -15,24 +15,30 @@ use super::macros::transform_script_setup_macro_expr;
 /// 3. The insides of `setup()` function in `<script>` Options API.
 pub fn transform_and_record_stmt(
     stmt: Stmt,
-    out: &mut Vec<SetupBinding>,
+    bindings_helper: &mut BindingsHelper,
     vue_imports: &VueResolvedImports,
     sfc_object_helper: &mut SfcExportedObjectHelper,
 ) -> Option<Stmt> {
     match stmt {
         Stmt::Expr(ref expr_stmt) => {
             let span = expr_stmt.span;
-            return transform_script_setup_macro_expr(&expr_stmt.expr, sfc_object_helper, false)
-                .map(|transformed| {
-                    Stmt::Expr(ExprStmt {
-                        span,
-                        expr: Box::new(transformed),
-                    })
-                });
+            return transform_script_setup_macro_expr(
+                &expr_stmt.expr,
+                bindings_helper,
+                sfc_object_helper,
+                false,
+            )
+            .map(|transformed| {
+                Stmt::Expr(ExprStmt {
+                    span,
+                    expr: Box::new(transformed),
+                })
+            });
         }
 
         Stmt::Decl(ref decl) => {
-            return transform_decl_stmt(decl, out, vue_imports, sfc_object_helper).map(Stmt::Decl);
+            return transform_decl_stmt(decl, bindings_helper, vue_imports, sfc_object_helper)
+                .map(Stmt::Decl);
         }
 
         _ => {}
@@ -46,14 +52,20 @@ pub fn transform_and_record_stmt(
 /// These are typically `var`/`let`/`const` declarations, function declarations, etc.
 fn transform_decl_stmt(
     decl: &Decl,
-    out: &mut Vec<SetupBinding>,
-    vue_imports: &VueResolvedImports,
+    bindings_helper: &mut BindingsHelper,
+    vue_user_imports: &VueResolvedImports,
     sfc_object_helper: &mut SfcExportedObjectHelper,
 ) -> Option<Decl> {
+    macro_rules! push {
+        ($binding: expr) => {
+            bindings_helper.setup_bindings.push($binding)
+        };
+    }
+
     match decl {
-        Decl::Class(class) => out.push(categorize_class(class)),
+        Decl::Class(class) => push!(categorize_class(class)),
 
-        Decl::Fn(fn_decl) => out.push(categorize_fn_decl(fn_decl)),
+        Decl::Fn(fn_decl) => push!(categorize_fn_decl(fn_decl)),
 
         Decl::Var(var_decl) => {
             let is_const = matches!(var_decl.kind, VarDeclKind::Const);
@@ -63,10 +75,20 @@ fn transform_decl_stmt(
             let mut new_var_decl = var_decl.to_owned();
 
             for var_declarator in new_var_decl.as_mut().decls.iter_mut() {
-                categorize_var_declarator(&var_declarator, out, vue_imports, is_const);
+                categorize_var_declarator(
+                    &var_declarator,
+                    &mut bindings_helper.setup_bindings,
+                    vue_user_imports,
+                    is_const,
+                );
 
                 if let Some(ref mut init_expr) = var_declarator.init {
-                    let transformed = transform_script_setup_macro_expr(&init_expr, sfc_object_helper, true);
+                    let transformed = transform_script_setup_macro_expr(
+                        &init_expr,
+                        bindings_helper,
+                        sfc_object_helper,
+                        true,
+                    );
                     if let Some(transformed) = transformed {
                         *init_expr = Box::new(transformed);
                     }
@@ -79,7 +101,7 @@ fn transform_decl_stmt(
         Decl::TsEnum(ts_enum) => {
             // Ambient enums are also included, this is intentional
             // I am not sure about `const enum`s though
-            out.push(SetupBinding(
+            push!(SetupBinding(
                 ts_enum.id.sym.to_owned(),
                 BindingTypes::LiteralConst,
             ))
diff --git a/crates/fervid_transform/src/structs.rs b/crates/fervid_transform/src/structs.rs
index c1e5bd2..7b86518 100644
--- a/crates/fervid_transform/src/structs.rs
+++ b/crates/fervid_transform/src/structs.rs
@@ -1,6 +1,6 @@
 //! Exports data structs used by the crate
 
-use fervid_core::{BindingTypes, VueImportsSet, FervidAtom, TemplateGenerationMode};
+use fervid_core::{BindingTypes, VueImportsSet, FervidAtom, TemplateGenerationMode, BuiltinType};
 use fxhash::FxHashMap as HashMap;
 use swc_core::ecma::{atoms::JsWord, ast::{Id, Expr, PropOrSpread, Module, ObjectLit, Function, ExprOrSpread}};
 use smallvec::SmallVec;
@@ -33,6 +33,21 @@ pub struct VueResolvedImports {
     pub reactive: Option<Id>
 }
 
+#[derive(Debug, Default)]
+pub enum ComponentBinding {
+    Resolved(Box<Expr>),
+    #[default]
+    Unresolved,
+    Builtin(BuiltinType)
+}
+
+#[derive(Debug, Default)]
+pub enum CustomDirectiveBinding {
+    Resolved(Box<Expr>),
+    #[default]
+    Unresolved
+}
+
 #[derive(Debug)]
 pub struct TemplateScope {
     pub variables: SmallVec<[JsWord; 1]>,
@@ -40,13 +55,23 @@ pub struct TemplateScope {
 }
 
 #[derive(Debug, Default)]
-pub struct ScopeHelper {
+pub struct BindingsHelper {
+    /// All components present in the `<template>`
+    pub components: HashMap<FervidAtom, ComponentBinding>,
+    /// All custom directives present in the `<template>`
+    pub custom_directives: HashMap<FervidAtom, CustomDirectiveBinding>,
+    /// Scopes of the `<template>` for in-template variable resolutions
     pub template_scopes: Vec<TemplateScope>,
+    /// Bindings in `<script setup>`
     pub setup_bindings: Vec<SetupBinding>,
-    pub options_api_vars: Option<Box<ScriptLegacyVars>>,
+    /// Bindings in `<script>`
+    pub options_api_bindings: Option<Box<ScriptLegacyVars>>,
+    /// The mode with which `<template>` variables are resolved
     pub template_generation_mode: TemplateGenerationMode,
     /// Identifiers used in the template and their respective binding types
-    pub used_idents: HashMap<FervidAtom, BindingTypes>,
+    pub used_bindings: HashMap<FervidAtom, BindingTypes>,
+    /// Internal Vue imports used by built-in components, directives and others
+    pub vue_imports: VueImportsSet
 }
 
 /// https://github.com/vuejs/rfcs/discussions/503
@@ -72,13 +97,9 @@ pub struct SfcExportedObjectHelper {
     pub props: Option<Box<Expr>>,
     /// Other fields of the object
     pub untyped_fields: Vec<PropOrSpread>,
-    /// What imports need to be used
-    pub vue_imports: VueImportsSet
 }
 
 pub struct TransformScriptsResult {
-    /// Imports added by transformation (usually by macros)
-    pub added_imports: VueImportsSet,
     /// EcmaScript module
     pub module: Module,
     /// Default exported object (not linked to module yet)
diff --git a/crates/fervid_transform/src/template/ast_transform.rs b/crates/fervid_transform/src/template/ast_transform.rs
index 7591c29..a4ea97f 100644
--- a/crates/fervid_transform/src/template/ast_transform.rs
+++ b/crates/fervid_transform/src/template/ast_transform.rs
@@ -6,16 +6,16 @@ use fervid_core::{
 use smallvec::SmallVec;
 use swc_core::ecma::atoms::{JsWord, js_word};
 
-use crate::structs::{ScopeHelper, TemplateScope};
+use crate::structs::{BindingsHelper, TemplateScope};
 
 use super::collect_vars::collect_variables;
 
 struct TemplateVisitor<'s> {
-    scope_helper: &'s mut ScopeHelper,
+    scope_helper: &'s mut BindingsHelper,
     current_scope: u32,
 }
 
-/// Transforms the AST template by using information from [`ScopeHelper`].
+/// Transforms the AST template by using information from [`BindingsHelper`].
 ///
 /// The transformations tackled:
 /// - Optimizing the tree by removing white-space nodes;
@@ -23,7 +23,7 @@ struct TemplateVisitor<'s> {
 /// - Transforming Js expressions by resolving variables inside them.
 pub fn transform_and_record_template(
     template: &mut SfcTemplateBlock,
-    scope_helper: &mut ScopeHelper,
+    bindings_helper: &mut BindingsHelper,
 ) {
     // Only retain `ElementNode`s as template roots
     template
@@ -52,7 +52,7 @@ pub fn transform_and_record_template(
     }
 
     let mut template_visitor = TemplateVisitor {
-        scope_helper,
+        scope_helper: bindings_helper,
         current_scope: 0,
     };
 
diff --git a/crates/fervid_transform/src/template/expr_transform.rs b/crates/fervid_transform/src/template/expr_transform.rs
index 3d301c9..a9b06bd 100644
--- a/crates/fervid_transform/src/template/expr_transform.rs
+++ b/crates/fervid_transform/src/template/expr_transform.rs
@@ -1,4 +1,4 @@
-use fervid_core::{BindingTypes, FervidAtom, TemplateGenerationMode};
+use fervid_core::{BindingTypes, FervidAtom, TemplateGenerationMode, VueImports};
 use swc_core::{
     common::{Span, DUMMY_SP},
     ecma::{
@@ -11,17 +11,17 @@ use swc_core::{
     },
 };
 
-use crate::{structs::ScopeHelper, template::js_builtins::JS_BUILTINS};
+use crate::{structs::BindingsHelper, template::js_builtins::JS_BUILTINS};
 
 struct TransformVisitor<'s> {
     current_scope: u32,
-    scope_helper: &'s mut ScopeHelper,
+    scope_helper: &'s mut BindingsHelper,
     has_js_bindings: bool,
     is_inline: bool,
     is_write: bool,
 }
 
-impl ScopeHelper {
+impl BindingsHelper {
     // TODO This function needs to be invoked when an AST is being optimized
     // TODO Support transformation modes (e.g. `inline`, `renderFn`)
     pub fn transform_expr(&mut self, expr: &mut Expr, scope_to_use: u32) -> bool {
@@ -68,19 +68,19 @@ impl ScopeHelper {
 
         // Check hash-map for convenience (we may have found the reference previously)
         let variable_atom = FervidAtom::from(variable);
-        if let Some(binding_type) = self.used_idents.get(&variable_atom) {
+        if let Some(binding_type) = self.used_bindings.get(&variable_atom) {
             return binding_type.to_owned();
         }
 
         // Check setup bindings (both `<script setup>` and `setup()`)
         let setup_bindings = self.setup_bindings.iter().chain(
-            self.options_api_vars
+            self.options_api_bindings
                 .as_ref()
                 .map_or_else(|| [].iter(), |v| v.setup.iter()),
         );
         for binding in setup_bindings {
             if binding.0 == variable_atom {
-                self.used_idents.insert(variable_atom, binding.1);
+                self.used_bindings.insert(variable_atom, binding.1);
                 return binding.1;
             }
         }
@@ -89,14 +89,14 @@ impl ScopeHelper {
         macro_rules! check_scope {
             ($vars: expr, $ret_descriptor: expr) => {
                 if $vars.iter().any(|it| *it == variable_atom) {
-                    self.used_idents.insert(variable_atom, $ret_descriptor);
+                    self.used_bindings.insert(variable_atom, $ret_descriptor);
                     return $ret_descriptor;
                 }
             };
         }
 
         // Check all the options API variables
-        if let Some(options_api_vars) = &self.options_api_vars {
+        if let Some(options_api_vars) = &self.options_api_bindings {
             check_scope!(options_api_vars.data, BindingTypes::Data);
             check_scope!(options_api_vars.props, BindingTypes::Props);
             check_scope!(options_api_vars.computed, BindingTypes::Options);
@@ -107,7 +107,7 @@ impl ScopeHelper {
             // Currently it ignores the SyntaxContext (same as in js implementation)
             for binding in options_api_vars.imports.iter() {
                 if binding.0 == variable_atom {
-                    self.used_idents
+                    self.used_bindings
                         .insert(variable_atom, BindingTypes::SetupMaybeRef);
                     return BindingTypes::SetupMaybeRef;
                 }
@@ -188,14 +188,14 @@ impl<'s> VisitMut for TransformVisitor<'s> {
             })
         };
 
-        let unref = |expr: &mut Expr, span: Span| {
-            // TODO Import `_unref` somehow
-            // TODO Rename `ScopeHelper` to `BindingsHelper` and add `vue_imports` there
+        let mut unref = |expr: &mut Expr, span: Span| {
+            self.scope_helper.vue_imports |= VueImports::Unref;
+
             *expr = Expr::Call(CallExpr {
                 span,
                 callee: Callee::Expr(Box::new(Expr::Ident(Ident {
                     span,
-                    sym: JsWord::from("_unref"),
+                    sym: VueImports::Unref.as_atom(),
                     optional: false,
                 }))),
                 args: vec![ExprOrSpread {
@@ -318,7 +318,7 @@ pub fn get_prefix(binding_type: &BindingTypes, is_inline: bool) -> Option<JsWord
 #[cfg(test)]
 mod tests {
     use crate::{
-        structs::{ScopeHelper, TemplateScope},
+        structs::{BindingsHelper, TemplateScope},
         template::js_builtins::JS_BUILTINS,
     };
     use fervid_core::{BindingTypes, TemplateGenerationMode};
@@ -327,7 +327,7 @@ mod tests {
 
     #[test]
     fn it_acknowledges_builtins() {
-        let mut helper = ScopeHelper::default();
+        let mut helper = BindingsHelper::default();
 
         for builtin in JS_BUILTINS.iter() {
             assert_eq!(
@@ -375,7 +375,7 @@ mod tests {
             variables: SmallVec::from_vec(vec![v_grand2_1.to_owned(), v_grand2_2.to_owned()]),
         };
 
-        let mut scope_helper = ScopeHelper::default();
+        let mut scope_helper = BindingsHelper::default();
         scope_helper.template_scopes.extend(vec![
             root_scope,
             child_scope,