fix: infinite recursion on perl (WIP)

nix-js/Cargo.toml

@@ -75,7 +75,7 @@ name = "builtins"
 harness = false
 
 [[bench]]
-name = "thunk_scope"
+name = "scc_optimization"
 harness = false
 
 [[bench]]

nix-js/src/codegen.rs

@@ -107,9 +107,23 @@ impl<Ctx: CodegenContext> Compile<Ctx> for Ir {
             Ir::List(x) => x.compile(ctx),
             Ir::Call(x) => x.compile(ctx),
             Ir::Arg(x) => format!("arg{}", x.inner.0),
-            Ir::TopLevel(x) => x.compile(ctx),
+            Ir::Let(x) => x.compile(ctx),
             Ir::Select(x) => x.compile(ctx),
-            &Ir::Thunk(Thunk { inner: expr_id, .. }) => {
+            &Ir::Thunk(Thunk {
+                inner: expr_id,
+                span,
+            }) => {
+                let inner = ctx.get_ir(expr_id).compile(ctx);
+                format!(
+                    "Nix.createThunk(()=>({}),\"expr{} {}:{}:{}\")",
+                    inner,
+                    expr_id.0,
+                    ctx.get_current_source().get_name(),
+                    usize::from(span.start()),
+                    usize::from(span.end())
+                )
+            }
+            &Ir::ExprRef(ExprRef { inner: expr_id, .. }) => {
                 format!("expr{}", expr_id.0)
             }
             Ir::Builtins(_) => "Nix.builtins".to_string(),
@@ -206,13 +220,7 @@ impl<Ctx: CodegenContext> Compile<Ctx> for UnOp {
 impl<Ctx: CodegenContext> Compile<Ctx> for Func {
     fn compile(&self, ctx: &Ctx) -> String {
         let id = ctx.get_ir(self.arg).as_ref().unwrap_arg().inner.0;
-        let thunk_defs = compile_thunks(&self.thunks, ctx);
+        let body = ctx.get_ir(self.body).compile(ctx);
-        let body_code = ctx.get_ir(self.body).compile(ctx);
-        let body = if thunk_defs.is_empty() {
-            body_code
-        } else {
-            format!("{{{}return {}}}", thunk_defs, body_code)
-        };
 
         if let Some(Param {
             required,
@@ -224,17 +232,9 @@ impl<Ctx: CodegenContext> Compile<Ctx> for Func {
             let required = format!("[{}]", required.join(","));
             let mut optional = optional.iter().map(|&sym| ctx.get_sym(sym).escape_quote());
             let optional = format!("[{}]", optional.join(","));
-            if thunk_defs.is_empty() {
             format!("Nix.mkFunction(arg{id}=>({body}),{required},{optional},{ellipsis})")
         } else {
-                format!("Nix.mkFunction(arg{id}=>{body},{required},{optional},{ellipsis})")
-            }
-        } else {
-            if thunk_defs.is_empty() {
             format!("arg{id}=>({body})")
-            } else {
-                format!("arg{id}=>{body}")
-            }
         }
     }
 }
@@ -248,38 +248,47 @@ impl<Ctx: CodegenContext> Compile<Ctx> for Call {
     }
 }
 
-fn compile_thunks<Ctx: CodegenContext>(thunks: &[(ExprId, ExprId)], ctx: &Ctx) -> String {
+/// Determines if a Thunk should be kept (not unwrapped) for non-recursive let bindings.
-    if thunks.is_empty() {
+/// Returns true for complex expressions that should remain lazy to preserve Nix semantics.
-        return String::new();
+fn should_keep_thunk(ir: &Ir) -> bool {
+    match ir {
+        // Simple literals can be evaluated eagerly
+        Ir::Int(_) | Ir::Float(_) | Ir::Bool(_) | Ir::Null(_) | Ir::Str(_) => false,
+        // Builtin references are safe to evaluate eagerly
+        Ir::Builtin(_) | Ir::Builtins(_) => false,
+        Ir::ExprRef(_) => false,
+        // Everything else should remain lazy:
+        _ => true,
     }
-    thunks
-        .iter()
-        .map(|&(slot, inner)| {
-            let inner_code = ctx.get_ir(inner).compile(ctx);
-            let inner_span = ctx.get_ir(inner).span();
-            format!(
-                "let expr{}=Nix.createThunk(()=>({}),\"expr{} {}:{}:{}\")",
-                slot.0,
-                inner_code,
-                slot.0,
-                ctx.get_current_source().get_name(),
-                usize::from(inner_span.start()),
-                usize::from(inner_span.end())
-            )
-        })
-        .join(";")
-        + ";"
 }
 
-impl<Ctx: CodegenContext> Compile<Ctx> for TopLevel {
+fn unwrap_thunk(ir: &Ir, ctx: &impl CodegenContext) -> String {
-    fn compile(&self, ctx: &Ctx) -> String {
+    if let Ir::Thunk(Thunk { inner, .. }) = ir {
-        let thunk_defs = compile_thunks(&self.thunks, ctx);
+        let inner_ir = ctx.get_ir(*inner);
-        let body = ctx.get_ir(self.body).compile(ctx);
+        if should_keep_thunk(inner_ir) {
-        if thunk_defs.is_empty() {
+            ir.compile(ctx)
-            body
         } else {
-            format!("(()=>{{{}return {}}})()", thunk_defs, body)
+            inner_ir.compile(ctx)
         }
+    } else {
+        ir.compile(ctx)
+    }
+}
+
+impl<Ctx: CodegenContext> Compile<Ctx> for Let {
+    fn compile(&self, ctx: &Ctx) -> String {
+        let info = &self.binding_sccs;
+        let mut js_statements = Vec::new();
+
+        for (scc_exprs, _is_recursive) in info.sccs.iter() {
+            for &expr in scc_exprs {
+                let value = unwrap_thunk(ctx.get_ir(expr), ctx);
+                js_statements.push(format!("const expr{}={}", expr.0, value));
+            }
+        }
+
+        let body = ctx.get_ir(self.body).compile(ctx);
+        format!("(()=>{{{};return {}}})()", js_statements.join(";"), body)
     }
 }
 

nix-js/src/context.rs

@@ -1,21 +1,28 @@
 use std::path::Path;
 use std::ptr::NonNull;
 
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use itertools::Itertools as _;
+use petgraph::graphmap::DiGraphMap;
 use rnix::TextRange;
 use string_interner::DefaultStringInterner;
 
 use crate::codegen::{CodegenContext, compile};
 use crate::error::{Error, Result, Source};
 use crate::ir::{
-    Arg, ArgId, Bool, Builtin, Downgrade as _, DowngradeContext, ExprId, Ir, Null, SymId, Thunk,
+    Arg, ArgId, Bool, Builtin, Downgrade as _, DowngradeContext, ExprId, ExprRef, Ir, Null, SymId,
-    ToIr as _, synthetic_span,
+    Thunk, ToIr as _, synthetic_span,
 };
 use crate::runtime::{Runtime, RuntimeContext};
 use crate::store::{Store, StoreBackend, StoreConfig};
 use crate::value::Value;
 
+#[derive(Debug)]
+pub(crate) struct SccInfo {
+    /// list of SCCs (exprs, recursive)
+    pub(crate) sccs: Vec<(Vec<ExprId>, bool)>,
+}
+
 pub struct Context {
     ctx: Ctx,
     runtime: Runtime<Ctx>,
@@ -249,6 +256,14 @@ impl RuntimeContext for Ctx {
     }
 }
 
+struct DependencyTracker {
+    graph: DiGraphMap<ExprId, ()>,
+    current_binding: Option<ExprId>,
+    let_scope_exprs: HashSet<ExprId>,
+    // The outer binding that owns this tracker (for nested let scopes in function params)
+    owner_binding: Option<ExprId>,
+}
+
 enum Scope<'ctx> {
     Global(&'ctx HashMap<SymId, ExprId>),
     Let(HashMap<SymId, ExprId>),
@@ -277,7 +292,7 @@ pub struct DowngradeCtx<'ctx> {
     irs: Vec<Option<Ir>>,
     scopes: Vec<Scope<'ctx>>,
     arg_id: usize,
-    thunk_scopes: Vec<Vec<(ExprId, ExprId)>>,
+    dep_tracker_stack: Vec<DependencyTracker>,
 }
 
 impl<'ctx> DowngradeCtx<'ctx> {
@@ -286,7 +301,7 @@ impl<'ctx> DowngradeCtx<'ctx> {
             scopes: vec![Scope::Global(global)],
             irs: vec![],
             arg_id: 0,
-            thunk_scopes: vec![Vec::new()],
+            dep_tracker_stack: Vec::new(),
             ctx,
         }
     }
@@ -331,15 +346,14 @@ impl DowngradeContext for DowngradeCtx<'_> {
             | Ir::Float(_)
             | Ir::Bool(_)
             | Ir::Null(_)
-            | Ir::Str(_)
+            | Ir::Str(_) => id,
-            | Ir::Thunk(_) => id,
+            _ => self.new_expr(
-            _ => {
+                Thunk {
-                let span = ir.span();
+                    inner: id,
-                let slot = self.reserve_slots(1).next().expect("reserve_slots failed");
+                    span: ir.span(),
-                self.replace_ir(slot, Thunk { inner: slot, span }.to_ir());
-                self.register_thunk(slot, id);
-                slot
                 }
+                .to_ir(),
+            ),
         }
     }
 
@@ -361,7 +375,45 @@ impl DowngradeContext for DowngradeCtx<'_> {
                 }
                 Scope::Let(let_scope) => {
                     if let Some(&expr) = let_scope.get(&sym) {
-                        return Ok(self.new_expr(Thunk { inner: expr, span }.to_ir()));
+                        // Find which tracker contains this expression
+                        let expr_tracker_idx = self
+                            .dep_tracker_stack
+                            .iter()
+                            .position(|t| t.let_scope_exprs.contains(&expr));
+
+                        // Find the innermost tracker with a current_binding
+                        let current_tracker_idx = self
+                            .dep_tracker_stack
+                            .iter()
+                            .rposition(|t| t.current_binding.is_some());
+
+                        // Record dependency if both exist
+                        if let (Some(expr_idx), Some(curr_idx)) =
+                            (expr_tracker_idx, current_tracker_idx)
+                        {
+                            let current_binding = self.dep_tracker_stack[curr_idx]
+                                .current_binding
+                                .expect("current_binding not set");
+                            let owner_binding = self.dep_tracker_stack[curr_idx].owner_binding;
+
+                            // If referencing from inner scope to outer scope
+                            if curr_idx >= expr_idx {
+                                let tracker = &mut self.dep_tracker_stack[expr_idx];
+                                let from_node = current_binding;
+                                let to_node = expr;
+                                if curr_idx > expr_idx {
+                                    // Cross-scope reference: use owner_binding if available
+                                    if let Some(owner) = owner_binding {
+                                        tracker.graph.add_edge(owner, expr, ());
+                                    }
+                                } else {
+                                    // Same-level reference: record directly
+                                    tracker.graph.add_edge(from_node, to_node, ());
+                                }
+                            }
+                        }
+
+                        return Ok(self.new_expr(ExprRef { inner: expr, span }.to_ir()));
                     }
                 }
                 &Scope::Param(param_sym, expr) => {
@@ -434,15 +486,11 @@ impl DowngradeContext for DowngradeCtx<'_> {
     }
 
     fn downgrade(mut self, root: rnix::ast::Expr) -> Result<ExprId> {
-        use crate::ir::TopLevel;
+        let root = root.downgrade(&mut self)?;
-        let body = root.downgrade(&mut self)?;
-        let thunks = self.pop_thunk_scope();
-        let span = self.get_ir(body).span();
-        let top_level = self.new_expr(TopLevel { body, thunks, span }.to_ir());
         self.ctx
             .irs
             .extend(self.irs.into_iter().map(Option::unwrap));
-        Ok(top_level)
+        Ok(root)
     }
 
     fn with_let_scope<F, R>(&mut self, bindings: HashMap<SymId, ExprId>, f: F) -> R
@@ -467,26 +515,83 @@ impl DowngradeContext for DowngradeCtx<'_> {
     where
         F: FnOnce(&mut Self) -> R,
     {
-        let namespace = self.maybe_thunk(namespace);
         self.scopes.push(Scope::With(namespace));
         let mut guard = ScopeGuard { ctx: self };
         f(guard.as_ctx())
     }
 
-    fn push_thunk_scope(&mut self) {
+    fn push_dep_tracker(&mut self, slots: &[ExprId]) {
-        self.thunk_scopes.push(Vec::new());
+        let mut graph = DiGraphMap::new();
+        let mut let_scope_exprs = HashSet::new();
+
+        for &expr in slots.iter() {
+            graph.add_node(expr);
+            let_scope_exprs.insert(expr);
         }
 
-    fn pop_thunk_scope(&mut self) -> Vec<(ExprId, ExprId)> {
+        self.dep_tracker_stack.push(DependencyTracker {
-        self.thunk_scopes
+            graph,
+            current_binding: None,
+            let_scope_exprs,
+            owner_binding: None,
+        });
+    }
+
+    fn push_dep_tracker_with_owner(&mut self, slots: &[ExprId], owner: ExprId) {
+        let mut graph = DiGraphMap::new();
+        let mut let_scope_exprs = HashSet::new();
+
+        for &expr in slots.iter() {
+            graph.add_node(expr);
+            let_scope_exprs.insert(expr);
+        }
+
+        self.dep_tracker_stack.push(DependencyTracker {
+            graph,
+            current_binding: None,
+            let_scope_exprs,
+            owner_binding: Some(owner),
+        });
+    }
+
+    fn get_current_binding(&self) -> Option<ExprId> {
+        self.dep_tracker_stack
+            .last()
+            .and_then(|t| t.current_binding)
+    }
+
+    fn set_current_binding(&mut self, expr: Option<ExprId>) {
+        if let Some(tracker) = self.dep_tracker_stack.last_mut() {
+            tracker.current_binding = expr;
+        }
+    }
+
+    fn pop_dep_tracker(&mut self) -> Result<SccInfo> {
+        let tracker = self
+            .dep_tracker_stack
             .pop()
-            .expect("pop_thunk_scope without active scope")
+            .expect("pop_dep_tracker without active tracker");
+
+        use petgraph::algo::kosaraju_scc;
+        let sccs = kosaraju_scc(&tracker.graph);
+
+        let mut sccs_topo = Vec::new();
+
+        for scc_nodes in sccs.iter() {
+            let mut scc_exprs = Vec::new();
+            let mut is_recursive = scc_nodes.len() > 1;
+
+            for &expr in scc_nodes {
+                scc_exprs.push(expr);
+
+                if !is_recursive && tracker.graph.contains_edge(expr, expr) {
+                    is_recursive = true;
+                }
             }
 
-    fn register_thunk(&mut self, slot: ExprId, inner: ExprId) {
+            sccs_topo.push((scc_exprs, is_recursive));
-        self.thunk_scopes
+        }
-            .last_mut()
+
-            .expect("register_thunk without active scope")
+        Ok(SccInfo { sccs: sccs_topo })
-            .push((slot, inner));
     }
 }

nix-js/src/ir.rs

@@ -3,6 +3,7 @@ use hashbrown::HashMap;
 use rnix::{TextRange, ast};
 use string_interner::symbol::SymbolU32;
 
+use crate::context::SccInfo;
 use crate::error::{Error, Result, Source};
 use crate::value::format_symbol;
 use nix_js_macros::ir;
@@ -43,9 +44,11 @@ pub trait DowngradeContext {
     where
         F: FnOnce(&mut Self) -> R;
 
-    fn push_thunk_scope(&mut self);
+    fn push_dep_tracker(&mut self, slots: &[ExprId]);
-    fn pop_thunk_scope(&mut self) -> Vec<(ExprId, ExprId)>;
+    fn push_dep_tracker_with_owner(&mut self, slots: &[ExprId], owner: ExprId);
-    fn register_thunk(&mut self, slot: ExprId, inner: ExprId);
+    fn get_current_binding(&self) -> Option<ExprId>;
+    fn set_current_binding(&mut self, expr: Option<ExprId>);
+    fn pop_dep_tracker(&mut self) -> Result<SccInfo>;
 }
 
 ir! {
@@ -68,9 +71,10 @@ ir! {
     Assert { pub assertion: ExprId, pub expr: ExprId, pub assertion_raw: String },
     ConcatStrings { pub parts: Vec<ExprId> },
     Path { pub expr: ExprId },
-    Func { pub body: ExprId, pub param: Option<Param>, pub arg: ExprId, pub thunks: Vec<(ExprId, ExprId)> },
+    Func { pub body: ExprId, pub param: Option<Param>, pub arg: ExprId },
-    TopLevel { pub body: ExprId, pub thunks: Vec<(ExprId, ExprId)> },
+    Let { pub binding_sccs: SccInfo, pub body: ExprId },
     Arg(ArgId),
+    ExprRef(ExprId),
     Thunk(ExprId),
     Builtins,
     Builtin(SymId),
@@ -97,9 +101,10 @@ impl Ir {
             Ir::ConcatStrings(c) => c.span,
             Ir::Path(p) => p.span,
             Ir::Func(f) => f.span,
-            Ir::TopLevel(t) => t.span,
+            Ir::Let(l) => l.span,
             Ir::Arg(a) => a.span,
-            Ir::Thunk(e) => e.span,
+            Ir::ExprRef(e) => e.span,
+            Ir::Thunk(t) => t.span,
             Ir::Builtins(b) => b.span,
             Ir::Builtin(b) => b.span,
             Ir::CurPos(c) => c.span,

nix-js/src/ir/downgrade.rs

@@ -158,7 +158,7 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::Str {
                 ast::InterpolPart::Literal(lit) => Ok(ctx.new_expr(Str { val: lit, span }.to_ir())),
                 ast::InterpolPart::Interpolation(interpol) => {
                     let inner = interpol.expr().unwrap().downgrade(ctx)?;
-                    Ok(ctx.maybe_thunk(inner))
+                    Ok(ctx.new_expr(Thunk { inner, span }.to_ir()))
                 }
             })
             .collect::<Result<Vec<_>>>()?;
@@ -220,7 +220,7 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::AttrSet {
 
         // rec { a = 1; b = a; } => let a = 1; b = a; in { inherit a b; }
         let entries: Vec<_> = self.entries().collect();
-        downgrade_let_bindings(entries, ctx, span, |ctx, binding_keys| {
+        let (binding_sccs, body) = downgrade_let_bindings(entries, ctx, |ctx, binding_keys| {
             // Create plain attrset as body with inherit
             let mut attrs = AttrSet {
                 stcs: HashMap::new(),
@@ -229,12 +229,22 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::AttrSet {
             };
 
             for sym in binding_keys {
+                // FIXME: span
                 let expr = ctx.lookup(*sym, synthetic_span())?;
                 attrs.stcs.insert(*sym, (expr, synthetic_span()));
             }
 
             Ok(ctx.new_expr(attrs.to_ir()))
-        })
+        })?;
+
+        Ok(ctx.new_expr(
+            Let {
+                body,
+                binding_sccs,
+                span,
+            }
+            .to_ir(),
+        ))
     }
 }
 
@@ -298,8 +308,17 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::Select {
         let expr = self.expr().unwrap().downgrade(ctx)?;
         let attrpath = downgrade_attrpath(self.attrpath().unwrap(), ctx)?;
         let default = if let Some(default) = self.default_expr() {
+            let span = default.syntax().text_range();
             let default_expr = default.downgrade(ctx)?;
-            Some(ctx.maybe_thunk(default_expr))
+            Some(
+                ctx.new_expr(
+                    Thunk {
+                        inner: default_expr,
+                        span,
+                    }
+                    .to_ir(),
+                ),
+            )
         } else {
             None
         };
@@ -359,9 +378,17 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::LetIn {
         let body_expr = self.body().unwrap();
         let span = self.syntax().text_range();
 
-        downgrade_let_bindings(entries, ctx, span, |ctx, _binding_keys| {
+        let (binding_sccs, body) =
-            body_expr.downgrade(ctx)
+            downgrade_let_bindings(entries, ctx, |ctx, _binding_keys| body_expr.downgrade(ctx))?;
-        })
+
+        Ok(ctx.new_expr(
+            Let {
+                body,
+                binding_sccs,
+                span,
+            }
+            .to_ir(),
+        ))
     }
 }
 
@@ -385,10 +412,9 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::Lambda {
         let raw_param = self.param().unwrap();
         let arg = ctx.new_arg(raw_param.syntax().text_range());
 
-        ctx.push_thunk_scope();
-
         let param;
         let body;
+        let span = self.body().unwrap().syntax().text_range();
 
         match raw_param {
             ast::Param::IdentParam(id) => {
@@ -410,6 +436,7 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::Lambda {
 
                 let PatternBindings {
                     body: inner_body,
+                    scc_info,
                     required,
                     optional,
                 } = downgrade_pattern_bindings(pat_entries, alias, arg, ctx, |ctx, _| {
@@ -422,18 +449,24 @@ impl<Ctx: DowngradeContext> Downgrade<Ctx> for ast::Lambda {
                     ellipsis,
                 });
 
-                body = inner_body;
+                body = ctx.new_expr(
+                    Let {
+                        body: inner_body,
+                        binding_sccs: scc_info,
+                        span,
+                    }
+                    .to_ir(),
+                );
             }
         }
 
-        let thunks = ctx.pop_thunk_scope();
         let span = self.syntax().text_range();
+        // The function's body and parameters are now stored directly in the `Func` node.
         Ok(ctx.new_expr(
             Func {
                 body,
                 param,
                 arg,
-                thunks,
                 span,
             }
             .to_ir(),

nix-js/src/ir/utils.rs

@@ -5,7 +5,6 @@ use hashbrown::hash_map::Entry;
 use hashbrown::{HashMap, HashSet};
 use itertools::Itertools as _;
 use rnix::ast;
-use rnix::TextRange;
 use rowan::ast::AstNode;
 
 use crate::error::{Error, Result};
@@ -100,7 +99,13 @@ pub fn downgrade_inherit(
                 }
                 .to_ir(),
             );
-            ctx.maybe_thunk(select_expr)
+            ctx.new_expr(
+                Thunk {
+                    inner: select_expr,
+                    span,
+                }
+                .to_ir(),
+            )
         } else {
             ctx.lookup(ident, span)?
         };
@@ -216,12 +221,20 @@ pub fn downgrade_static_attrpathvalue(
 
 pub struct PatternBindings {
     pub body: ExprId,
+    pub scc_info: SccInfo,
     pub required: Vec<SymId>,
     pub optional: Vec<SymId>,
 }
 
-/// Helper function for Lambda pattern parameters.
+/// Helper function for Lambda pattern parameters with SCC analysis.
-/// Processes pattern entries like `{ a, b ? 2, ... }@alias` and creates bindings.
+/// Processes pattern entries like `{ a, b ? 2, ... }@alias` and creates optimized bindings.
+///
+/// # Parameters
+/// - `pat_entries`: Iterator over pattern entries from the AST
+/// - `alias`: Optional alias symbol (from @alias syntax)
+/// - `arg`: The argument expression to extract from
+///
+/// Returns a tuple of (binding slots, body, SCC info, required params, allowed params)
 pub fn downgrade_pattern_bindings<Ctx>(
     pat_entries: impl Iterator<Item = ast::PatEntry>,
     alias: Option<SymId>,
@@ -281,19 +294,15 @@ where
         }
     });
 
-    let slots: Vec<_> = ctx.reserve_slots(binding_keys.len()).collect();
+    // Get the owner from outer tracker's current_binding
-    let let_bindings: HashMap<_, _> = binding_keys
+    let owner = ctx.get_current_binding();
-        .iter()
-        .copied()
-        .zip(slots.iter().copied())
-        .collect();
 
-    for &slot in &slots {
+    let (scc_info, body) = downgrade_bindings_generic_with_owner(
-        let span = synthetic_span();
+        ctx,
-        ctx.replace_ir(slot, Thunk { inner: slot, span }.to_ir());
+        binding_keys,
-    }
+        |ctx, sym_to_slot| {
+            let mut bindings = HashMap::new();
 
-    ctx.with_let_scope(let_bindings.clone(), |ctx| {
             for Param {
                 sym,
                 sym_span,
@@ -301,7 +310,8 @@ where
                 span,
             } in params
             {
-            let slot = *let_bindings.get(&sym).unwrap();
+                let slot = *sym_to_slot.get(&sym).unwrap();
+                ctx.set_current_binding(Some(slot));
 
                 let default = if let Some(default) = default {
                     let default = default.clone().downgrade(ctx)?;
@@ -319,32 +329,117 @@ where
                     }
                     .to_ir(),
                 );
-            ctx.register_thunk(slot, select_expr);
+                bindings.insert(sym, select_expr);
+                ctx.set_current_binding(None);
             }
 
             if let Some(alias_sym) = alias {
-            let slot = *let_bindings.get(&alias_sym).unwrap();
+                bindings.insert(alias_sym, arg);
-            ctx.register_thunk(slot, arg);
+            }
+
+            Ok(bindings)
+        },
+        body_fn,
+        owner, // Pass the owner to track cross-scope dependencies
+    )?;
+
+    Ok(PatternBindings {
+        body,
+        scc_info,
+        required,
+        optional,
+    })
+}
+
+/// Generic helper function to downgrade bindings with SCC analysis.
+/// This is the core logic for let bindings, extracted for reuse.
+///
+/// # Parameters
+/// - `binding_keys`: The symbols for all bindings
+/// - `compute_bindings_fn`: Called in let scope with sym_to_slot mapping to compute binding values
+/// - `body_fn`: Called in let scope to compute the body expression
+///
+/// Returns a tuple of (binding slots, body result, SCC info)
+pub fn downgrade_bindings_generic<Ctx, B, F>(
+    ctx: &mut Ctx,
+    binding_keys: Vec<SymId>,
+    compute_bindings_fn: B,
+    body_fn: F,
+) -> Result<(SccInfo, ExprId)>
+where
+    Ctx: DowngradeContext,
+    B: FnOnce(&mut Ctx, &HashMap<SymId, ExprId>) -> Result<HashMap<SymId, ExprId>>,
+    F: FnOnce(&mut Ctx, &[SymId]) -> Result<ExprId>,
+{
+    downgrade_bindings_generic_with_owner(ctx, binding_keys, compute_bindings_fn, body_fn, None)
+}
+
+pub fn downgrade_bindings_generic_with_owner<Ctx, B, F>(
+    ctx: &mut Ctx,
+    binding_keys: Vec<SymId>,
+    compute_bindings_fn: B,
+    body_fn: F,
+    owner: Option<ExprId>,
+) -> Result<(SccInfo, ExprId)>
+where
+    Ctx: DowngradeContext,
+    B: FnOnce(&mut Ctx, &HashMap<SymId, ExprId>) -> Result<HashMap<SymId, ExprId>>,
+    F: FnOnce(&mut Ctx, &[SymId]) -> Result<ExprId>,
+{
+    let slots: Vec<_> = ctx.reserve_slots(binding_keys.len()).collect();
+    let let_bindings: HashMap<_, _> = binding_keys
+        .iter()
+        .copied()
+        .zip(slots.iter().copied())
+        .collect();
+
+    if let Some(owner_binding) = owner {
+        ctx.push_dep_tracker_with_owner(&slots, owner_binding);
+    } else {
+        ctx.push_dep_tracker(&slots);
+    }
+
+    ctx.with_let_scope(let_bindings.clone(), |ctx| {
+        let bindings = compute_bindings_fn(ctx, &let_bindings)?;
+
+        let scc_info = ctx.pop_dep_tracker()?;
+
+        for (sym, slot) in binding_keys.iter().copied().zip(slots.iter()) {
+            if let Some(&expr) = bindings.get(&sym) {
+                ctx.replace_ir(
+                    *slot,
+                    Thunk {
+                        inner: expr,
+                        span: ctx.get_ir(expr).span(),
+                    }
+                    .to_ir(),
+                );
+            } else {
+                return Err(Error::internal(format!(
+                    "binding '{}' not found",
+                    format_symbol(ctx.get_sym(sym))
+                )));
+            }
         }
 
         let body = body_fn(ctx, &binding_keys)?;
 
-        Ok(PatternBindings {
+        Ok((scc_info, body))
-            body,
-            required,
-            optional,
-        })
     })
 }
 
 /// Helper function to downgrade entries with let bindings semantics.
 /// This extracts common logic for both `rec` attribute sets and `let...in` expressions.
+///
+/// Returns a tuple of (binding slots, body result, SCC info) where:
+/// - binding slots: pre-allocated expression slots for the bindings
+/// - body result: the result of calling `body_fn` in the let scope
+/// - SCC info: strongly connected components information for optimization
 pub fn downgrade_let_bindings<Ctx, F>(
     entries: Vec<ast::Entry>,
     ctx: &mut Ctx,
-    _span: TextRange,
     body_fn: F,
-) -> Result<ExprId>
+) -> Result<(SccInfo, ExprId)>
 where
     Ctx: DowngradeContext,
     F: FnOnce(&mut Ctx, &[SymId]) -> Result<ExprId>,
@@ -374,6 +469,8 @@ where
                 let attrpath = value.attrpath().unwrap();
                 let attrs_vec: Vec<_> = attrpath.attrs().collect();
 
+                // Only check for duplicate definitions if this is a top-level binding (path length == 1)
+                // For nested paths (e.g., types.a, types.b), they will be merged into the same attrset
                 if attrs_vec.len() == 1 {
                     if let Some(ast::Attr::Ident(ident)) = attrs_vec.first() {
                         let sym = ctx.new_sym(ident.to_string());
@@ -389,6 +486,7 @@ where
                         }
                     }
                 } else if attrs_vec.len() > 1 {
+                    // For nested paths, just record the first-level name without checking duplicates
                     if let Some(ast::Attr::Ident(ident)) = attrs_vec.first() {
                         let sym = ctx.new_sym(ident.to_string());
                         binding_syms.insert(sym);
@@ -399,19 +497,11 @@ where
     }
 
     let binding_keys: Vec<_> = binding_syms.into_iter().collect();
-    let slots: Vec<_> = ctx.reserve_slots(binding_keys.len()).collect();
-    let let_bindings: HashMap<_, _> = binding_keys
-        .iter()
-        .copied()
-        .zip(slots.iter().copied())
-        .collect();
 
-    for &slot in &slots {
+    downgrade_bindings_generic(
-        let span = synthetic_span();
+        ctx,
-        ctx.replace_ir(slot, Thunk { inner: slot, span }.to_ir());
+        binding_keys,
-    }
+        |ctx, sym_to_slot| {
-
-    ctx.with_let_scope(let_bindings.clone(), |ctx| {
             let mut temp_attrs = AttrSet {
                 stcs: HashMap::new(),
                 dyns: Vec::new(),
@@ -421,25 +511,37 @@ where
             for entry in entries {
                 match entry {
                     ast::Entry::Inherit(inherit) => {
+                        for attr in inherit.attrs() {
+                            if let ast::Attr::Ident(ident) = attr {
+                                let sym = ctx.new_sym(ident.to_string());
+                                let slot = *sym_to_slot.get(&sym).unwrap();
+                                ctx.set_current_binding(Some(slot));
+                            }
+                        }
                         downgrade_inherit(inherit, &mut temp_attrs.stcs, ctx)?;
+                        ctx.set_current_binding(None);
                     }
                     ast::Entry::AttrpathValue(value) => {
+                        let attrpath = value.attrpath().unwrap();
+                        if let Some(first_attr) = attrpath.attrs().next()
+                            && let ast::Attr::Ident(ident) = first_attr
+                        {
+                            let sym = ctx.new_sym(ident.to_string());
+                            let slot = *sym_to_slot.get(&sym).unwrap();
+                            ctx.set_current_binding(Some(slot));
+                        }
                         downgrade_static_attrpathvalue(value, &mut temp_attrs, ctx)?;
+                        ctx.set_current_binding(None);
                     }
                 }
             }
 
-        for (sym, slot) in binding_keys.iter().copied().zip(slots.iter()) {
+            Ok(temp_attrs
-            if let Some(&(expr, _)) = temp_attrs.stcs.get(&sym) {
+                .stcs
-                ctx.register_thunk(*slot, expr);
+                .into_iter()
-            } else {
+                .map(|(k, (v, _))| (k, v))
-                return Err(Error::internal(format!(
+                .collect())
-                    "binding '{}' not found",
+        },
-                    format_symbol(ctx.get_sym(sym))
+        body_fn,
-                )));
+    )
-            }
-        }
-
-        body_fn(ctx, &binding_keys)
-    })
 }

nix-js/src/runtime.rs

@@ -539,11 +539,7 @@ fn op_copy_path_to_store<Ctx: RuntimeContext>(
 #[deno_core::op2]
 #[string]
 fn op_get_env(#[string] key: String) -> std::result::Result<String, NixError> {
-    match std::env::var(key) {
+    Ok(std::env::var(key).map_err(|err| format!("Failed to read env var: {err}"))?)
-        Ok(val) => Ok(val),
-        Err(std::env::VarError::NotPresent) => Ok("".into()),
-        Err(err) => Err(format!("Failed to read env var: {err}").into())
-    }
 }
 
 pub(crate) struct Runtime<Ctx: RuntimeContext> {