diff --git a/Cargo.lock b/Cargo.lock
index 39f8c38..4304df1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -512,6 +512,7 @@ name = "fervid_transform"
 version = "0.0.1"
 dependencies = [
  "fervid_core",
+ "fxhash",
  "lazy_static",
  "phf 0.11.2",
  "smallvec",
diff --git a/crates/fervid/src/lib.rs b/crates/fervid/src/lib.rs
index d563ffc..2b3496d 100644
--- a/crates/fervid/src/lib.rs
+++ b/crates/fervid/src/lib.rs
@@ -42,10 +42,7 @@ pub mod parser;
 
 use fervid_codegen::CodegenContext;
 pub use fervid_core::*;
-use fervid_transform::{
-    script::transform_and_record_scripts, structs::ScopeHelper,
-    template::transform_and_record_template,
-};
+use fervid_transform::transform_sfc;
 use swc_core::ecma::ast::Expr;
 
 /// Naive implementation of the SFC compilation, meaning that:
@@ -60,28 +57,25 @@ pub fn compile_sync_naive(source: &str) -> Result<String, String> {
     // })?;
 
     let mut errors = Vec::new();
-    let mut sfc = fervid_parser::parse_sfc(&source, &mut errors).map_err(|err| {
+    let sfc = fervid_parser::parse_sfc(&source, &mut errors).map_err(|err| {
         return err.to_string();
     })?;
 
-    let mut scope_helper = ScopeHelper::default();
-    let transform_result =
-        transform_and_record_scripts(sfc.script_setup, sfc.script_legacy, &mut scope_helper);
+    // TODO Return template used variables as a part of transformation result.
+    // Also `used_imports`? `vue_imports`? User imports?
+    let transform_result = transform_sfc(sfc);
 
     let mut ctx = CodegenContext::default();
+    ctx.used_imports = transform_result.used_vue_imports;
 
-    let template_expr: Option<Expr> = sfc.template.as_mut().map(|template_block| {
-        transform_and_record_template(template_block, &mut scope_helper);
+    let template_expr: Option<Expr> = transform_result.template_block.map(|template_block| {
         ctx.generate_sfc_template(&template_block)
     });
 
-    // Add imports from script transformation (because macros generate new imports)
-    ctx.used_imports |= transform_result.added_imports;
-
     let sfc_module = ctx.generate_module(
         template_expr,
         transform_result.module,
-        transform_result.export_obj,
+        transform_result.exported_obj,
         transform_result.setup_fn,
     );
 
diff --git a/crates/fervid_transform/Cargo.toml b/crates/fervid_transform/Cargo.toml
index 0fb34bc..d7541e6 100644
--- a/crates/fervid_transform/Cargo.toml
+++ b/crates/fervid_transform/Cargo.toml
@@ -11,6 +11,7 @@ license = "Apache-2.0"
 
 [dependencies]
 fervid_core = { path="../fervid_core", version = "0.0.1" }
+fxhash = "0.2.1"
 lazy_static = "1.4.0"
 phf = { version = "0.11", features = ["macros"] }
 swc_core = { version = "0.83.*", features = ["common", "ecma_ast", "ecma_visit"] }
diff --git a/crates/fervid_transform/src/lib.rs b/crates/fervid_transform/src/lib.rs
index dc874be..ab6c2fa 100644
--- a/crates/fervid_transform/src/lib.rs
+++ b/crates/fervid_transform/src/lib.rs
@@ -1,3 +1,10 @@
+use fervid_core::{SfcDescriptor, SfcTemplateBlock, VueImportsSet, BindingTypes, FervidAtom};
+use fxhash::FxHashMap as HashMap;
+use script::transform_and_record_scripts;
+use structs::ScopeHelper;
+use swc_core::ecma::ast::{Module, ObjectLit, Function};
+use template::transform_and_record_template;
+
 #[macro_use]
 extern crate lazy_static;
 
@@ -8,3 +15,46 @@ pub mod template;
 
 #[cfg(test)]
 mod test_utils;
+
+pub struct TransformSfcResult {
+    /// Object exported from the `Module`, but detached from it
+    pub exported_obj: ObjectLit,
+    /// Module obtained by processing `<script>` and `<script setup>`
+    pub module: Module,
+    /// Setup function (not linked to default export yet)
+    pub setup_fn: Option<Box<Function>>,
+    /// Transformed template block
+    pub template_block: Option<SfcTemplateBlock>,
+    /// All imports `from 'vue'`
+    pub used_vue_imports: VueImportsSet,
+    /// Identifiers used in the template and their respective binding types
+    pub used_idents: HashMap<FervidAtom, BindingTypes>
+}
+
+/// Applies all the necessary transformations to the SFC.
+///
+/// The transformations can be fine-tuned by using individual `transform_` functions.
+pub fn transform_sfc(sfc_descriptor: SfcDescriptor) -> TransformSfcResult {
+    let mut template_block = None;
+
+    let mut scope_helper = ScopeHelper::default();
+    let transform_result = transform_and_record_scripts(
+        sfc_descriptor.script_setup,
+        sfc_descriptor.script_legacy,
+        &mut scope_helper,
+    );
+
+    if let Some(mut template) = sfc_descriptor.template {
+        transform_and_record_template(&mut template, &mut scope_helper);
+        template_block = Some(template);
+    }
+
+    TransformSfcResult {
+        exported_obj: transform_result.export_obj,
+        module: transform_result.module,
+        setup_fn: transform_result.setup_fn,
+        template_block,
+        used_idents: scope_helper.used_idents,
+        used_vue_imports: transform_result.added_imports,
+    }
+}
diff --git a/crates/fervid_transform/src/script.rs b/crates/fervid_transform/src/script.rs
index 99f959f..d12aec1 100644
--- a/crates/fervid_transform/src/script.rs
+++ b/crates/fervid_transform/src/script.rs
@@ -34,6 +34,9 @@ pub fn transform_and_record_scripts(
     script_legacy: Option<SfcScriptBlock>,
     scope_helper: &mut ScopeHelper,
 ) -> TransformScriptsResult {
+    // Set `is_inline` flag in `ScopeHelper`
+    scope_helper.is_inline = script_legacy.is_none() && script_setup.is_some();
+
     //
     // STEP 1: Transform Options API `<script>`.
     //
diff --git a/crates/fervid_transform/src/script/setup.rs b/crates/fervid_transform/src/script/setup.rs
index 5860c5c..00ab297 100644
--- a/crates/fervid_transform/src/script/setup.rs
+++ b/crates/fervid_transform/src/script/setup.rs
@@ -57,9 +57,8 @@ pub fn transform_and_record_script_setup(
             }
 
             ModuleItem::Stmt(stmt) => {
-                // todo actual analysis and transformation as in `fervid_script`
                 if let Some(transformed_stmt) = transform_and_record_stmt(
-                    &stmt,
+                    stmt,
                     &mut scope_helper.setup_bindings,
                     &vue_imports,
                     &mut sfc_object_helper,
@@ -208,19 +207,19 @@ mod tests {
         setup: Vec<SetupBinding>,
     }
 
-    fn analyze_mock(module: &Module) -> MockAnalysisResult {
+    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.iter() {
-            match *module_item {
+        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)
                 }
 
-                ModuleItem::Stmt(ref stmt) => {
+                ModuleItem::Stmt(stmt) => {
                     transform_and_record_stmt(stmt, &mut setup, &mut vue_imports, &mut sfc_object);
                 }
 
@@ -241,7 +240,7 @@ mod tests {
             .expect("analyze_js expects the input to be parseable")
             .0;
 
-        analyze_mock(&parsed)
+        analyze_mock(parsed)
     }
 
     fn analyze_ts(input: &str) -> MockAnalysisResult {
@@ -249,7 +248,7 @@ mod tests {
             .expect("analyze_ts expects the input to be parseable")
             .0;
 
-        analyze_mock(&parsed)
+        analyze_mock(parsed)
     }
 
     macro_rules! test_js_and_ts {
diff --git a/crates/fervid_transform/src/script/setup/statements.rs b/crates/fervid_transform/src/script/setup/statements.rs
index 4dce32f..bc87243 100644
--- a/crates/fervid_transform/src/script/setup/statements.rs
+++ b/crates/fervid_transform/src/script/setup/statements.rs
@@ -14,7 +14,7 @@ use super::macros::transform_script_setup_macro_expr;
 /// 2. The top-level statements in `<script>` when using mixed `<script>` + `<script setup>`;
 /// 3. The insides of `setup()` function in `<script>` Options API.
 pub fn transform_and_record_stmt(
-    stmt: &Stmt,
+    stmt: Stmt,
     out: &mut Vec<SetupBinding>,
     vue_imports: &VueResolvedImports,
     sfc_object_helper: &mut SfcExportedObjectHelper,
@@ -39,7 +39,7 @@ pub fn transform_and_record_stmt(
     }
 
     // By default, just return the copied statement
-    Some(stmt.to_owned())
+    Some(stmt)
 }
 
 /// Analyzes the declaration in `script setup` context.
diff --git a/crates/fervid_transform/src/structs.rs b/crates/fervid_transform/src/structs.rs
index cc29ba6..8cab26c 100644
--- a/crates/fervid_transform/src/structs.rs
+++ b/crates/fervid_transform/src/structs.rs
@@ -1,6 +1,7 @@
 //! Exports data structs used by the crate
 
-use fervid_core::{BindingTypes, VueImportsSet};
+use fervid_core::{BindingTypes, VueImportsSet, FervidAtom};
+use fxhash::FxHashMap as HashMap;
 use swc_core::ecma::{atoms::JsWord, ast::{Id, Expr, PropOrSpread, Module, ObjectLit, Function, ExprOrSpread}};
 use smallvec::SmallVec;
 
@@ -44,7 +45,9 @@ pub struct ScopeHelper {
     pub setup_bindings: Vec<SetupBinding>,
     pub options_api_vars: Option<Box<ScriptLegacyVars>>,
     pub is_inline: bool,
-    pub transform_mode: TemplateGenerationMode
+    pub transform_mode: TemplateGenerationMode,
+    /// Identifiers used in the template and their respective binding types
+    pub used_idents: HashMap<FervidAtom, BindingTypes>,
 }
 
 /// https://github.com/vuejs/rfcs/discussions/503
diff --git a/crates/fervid_transform/src/template/ast_transform.rs b/crates/fervid_transform/src/template/ast_transform.rs
index fbea649..ce5fde5 100644
--- a/crates/fervid_transform/src/template/ast_transform.rs
+++ b/crates/fervid_transform/src/template/ast_transform.rs
@@ -309,6 +309,7 @@ impl<'a> Visitor for TemplateVisitor<'_> {
         self.current_scope = scope_to_use;
 
         // Transform the VBind and VOn attributes
+        let patch_hints = &mut element_node.patch_hints;
         for attr in element_node.starting_tag.attributes.iter_mut() {
             match attr {
                 // The logic for the patch flags:
@@ -321,7 +322,6 @@ impl<'a> Visitor for TemplateVisitor<'_> {
                     let has_bindings = self
                         .scope_helper
                         .transform_expr(&mut v_bind.value, scope_to_use);
-                    let patch_hints = &mut element_node.patch_hints;
 
                     let Some(StrOrExpr::Str(ref argument)) = v_bind.argument else {
                         // This is dynamic
diff --git a/crates/fervid_transform/src/template/expr_transform.rs b/crates/fervid_transform/src/template/expr_transform.rs
index 501de83..e497a01 100644
--- a/crates/fervid_transform/src/template/expr_transform.rs
+++ b/crates/fervid_transform/src/template/expr_transform.rs
@@ -1,35 +1,44 @@
-use fervid_core::BindingTypes;
-use swc_core::ecma::{
-    ast::{Expr, Ident, KeyValueProp, MemberExpr, MemberProp, Prop, PropName, PropOrSpread},
-    atoms::JsWord,
-    visit::{VisitMut, VisitMutWith},
+use fervid_core::{BindingTypes, FervidAtom};
+use swc_core::{
+    common::{Span, DUMMY_SP},
+    ecma::{
+        ast::{
+            CallExpr, Expr, Ident, KeyValueProp, MemberExpr, MemberProp, Prop, PropName,
+            PropOrSpread, Callee, ExprOrSpread, PatOrExpr,
+        },
+        atoms::JsWord,
+        visit::{VisitMut, VisitMutWith},
+    },
 };
 
 use crate::{structs::ScopeHelper, template::js_builtins::JS_BUILTINS};
 
 struct TransformVisitor<'s> {
     current_scope: u32,
-    scope_helper: &'s ScopeHelper,
+    scope_helper: &'s mut ScopeHelper,
     has_js_bindings: bool,
     is_inline: bool,
+    is_write: bool
 }
 
 impl ScopeHelper {
     // 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(&self, expr: &mut Expr, scope_to_use: u32) -> bool {
+    pub fn transform_expr(&mut self, expr: &mut Expr, scope_to_use: u32) -> bool {
+        let is_inline = self.is_inline;
         let mut visitor = TransformVisitor {
             current_scope: scope_to_use,
             scope_helper: self,
             has_js_bindings: false,
-            is_inline: self.is_inline,
+            is_inline,
+            is_write: false
         };
         expr.visit_mut_with(&mut visitor);
 
         visitor.has_js_bindings
     }
 
-    pub fn get_var_binding_type(&self, starting_scope: u32, variable: &str) -> BindingTypes {
+    pub fn get_var_binding_type(&mut self, starting_scope: u32, variable: &str) -> BindingTypes {
         if JS_BUILTINS.contains(variable) {
             return BindingTypes::JsGlobal;
         }
@@ -54,6 +63,12 @@ impl ScopeHelper {
             current_scope_index = current_scope.parent;
         }
 
+        // 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) {
+            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
@@ -61,7 +76,8 @@ impl ScopeHelper {
                 .map_or_else(|| [].iter(), |v| v.setup.iter()),
         );
         for binding in setup_bindings {
-            if &binding.0 == variable {
+            if binding.0 == variable_atom {
+                self.used_idents.insert(variable_atom, binding.1);
                 return binding.1;
             }
         }
@@ -69,7 +85,8 @@ impl ScopeHelper {
         // Macro to check if the variable is in the slice/Vec and conditionally return
         macro_rules! check_scope {
             ($vars: expr, $ret_descriptor: expr) => {
-                if $vars.iter().any(|it| it == variable) {
+                if $vars.iter().any(|it| *it == variable_atom) {
+                    self.used_idents.insert(variable_atom, $ret_descriptor);
                     return $ret_descriptor;
                 }
             };
@@ -86,7 +103,9 @@ impl ScopeHelper {
             // Check options API imports.
             // Currently it ignores the SyntaxContext (same as in js implementation)
             for binding in options_api_vars.imports.iter() {
-                if &binding.0 == variable {
+                if binding.0 == variable_atom {
+                    self.used_idents
+                        .insert(variable_atom, BindingTypes::SetupMaybeRef);
                     return BindingTypes::SetupMaybeRef;
                 }
             }
@@ -97,35 +116,99 @@ impl ScopeHelper {
 }
 
 impl<'s> VisitMut for TransformVisitor<'s> {
-    fn visit_mut_expr(&mut self, n: &mut Expr) {
-        match n {
-            Expr::Ident(ident_expr) => {
-                let symbol = &ident_expr.sym;
-                let binding_type = self
-                    .scope_helper
-                    .get_var_binding_type(self.current_scope, symbol);
-
-                // TODO The logic for setup variables actually differs quite significantly
-                // https://play.vuejs.org/#eNp9UU1rwzAM/SvCl25QEkZvIRTa0cN22Mq6oy8hUVJ3iW380QWC//tkh2Y7jN6k956kJ2liO62zq0dWsNLWRmgHFp3XWy7FoJVxMMEOArRGDbDK8v2KywZbIfFolLYPE5cArVIFnJwRsuMyPHJZ5nMv6kKJw0H3lUPKAMrz03aaYgmEQAE1D2VOYKxalGzNnK2VbEWXXaySZC9N4qxWgxY9mnfthJKWswISE7mq79X3a8Kc8bi+4fUZ669/8IsdI8bZ0aBFc0XOFs5VpkM304fTG44UL+SgGt+T+g75gVb1PnqcZXsvG7L9R5fcvqQj0+E+7WF0KO1tqWg0KkPSc0Y/er6z+q/dTbZJdfQJFn4A+DKelw==
-
-                // Get the prefix which fits the scope (e.g. `_ctx.` for unknown scopes, `$setup.` for setup scope)
-                if let Some(prefix) = get_prefix(&binding_type, self.is_inline) {
-                    *n = Expr::Member(MemberExpr {
-                        span: ident_expr.span,
-                        obj: Box::new(Expr::Ident(Ident {
-                            span: ident_expr.span,
-                            sym: prefix,
-                            optional: false,
-                        })),
-                        prop: MemberProp::Ident(ident_expr.to_owned()),
-                    });
-                    self.has_js_bindings = true;
-                } else if let BindingTypes::TemplateLocal = binding_type {
-                    self.has_js_bindings = true;
-                }
+    fn visit_mut_assign_expr(&mut self, n: &mut swc_core::ecma::ast::AssignExpr) {
+        match n.left {
+            // Assignments must have their LHS correctly handled
+            // Especially `SetupLet`
+            PatOrExpr::Expr(ref e) if matches!(**e, Expr::Ident(_)) => {
+                let old_is_write = self.is_write;
+                self.is_write = true;
+                n.left.visit_mut_with(self);
+                self.is_write = old_is_write;
+                n.right.visit_mut_with(self);
+            }
+
+            _ => {
+                n.visit_mut_children_with(self)
             }
+        }        
+    }
+
+    fn visit_mut_expr(&mut self, n: &mut Expr) {
+        let Expr::Ident(ident_expr) = n else {
+            n.visit_mut_children_with(self);
+            return;
+        };
+
+        let symbol = &ident_expr.sym;
+        let span = ident_expr.span;
+
+        let binding_type = self
+            .scope_helper
+            .get_var_binding_type(self.current_scope, symbol);
+
+        // Template local binding doesn't need any processing
+        if let BindingTypes::TemplateLocal = binding_type {
+            self.has_js_bindings = true;
+            return;
+        }
+
+        // Get the prefix which fits the scope (e.g. `_ctx.` for unknown scopes, `$setup.` for setup scope)
+        if let Some(prefix) = get_prefix(&binding_type, self.is_inline) {
+            *n = Expr::Member(MemberExpr {
+                span,
+                obj: Box::new(Expr::Ident(Ident {
+                    span,
+                    sym: prefix,
+                    optional: false,
+                })),
+                prop: MemberProp::Ident(ident_expr.to_owned()),
+            });
+            self.has_js_bindings = true;
+        }
+
+        // Non-inline logic ends here
+        if !self.is_inline {
+            return;
+        }
+
+        // TODO The logic for setup variables actually differs quite significantly
+        // https://play.vuejs.org/#eNp9UU1rwzAM/SvCl25QEkZvIRTa0cN22Mq6oy8hUVJ3iW380QWC//tkh2Y7jN6k956kJ2liO62zq0dWsNLWRmgHFp3XWy7FoJVxMMEOArRGDbDK8v2KywZbIfFolLYPE5cArVIFnJwRsuMyPHJZ5nMv6kKJw0H3lUPKAMrz03aaYgmEQAE1D2VOYKxalGzNnK2VbEWXXaySZC9N4qxWgxY9mnfthJKWswISE7mq79X3a8Kc8bi+4fUZ669/8IsdI8bZ0aBFc0XOFs5VpkM304fTG44UL+SgGt+T+g75gVb1PnqcZXsvG7L9R5fcvqQj0+E+7WF0KO1tqWg0KkPSc0Y/er6z+q/dTbZJdfQJFn4A+DKelw==
+
+        let dot_value = |expr: &mut Expr, span: Span| {
+            *expr = Expr::Member(MemberExpr {
+                span,
+                obj: Box::new(expr.to_owned()),
+                prop: MemberProp::Ident(Ident {
+                    span: DUMMY_SP,
+                    sym: "value".into(),
+                    optional: false,
+                }),
+            })
+        };
+
+        let unref = |expr: &mut Expr, span: Span| {
+            // TODO Import `_unref` somehow
+            *expr = Expr::Call(CallExpr {
+                span,
+                callee: Callee::Expr(Box::new(Expr::Ident(Ident { span, sym: JsWord::from("_unref"), optional: false }))),
+                args: vec![
+                    ExprOrSpread { spread: None, expr: Box::new(expr.to_owned()) }
+                ],
+                type_args: None,
+            });
+        };
 
-            _ => n.visit_mut_children_with(self),
+        // Inline logic is pretty complex
+        // TODO Actual logic
+        match binding_type {
+            BindingTypes::SetupLet => unref(n, span),
+            BindingTypes::SetupConst => {},
+            BindingTypes::SetupReactiveConst => {},
+            BindingTypes::SetupMaybeRef => unref(n, span),
+            BindingTypes::SetupRef => dot_value(n, span),
+            BindingTypes::LiteralConst => {},
+            _ => {}
         }
     }
 
@@ -190,7 +273,7 @@ pub fn get_prefix(binding_type: &BindingTypes, is_inline: bool) -> Option<JsWord
     // For inline mode, options API variables become prefixed
     if is_inline {
         return match binding_type {
-            BindingTypes::Data | BindingTypes::Options => Some(JsWord::from("_ctx")),
+            BindingTypes::Data | BindingTypes::Options | BindingTypes::Unresolved => Some(JsWord::from("_ctx")),
             BindingTypes::Props => Some(JsWord::from("__props")),
             // TODO This is not correct. The transform implementation must handle `unref`
             _ => None,