diff --git a/.config/nextest.toml b/.config/nextest.toml
index c0dcb04c99ce..3d85de7ee9f4 100644
--- a/.config/nextest.toml
+++ b/.config/nextest.toml
@@ -1,6 +1,7 @@
 [profile.default]
 fail-fast = false
 failure-output = "final"
+status-level = "slow"
 slow-timeout = {period = "500ms", terminate-after = 4}
 
 [[profile.default.overrides]]
diff --git a/prqlc/bindings/js/README.md b/prqlc/bindings/js/README.md
index 175ed96d78dd..f2300daaf575 100644
--- a/prqlc/bindings/js/README.md
+++ b/prqlc/bindings/js/README.md
@@ -76,7 +76,7 @@ console.log(sql);
 <html>
   <head>
     <script type="module">
-      import init, { compile } from './dist/web/prql_js.js';
+      import init, { compile } from "./dist/web/prql_js.js";
       await init();
 
       const sql = compile("from db.employees | select first_name");
diff --git a/prqlc/bindings/js/tests/test_all.mjs b/prqlc/bindings/js/tests/test_all.mjs
index 0191ade2f97e..5dd57a25565e 100644
--- a/prqlc/bindings/js/tests/test_all.mjs
+++ b/prqlc/bindings/js/tests/test_all.mjs
@@ -94,7 +94,10 @@ describe("prql-js", () => {
       const opts = new prql.CompileOptions();
 
       opts.target = "sql.any";
-      const res = prql.compile("prql target:sql.mssql\nfrom db.a | take 1", opts);
+      const res = prql.compile(
+        "prql target:sql.mssql\nfrom db.a | take 1",
+        opts,
+      );
       assert(res.includes("1 ROWS ONLY"));
     });
   });
diff --git a/prqlc/prqlc-ast/src/error.rs b/prqlc/prqlc-ast/src/error.rs
index c95718c99acc..01e984087c0a 100644
--- a/prqlc/prqlc-ast/src/error.rs
+++ b/prqlc/prqlc-ast/src/error.rs
@@ -146,6 +146,7 @@ pub trait WithErrorInfo: Sized {
     fn with_hints<S: Into<String>, I: IntoIterator<Item = S>>(self, hints: I) -> Self;
 
     fn with_span(self, span: Option<Span>) -> Self;
+    fn with_span_fallback(self, span: Option<Span>) -> Self;
     fn with_code(self, code: &'static str) -> Self;
 }
 
@@ -160,6 +161,11 @@ impl WithErrorInfo for Error {
         self
     }
 
+    fn with_span_fallback(mut self, span: Option<Span>) -> Self {
+        self.span = self.span.or(span);
+        self
+    }
+
     fn push_hint<S: Into<String>>(mut self, hint: S) -> Self {
         self.hints.push(hint.into());
         self
@@ -180,6 +186,10 @@ impl<T, E: WithErrorInfo> WithErrorInfo for Result<T, E> {
         self.map_err(|e| e.with_span(span))
     }
 
+    fn with_span_fallback(self, span: Option<Span>) -> Self {
+        self.map_err(|e| e.with_span_fallback(span))
+    }
+
     fn with_code(self, code: &'static str) -> Self {
         self.map_err(|e| e.with_code(code))
     }
diff --git a/prqlc/prqlc-ast/src/expr/ident.rs b/prqlc/prqlc-ast/src/expr/ident.rs
index 8d8947b1fdfc..f6e41e2cc46f 100644
--- a/prqlc/prqlc-ast/src/expr/ident.rs
+++ b/prqlc/prqlc-ast/src/expr/ident.rs
@@ -144,7 +144,11 @@ impl<'de> Deserialize<'de> for Ident {
 }
 
 pub fn display_ident(f: &mut std::fmt::Formatter, ident: &Ident) -> Result<(), std::fmt::Error> {
-    for part in &ident.path {
+    let mut path = &ident.path[..];
+    if path.first().map_or(false, |f| f == "_local") {
+        path = &path[1..];
+    }
+    for part in path {
         display_ident_part(f, part)?;
         f.write_char('.')?;
     }
diff --git a/prqlc/prqlc/src/cli/mod.rs b/prqlc/prqlc/src/cli/mod.rs
index 089f34c0fee8..464754985d52 100644
--- a/prqlc/prqlc/src/cli/mod.rs
+++ b/prqlc/prqlc/src/cli/mod.rs
@@ -291,6 +291,7 @@ impl Command {
                 let mut root_module_def = prql_to_pl_tree(sources)?;
 
                 drop_module_def(&mut root_module_def.stmts, "std");
+                drop_module_def(&mut root_module_def.stmts, "_local");
 
                 pl_to_prql(&root_module_def)?.into_bytes()
             }
@@ -302,6 +303,7 @@ impl Command {
                 let mut restricted = prqlc::semantic::ast_expand::restrict_module_def(expanded);
 
                 drop_module_def(&mut restricted.stmts, "std");
+                drop_module_def(&mut restricted.stmts, "_local");
 
                 pl_to_prql(&restricted)?.into_bytes()
             }
@@ -323,6 +325,7 @@ impl Command {
                 // resolved PL, restricted back into AST
                 let mut root_module = semantic::ast_expand::restrict_module(root_module.module);
                 drop_module_def(&mut root_module.stmts, "std");
+                drop_module_def(&mut root_module.stmts, "_local");
                 out.extend(pl_to_prql(&root_module)?.into_bytes());
 
                 out
@@ -638,7 +641,10 @@ sort full
             },
             &mut SourceTree::new(
                 [
-                    ("Project.prql".into(), "orders.x | select y".to_string()),
+                    (
+                        "Project.prql".into(),
+                        "project.orders.x | select y".to_string(),
+                    ),
                     (
                         "orders.prql".into(),
                         "let x = (from db.z | select {y, u})".to_string(),
diff --git a/prqlc/prqlc/src/codegen/ast.rs b/prqlc/prqlc/src/codegen/ast.rs
index 72fd6b370ac2..924a5ef70c03 100644
--- a/prqlc/prqlc/src/codegen/ast.rs
+++ b/prqlc/prqlc/src/codegen/ast.rs
@@ -292,7 +292,12 @@ impl WriteSource for Ident {
         opt.consume_width(width as u16)?;
 
         let mut r = String::new();
-        for part in &self.path {
+
+        let mut path = &self.path[..];
+        if path.first().map_or(false, |f| f == "_local") {
+            path = &path[1..];
+        }
+        for part in path {
             r += &write_ident_part(part);
             r += ".";
         }
@@ -303,7 +308,9 @@ impl WriteSource for Ident {
 
 pub static KEYWORDS: Lazy<HashSet<&str>> = Lazy::new(|| {
     HashSet::from_iter([
-        "let", "into", "case", "prql", "type", "module", "internal", "func",
+        "let", "into", "case", "prql", "type", "internal",
+        "func",
+        // "module" can be both keyword and ident
     ])
 });
 
diff --git a/prqlc/prqlc/src/ir/decl.rs b/prqlc/prqlc/src/ir/decl.rs
index adddd0724e7b..27f948951a86 100644
--- a/prqlc/prqlc/src/ir/decl.rs
+++ b/prqlc/prqlc/src/ir/decl.rs
@@ -37,11 +37,17 @@ pub struct Module {
 
     /// A declaration that has been shadowed (overwritten) by this module.
     pub shadowed: Option<Box<Decl>>,
+
+    /// When a reference into this module does not exist, this declaration will
+    /// be instantiated instead.
+    pub infer_decl: Option<Box<Decl>>,
 }
 
-/// A struct containing information about a single declaration.
+/// A struct containing information about a single declaration
+/// within a PRQL module.
 #[derive(Debug, PartialEq, Default, Serialize, Deserialize, Clone)]
 pub struct Decl {
+    // TODO: make this plain usize, it is populated at creation anyway
     #[serde(skip_serializing_if = "Option::is_none")]
     pub declared_at: Option<usize>,
 
@@ -56,7 +62,7 @@ pub struct Decl {
     pub annotations: Vec<Annotation>,
 }
 
-/// The Declaration itself.
+/// Declaration kind.
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone, EnumAsInner)]
 pub enum DeclKind {
     /// A nested namespace
@@ -85,6 +91,11 @@ pub enum DeclKind {
 
     /// Equivalent to the declaration pointed to by the fully qualified ident
     Import(Ident),
+
+    /// A declaration that has not yet been resolved.
+    /// Created during the first pass of the AST, must not be present in
+    /// a fully resolved module structure.
+    Unresolved(StmtKind),
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
@@ -163,6 +174,7 @@ impl Default for DeclKind {
     }
 }
 
+// TODO: convert to Decl::new
 impl From<DeclKind> for Decl {
     fn from(kind: DeclKind) -> Self {
         Decl {
@@ -199,6 +211,7 @@ impl std::fmt::Display for DeclKind {
             Self::Ty(arg0) => write!(f, "Ty: {}", write_ty(arg0)),
             Self::QueryDef(_) => write!(f, "QueryDef"),
             Self::Import(arg0) => write!(f, "Import {arg0}"),
+            Self::Unresolved(_) => write!(f, "Unresolved"),
         }
     }
 }
diff --git a/prqlc/prqlc/src/ir/pl/fold.rs b/prqlc/prqlc/src/ir/pl/fold.rs
index 2617191b294b..7ecf0a1e1640 100644
--- a/prqlc/prqlc/src/ir/pl/fold.rs
+++ b/prqlc/prqlc/src/ir/pl/fold.rs
@@ -277,13 +277,18 @@ pub fn fold_transform_kind<T: ?Sized + PlFold>(
 
 pub fn fold_func<T: ?Sized + PlFold>(fold: &mut T, func: Func) -> Result<Func> {
     Ok(Func {
+        name_hint: func.name_hint,
         body: Box::new(fold.fold_expr(*func.body)?),
         args: func
             .args
             .into_iter()
             .map(|item| fold.fold_expr(item))
             .try_collect()?,
-        ..func
+        return_ty: fold_type_opt(fold, func.return_ty)?,
+        params: fold_func_param(fold, func.params)?,
+        named_params: fold_func_param(fold, func.named_params)?,
+        generic_type_params: func.generic_type_params, // recurse into this too?
+        env: func.env,                                 // recurse into this too?
     })
 }
 
@@ -295,8 +300,9 @@ pub fn fold_func_param<T: ?Sized + PlFold>(
         .into_iter()
         .map(|param| {
             Ok(FuncParam {
+                name: param.name,
+                ty: fold_type_opt(fold, param.ty)?,
                 default_value: fold_optional_box(fold, param.default_value)?,
-                ..param
             })
         })
         .try_collect()
diff --git a/prqlc/prqlc/src/semantic/ast_expand.rs b/prqlc/prqlc/src/semantic/ast_expand.rs
index 950ec1875333..051f1507b700 100644
--- a/prqlc/prqlc/src/semantic/ast_expand.rs
+++ b/prqlc/prqlc/src/semantic/ast_expand.rs
@@ -9,6 +9,8 @@ use crate::ir::pl::{self, new_binop};
 use crate::semantic::{NS_THAT, NS_THIS};
 use crate::{Error, Result};
 
+use super::NS_LOCAL;
+
 /// An AST pass that maps AST to PL.
 pub fn expand_expr(expr: Expr) -> Result<pl::Expr> {
     let kind = match expr.kind {
@@ -306,7 +308,13 @@ fn restrict_exprs(exprs: Vec<pl::Expr>) -> Vec<Expr> {
 fn restrict_expr_kind(value: pl::ExprKind) -> ExprKind {
     match value {
         pl::ExprKind::Ident(v) => {
+            // HACK: remove the '_local' prefix
+            let skip_first = v.starts_with_part(NS_LOCAL);
+
             let mut parts = v.into_iter();
+            if skip_first {
+                parts.next();
+            }
             let mut base = Box::new(Expr::new(ExprKind::Ident(parts.next().unwrap())));
             for part in parts {
                 let field = IndirectionKind::Name(part);
@@ -508,6 +516,7 @@ fn restrict_decl(name: String, value: decl::Decl) -> Option<Stmt> {
         }
         decl::DeclKind::Column(id) => new_internal_stmt(name, format!("column.{id}")),
         decl::DeclKind::Infer(_) => new_internal_stmt(name, "infer".to_string()),
+        decl::DeclKind::Unresolved(_) => new_internal_stmt(name, "unresolved".to_string()),
 
         decl::DeclKind::Expr(mut expr) => StmtKind::VarDef(VarDef {
             kind: VarDefKind::Let,
diff --git a/prqlc/prqlc/src/semantic/lowering.rs b/prqlc/prqlc/src/semantic/lowering.rs
index aa5bdfee4266..cff71f348951 100644
--- a/prqlc/prqlc/src/semantic/lowering.rs
+++ b/prqlc/prqlc/src/semantic/lowering.rs
@@ -855,6 +855,7 @@ impl Lowerer {
                     );
                 }
             }
+
             pl::ExprKind::Literal(literal) => rq::ExprKind::Literal(literal),
 
             pl::ExprKind::SString(items) => {
diff --git a/prqlc/prqlc/src/semantic/mod.rs b/prqlc/prqlc/src/semantic/mod.rs
index 6c7ad94f634f..3ec81b8cb8c3 100644
--- a/prqlc/prqlc/src/semantic/mod.rs
+++ b/prqlc/prqlc/src/semantic/mod.rs
@@ -5,6 +5,7 @@ mod eval;
 mod lowering;
 mod module;
 pub mod reporting;
+mod resolve_decls;
 mod resolver;
 
 use self::resolver::Resolver;
@@ -14,7 +15,7 @@ pub use lowering::lower_to_ir;
 
 use crate::ast;
 use crate::ir::constant::ConstExpr;
-use crate::ir::decl::{Module, RootModule};
+use crate::ir::decl::RootModule;
 use crate::ir::pl::{self, Expr, ImportDef, ModuleDef, Stmt, StmtKind, TypeDef, VarDef};
 use crate::ir::rq::RelationalQuery;
 use crate::parser::is_mod_def_for;
@@ -42,15 +43,18 @@ pub fn resolve(mut module_tree: ast::ModuleDef, options: ResolverOptions) -> Res
     // expand AST into PL
     let root_module_def = ast_expand::expand_module_def(module_tree)?;
 
-    // init new root module
-    let mut root_module = RootModule {
-        module: Module::new_root(),
-        ..Default::default()
-    };
+    // init the module structure
+    let mut root_module = resolve_decls::init_module_tree(root_module_def);
+
+    // resolve name references between declarations
+    let resolution_order = resolve_decls::resolve_decl_refs(&mut root_module)?;
+
+    // resolve
     let mut resolver = Resolver::new(&mut root_module, options);
 
-    // resolve the module def into the root module
-    resolver.fold_statements(root_module_def.stmts)?;
+    for decl_fq in resolution_order {
+        resolver.resolve_decl(decl_fq)?;
+    }
 
     Ok(root_module)
 }
@@ -99,6 +103,7 @@ pub const NS_PARAM: &str = "_param";
 pub const NS_DEFAULT_DB: &str = "db";
 pub const NS_QUERY_DEF: &str = "prql";
 pub const NS_MAIN: &str = "main";
+pub const NS_LOCAL: &str = "_local";
 
 // refers to the containing module (direct parent)
 pub const NS_SELF: &str = "_self";
diff --git a/prqlc/prqlc/src/semantic/module.rs b/prqlc/prqlc/src/semantic/module.rs
index 86598e88ff87..bd8180867c0e 100644
--- a/prqlc/prqlc/src/semantic/module.rs
+++ b/prqlc/prqlc/src/semantic/module.rs
@@ -4,12 +4,12 @@ use crate::ast::QueryDef;
 use crate::ast::{Literal, Span, Ty, TyKind, TyTupleField};
 use crate::Result;
 
-use crate::ir::pl::{Annotation, Expr, Ident, Lineage, LineageColumn};
+use crate::ir::pl::{Expr, Ident, Lineage, LineageColumn};
 use crate::Error;
 
 use super::{
-    NS_DEFAULT_DB, NS_GENERIC, NS_INFER, NS_INFER_MODULE, NS_MAIN, NS_PARAM, NS_QUERY_DEF, NS_SELF,
-    NS_STD, NS_THAT, NS_THIS,
+    NS_DEFAULT_DB, NS_GENERIC, NS_INFER, NS_INFER_MODULE, NS_LOCAL, NS_MAIN, NS_PARAM,
+    NS_QUERY_DEF, NS_SELF, NS_STD, NS_THAT, NS_THIS,
 };
 use crate::ir::decl::{Decl, DeclKind, Module, RootModule, TableDecl, TableExpr};
 
@@ -31,40 +31,101 @@ impl Module {
                     Decl::from(DeclKind::Module(Module::new_database())),
                 ),
                 (NS_STD.to_string(), Decl::from(DeclKind::default())),
+                (
+                    NS_LOCAL.to_string(),
+                    Decl::from(DeclKind::Module(Module {
+                        names: HashMap::from_iter(
+                            [
+                                "array",
+                                "scalar",
+                                "tuple",
+                                "range",
+                                "relation",
+                                "transform",
+                                // transforms
+                                "from",
+                                "select",
+                                "filter",
+                                "derive",
+                                "aggregate",
+                                "sort",
+                                "take",
+                                "join",
+                                "group",
+                                "window",
+                                "append",
+                                "intersect",
+                                "remove",
+                                "loop",
+                                // agg
+                                "min",
+                                "max",
+                                "sum",
+                                "average",
+                                "stddev",
+                                "all",
+                                "any",
+                                "concat_array",
+                                "count",
+                                "count_distinct",
+                                "lag",
+                                "lead",
+                                "first",
+                                "last",
+                                "rank",
+                                "rank_dense",
+                                "row_number",
+                                // utils
+                                "in",
+                                "as",
+                            ]
+                            .into_iter()
+                            .map(|s| {
+                                (
+                                    s.to_string(),
+                                    Decl::from(DeclKind::Import(Ident::from_path(vec!["std", s]))),
+                                )
+                            }),
+                        ),
+                        shadowed: None,
+                        redirects: vec![
+                            Ident::from_name(NS_THIS),
+                            Ident::from_name(NS_THAT),
+                            Ident::from_name(NS_PARAM),
+                            Ident::from_name(NS_GENERIC),
+                        ],
+                        infer_decl: None,
+                    })),
+                ),
             ]),
             shadowed: None,
-            redirects: vec![
-                Ident::from_name(NS_THIS),
-                Ident::from_name(NS_THAT),
-                Ident::from_name(NS_PARAM),
-                Ident::from_name(NS_STD),
-                Ident::from_name(NS_GENERIC),
-            ],
+            redirects: vec![],
+            infer_decl: None,
         }
     }
 
     pub fn new_database() -> Module {
+        let table_decl = DeclKind::TableDecl(TableDecl {
+            ty: Some(Ty::relation(vec![TyTupleField::Wildcard(None)])),
+            expr: TableExpr::LocalTable,
+        });
+
         let names = HashMap::from([
             (
                 NS_INFER.to_string(),
-                Decl::from(DeclKind::Infer(Box::new(DeclKind::TableDecl(TableDecl {
-                    ty: Some(Ty::relation(vec![TyTupleField::Wildcard(None)])),
-                    expr: TableExpr::LocalTable,
-                })))),
+                Decl::from(DeclKind::Infer(Box::new(table_decl.clone()))),
             ),
             (
                 NS_INFER_MODULE.to_string(),
-                Decl::from(DeclKind::Infer(Box::new(DeclKind::Module(Module {
-                    names: HashMap::new(),
-                    redirects: vec![],
-                    shadowed: None,
-                })))),
+                Decl::from(DeclKind::Infer(Box::new(DeclKind::Module(
+                    Module::default(),
+                )))),
             ),
         ]);
         Module {
             names,
-            shadowed: None,
-            redirects: vec![],
+            infer_decl: Some(Box::new(Decl::from(table_decl))),
+            ..Default::default()
         }
     }
 
@@ -137,6 +198,35 @@ impl Module {
         ns.names.get(&fq_ident.name)
     }
 
+    pub fn get_submodule(&self, path: &[String]) -> Option<&Module> {
+        let mut curr_mod = self;
+        for step in path {
+            let decl = curr_mod.names.get(step)?;
+            curr_mod = decl.kind.as_module()?;
+        }
+        Some(curr_mod)
+    }
+
+    pub fn get_submodule_mut(&mut self, path: &[String]) -> Option<&mut Module> {
+        let mut curr_mod = self;
+        for step in path {
+            let decl = curr_mod.names.get_mut(step)?;
+            curr_mod = decl.kind.as_module_mut()?;
+        }
+        Some(curr_mod)
+    }
+
+    pub fn get_module_path(&self, path: &[String]) -> Option<Vec<&Module>> {
+        let mut res = vec![self];
+        for step in path {
+            let decl = res.last().unwrap().names.get(step)?;
+            let module = decl.kind.as_module()?;
+            res.push(module);
+        }
+
+        Some(res)
+    }
+
     pub fn lookup(&self, ident: &Ident) -> HashSet<Ident> {
         fn lookup_in(module: &Module, ident: Ident) -> HashSet<Ident> {
             let (prefix, ident) = ident.pop_front();
@@ -206,7 +296,10 @@ impl Module {
                 LineageColumn::All { input_id, .. } => {
                     lineage.find_input(*input_id).map(|i| &i.name)
                 }
-                LineageColumn::Single { name, .. } => name.as_ref().and_then(|n| n.path.first()),
+                LineageColumn::Single { name, .. } => name
+                    .as_ref()
+                    .and_then(|n| n.path.first())
+                    .filter(|x| x.as_str() != NS_THIS),
             };
 
             // get or create input namespace
@@ -425,28 +518,14 @@ fn decl_has_annotation(decl: &Decl, annotation_name: &Ident) -> bool {
 type HintAndSpan = (Option<String>, Option<Span>);
 
 impl RootModule {
-    pub(super) fn declare(
-        &mut self,
-        ident: Ident,
-        decl: DeclKind,
-        id: Option<usize>,
-        annotations: Vec<Annotation>,
-    ) -> Result<()> {
-        let existing = self.module.get(&ident);
-        if existing.is_some() {
-            return Err(Error::new_simple(format!(
-                "duplicate declarations of {ident}"
-            )));
-        }
+    pub fn local(&self) -> &Module {
+        let decl = self.module.names.get(NS_LOCAL).unwrap();
+        decl.kind.as_module().unwrap()
+    }
 
-        let decl = Decl {
-            kind: decl,
-            declared_at: id,
-            order: 0,
-            annotations,
-        };
-        self.module.insert(ident, decl).unwrap();
-        Ok(())
+    pub fn local_mut(&mut self) -> &mut Module {
+        let decl = self.module.names.get_mut(NS_LOCAL).unwrap();
+        decl.kind.as_module_mut().unwrap()
     }
 
     /// Finds that main pipeline given a path to either main itself or its parent module.
diff --git a/prqlc/prqlc/src/semantic/reporting.rs b/prqlc/prqlc/src/semantic/reporting.rs
index 1b8c85060fc0..90f0b4e38358 100644
--- a/prqlc/prqlc/src/semantic/reporting.rs
+++ b/prqlc/prqlc/src/semantic/reporting.rs
@@ -86,6 +86,7 @@ impl<'a> PlFold for Labeler<'a> {
                         DeclKind::Infer(_) => Color::White,
                         DeclKind::QueryDef(_) => Color::White,
                         DeclKind::Import(_) => Color::White,
+                        DeclKind::Unresolved(_) => Color::White,
                     };
 
                     let location = decl
diff --git a/prqlc/prqlc/src/semantic/resolve_decls/init_modules.rs b/prqlc/prqlc/src/semantic/resolve_decls/init_modules.rs
new file mode 100644
index 000000000000..11761d048394
--- /dev/null
+++ b/prqlc/prqlc/src/semantic/resolve_decls/init_modules.rs
@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use crate::ast;
+use crate::ir::decl;
+use crate::ir::pl;
+use crate::utils::IdGenerator;
+use crate::Span;
+
+pub fn init_module_tree(root_module_def: pl::ModuleDef) -> decl::RootModule {
+    let mut root = decl::Module::new_root();
+
+    let mut ctx = Context {
+        span_map: Default::default(),
+        id: IdGenerator::new(),
+    };
+
+    ctx.populate_module(&mut root, root_module_def.stmts);
+
+    decl::RootModule {
+        module: root,
+        span_map: ctx.span_map,
+    }
+}
+
+struct Context {
+    span_map: HashMap<usize, Span>,
+    id: IdGenerator<usize>,
+}
+
+impl Context {
+    fn populate_module(&mut self, module: &mut decl::Module, stmts: Vec<pl::Stmt>) {
+        for (index, stmt) in stmts.into_iter().enumerate() {
+            let id = self.id.gen();
+            if let Some(span) = stmt.span {
+                self.span_map.insert(id, span);
+            }
+
+            let name = stmt.name().to_string();
+
+            let kind = match stmt.kind {
+                pl::StmtKind::ModuleDef(module_def) => {
+                    // init new module and recurse
+                    let mut new_mod = decl::Module::default();
+                    self.populate_module(&mut new_mod, module_def.stmts);
+
+                    decl::DeclKind::Module(new_mod)
+                }
+                mut kind => {
+                    // insert "DeclKind::Unresolved"
+
+                    // hack: add type annotation to `main` var defs
+                    if let pl::StmtKind::VarDef(def) = &mut kind {
+                        if def.name == "main" && def.ty.is_none() {
+                            def.ty = Some(ast::Ty::new(ast::TyKind::Ident(ast::Ident::from_path(
+                                vec!["std", "relation"],
+                            ))));
+                        }
+                    }
+
+                    decl::DeclKind::Unresolved(kind)
+                }
+            };
+            let decl = decl::Decl {
+                declared_at: Some(id),
+                kind,
+                order: index + 1,
+                annotations: stmt.annotations,
+            };
+            module.names.insert(name, decl);
+        }
+    }
+}
diff --git a/prqlc/prqlc/src/semantic/resolve_decls/mod.rs b/prqlc/prqlc/src/semantic/resolve_decls/mod.rs
new file mode 100644
index 000000000000..585037bc7848
--- /dev/null
+++ b/prqlc/prqlc/src/semantic/resolve_decls/mod.rs
@@ -0,0 +1,5 @@
+mod init_modules;
+mod names;
+
+pub use init_modules::init_module_tree;
+pub use names::resolve_decl_refs;
diff --git a/prqlc/prqlc/src/semantic/resolve_decls/names.rs b/prqlc/prqlc/src/semantic/resolve_decls/names.rs
new file mode 100644
index 000000000000..a7f1473bff1a
--- /dev/null
+++ b/prqlc/prqlc/src/semantic/resolve_decls/names.rs
@@ -0,0 +1,291 @@
+use itertools::Itertools;
+
+use crate::ir::decl;
+use crate::ir::pl::{self, ImportDef, PlFold};
+use crate::semantic::{NS_DEFAULT_DB, NS_LOCAL, NS_STD, NS_THIS};
+use crate::{ast, utils, Error};
+use crate::{Result, WithErrorInfo};
+
+/// Runs name resolution for global names - names that refer to declarations.
+///
+/// Keeps track of all inter-declaration references.
+/// Returns a resolution order.
+pub fn resolve_decl_refs(root: &mut decl::RootModule) -> Result<Vec<pl::Ident>> {
+    // resolve inter-declaration references
+    let refs = {
+        let mut r = ModuleRefResolver {
+            root,
+            refs: Default::default(),
+            current_path: Vec::new(),
+        };
+        r.resolve_refs()?;
+        r.refs
+    };
+
+    // HACK: put std.* declarations first
+    // this is needed because during compilation of transforms, we inject refs to "std.lte" and a few others
+    // sorting here makes std decls appear first in the final ordering
+    let mut refs = refs;
+    refs.sort_by_key(|(a, _)| !a.path.first().map_or(false, |p| p == "std"));
+
+    // toposort the declarations
+    // TODO: we might not need to compile all declarations if they are not used
+    //   to prevent that, this start should be something else than None
+    //   a list of all public declarations?
+    // let main = pl::Ident::from_name("main");
+    let order = utils::toposort::<ast::Ident>(&refs, None);
+
+    if let Some(order) = order {
+        Ok(order.into_iter().cloned().collect_vec())
+    } else {
+        todo!("error for a cyclic references between expressions")
+    }
+}
+
+/// Traverses module tree and runs name resolution on each of the declarations.
+/// Collects references of each declaration.
+struct ModuleRefResolver<'a> {
+    root: &'a mut decl::RootModule,
+    current_path: Vec<String>,
+
+    // TODO: maybe make these ids, instead of Ident?
+    refs: Vec<(ast::Ident, Vec<ast::Ident>)>,
+}
+
+impl ModuleRefResolver<'_> {
+    fn resolve_refs(&mut self) -> Result<()> {
+        let path = &mut self.current_path;
+        let module = self.root.module.get_submodule_mut(path).unwrap();
+
+        let mut submodules = Vec::new();
+        let mut unresolved_decls = Vec::new();
+        for (name, decl) in &module.names {
+            match &decl.kind {
+                decl::DeclKind::Module(_) => {
+                    submodules.push(name.clone());
+                }
+                decl::DeclKind::Unresolved(_) => {
+                    unresolved_decls.push(name.clone());
+                }
+                _ => {}
+            }
+        }
+
+        for name in unresolved_decls {
+            // take the decl out of the module tree
+            let mut decl = {
+                let submodule = self.root.module.get_submodule_mut(path).unwrap();
+                submodule.names.remove(&name).unwrap()
+            };
+            let span = decl
+                .declared_at
+                .and_then(|x| self.root.span_map.get(&x))
+                .cloned();
+
+            // resolve the decl
+            path.push(name);
+            let mut r = NameResolver {
+                root: self.root,
+                decl_module_path: &path[0..(path.len() - 1)],
+                refs: Vec::new(),
+            };
+
+            let stmt = decl.kind.into_unresolved().unwrap();
+            let stmt = r.fold_stmt_kind(stmt).with_span_fallback(span)?;
+            decl.kind = decl::DeclKind::Unresolved(stmt);
+
+            let decl_ident = pl::Ident::from_path(path.clone());
+            self.refs.push((decl_ident, r.refs));
+
+            let name = path.pop().unwrap();
+
+            // put the decl back in
+            {
+                let submodule = self.root.module.get_submodule_mut(path).unwrap();
+                submodule.names.insert(name, decl);
+            };
+        }
+
+        for name in submodules {
+            self.current_path.push(name);
+            self.resolve_refs()?;
+            self.current_path.pop();
+        }
+        Ok(())
+    }
+}
+
+/// Traverses AST and resolves all global (non-local) identifiers.
+struct NameResolver<'a> {
+    root: &'a decl::RootModule,
+    decl_module_path: &'a [String],
+    refs: Vec<pl::Ident>,
+}
+
+impl NameResolver<'_> {
+    fn fold_stmt_kind(&mut self, stmt: pl::StmtKind) -> Result<pl::StmtKind> {
+        Ok(match stmt {
+            pl::StmtKind::QueryDef(_) => stmt,
+            pl::StmtKind::VarDef(var_def) => pl::StmtKind::VarDef(self.fold_var_def(var_def)?),
+            pl::StmtKind::TypeDef(ty_def) => pl::StmtKind::TypeDef(self.fold_type_def(ty_def)?),
+            pl::StmtKind::ImportDef(import_def) => {
+                pl::StmtKind::ImportDef(self.fold_import_def(import_def)?)
+            }
+            pl::StmtKind::ModuleDef(_) => unreachable!(),
+        })
+    }
+
+    fn fold_import_def(&mut self, import_def: ImportDef) -> Result<pl::ImportDef, Error> {
+        let (fq_ident, indirections) = self.resolve_ident(import_def.name)?;
+        if !indirections.is_empty() {
+            return Err(Error::new_simple(
+                "Import can only reference modules and declarations",
+            ));
+        }
+        Ok(ImportDef {
+            name: fq_ident,
+            alias: import_def.alias,
+        })
+    }
+}
+
+impl pl::PlFold for NameResolver<'_> {
+    fn fold_expr(&mut self, expr: pl::Expr) -> Result<pl::Expr> {
+        Ok(match expr.kind {
+            pl::ExprKind::Ident(ident) => {
+                let (ident, indirections) = self.resolve_ident(ident).with_span(expr.span)?;
+
+                // TODO: hack for until indirections are implemented: convert back to ident
+                let ident = ast::Ident::from_path(ident.into_iter().chain(indirections).collect());
+
+                // for indirection in indirections {
+                //     r = pl::Expr::new(pl::ExprKind::Indirection {
+                //         base: Box::new(r),
+                //         field: indirection,
+                //     })
+                // }
+                pl::Expr {
+                    kind: pl::ExprKind::Ident(ident),
+                    ..expr
+                }
+            }
+            _ => pl::Expr {
+                kind: pl::fold_expr_kind(self, expr.kind)?,
+                ..expr
+            },
+        })
+    }
+
+    fn fold_type(&mut self, ty: ast::Ty) -> Result<ast::Ty> {
+        Ok(match ty.kind {
+            ast::TyKind::Ident(ident) => {
+                let (ident, indirections) = self.resolve_ident(ident).with_span(ty.span)?;
+
+                if !indirections.is_empty() {
+                    log::debug!("resolved type ident to : {ident} + {indirections:?}");
+                    return Err(
+                        Error::new_simple("types are not allowed indirections").with_span(ty.span)
+                    );
+                }
+
+                ast::Ty {
+                    kind: ast::TyKind::Ident(ident),
+                    ..ty
+                }
+            }
+            _ => pl::fold_type(self, ty)?,
+        })
+    }
+}
+
+impl NameResolver<'_> {
+    /// Returns resolved fully-qualified ident and a list of indirections
+    fn resolve_ident(&mut self, ident: ast::Ident) -> Result<(ast::Ident, Vec<String>)> {
+        // this is the name we are looking for
+        let first = ident.iter().next().unwrap();
+        let mod_path = match first.as_str() {
+            "project" => Some(vec![]),
+            "module" => Some(self.decl_module_path.to_vec()),
+            "super" => {
+                let mut path = self.decl_module_path.to_vec();
+                path.pop();
+                Some(path)
+            }
+
+            NS_STD => Some(vec![NS_STD.to_string()]),
+            NS_DEFAULT_DB => Some(vec![NS_DEFAULT_DB.to_string()]),
+            NS_THIS => Some(vec![NS_LOCAL.to_string(), NS_THIS.to_string()]),
+            "prql" => Some(vec![NS_STD.to_string(), "prql".to_string()]),
+            _ => None,
+        };
+        let mod_decl = mod_path
+            .as_ref()
+            .and_then(|p| self.root.module.get_submodule(p));
+
+        // let decl = find_lookup_base(&self.root.module, self.decl_module_path, name);
+        let (ident, indirections) = if let Some(module) = mod_decl {
+            let mod_path = mod_path.unwrap();
+            // module found
+
+            // now find the decl within that module
+            let mut ident_within = ident;
+            ident_within = ident_within.pop_front().1.unwrap();
+            let (_, path, indirections) = lookup_within_module(module, ident_within)?;
+
+            // prepend the ident with the module path
+            // this will make this ident a fully-qualified ident
+            let mut fq_ident = mod_path;
+            fq_ident.extend(path);
+            let fq_ident = ast::Ident::from_path(fq_ident);
+
+            self.refs.push(fq_ident.clone());
+
+            (fq_ident, indirections)
+        } else {
+            // cannot find module, so this must be a ref to a local var + indirections
+            let mut steps = ident.into_iter();
+            let first = steps.next().unwrap();
+            let indirections = steps.collect_vec();
+            (
+                ast::Ident::from_path(vec![NS_LOCAL.to_string(), first]),
+                indirections,
+            )
+        };
+        Ok((ident, indirections))
+    }
+}
+
+fn lookup_within_module(
+    module: &decl::Module,
+    ident_within: ast::Ident,
+) -> Result<(&decl::Decl, Vec<String>, Vec<String>)> {
+    let mut steps = ident_within.into_iter().collect_vec();
+
+    let mut module = module;
+    for i in 0..steps.len() {
+        let decl = match module.names.get(&steps[i]) {
+            Some(decl) => decl,
+            _ => {
+                if let Some(decl) = &module.infer_decl {
+                    // declaration was not found, but this module will infer the decl
+                    decl.as_ref()
+                } else {
+                    // declaration not found
+                    return Err(Error::new_simple(format!("`{}` does not exist", steps[i])));
+                }
+            }
+        };
+
+        match &decl.kind {
+            decl::DeclKind::Module(inner) => {
+                module = inner;
+            }
+            _ => {
+                let indirections = steps.drain((i + 1)..).collect_vec();
+                return Ok((decl, steps, indirections));
+            }
+        }
+    }
+
+    Err(Error::new_simple("direct references modules not allowed"))
+}
diff --git a/prqlc/prqlc/src/semantic/resolver/expr.rs b/prqlc/prqlc/src/semantic/resolver/expr.rs
index b11a8a69f73b..d86912df49cd 100644
--- a/prqlc/prqlc/src/semantic/resolver/expr.rs
+++ b/prqlc/prqlc/src/semantic/resolver/expr.rs
@@ -5,7 +5,7 @@ use crate::ast::{Ty, TyKind, TyTupleField};
 use crate::ir::decl::{DeclKind, Module};
 use crate::ir::pl::*;
 use crate::semantic::resolver::{flatten, types, Resolver};
-use crate::semantic::{NS_INFER, NS_SELF, NS_THAT, NS_THIS};
+use crate::semantic::{NS_INFER, NS_LOCAL, NS_SELF, NS_THAT, NS_THIS};
 use crate::utils::IdGenerator;
 use crate::{Error, Reason, Span, WithErrorInfo};
 
@@ -17,24 +17,32 @@ impl PlFold for Resolver<'_> {
     fn fold_type(&mut self, ty: Ty) -> Result<Ty> {
         Ok(match ty.kind {
             TyKind::Ident(ident) => {
-                self.root_mod.module.shadow(NS_THIS);
-                self.root_mod.module.shadow(NS_THAT);
+                self.root_mod.local_mut().shadow(NS_THIS);
+                self.root_mod.local_mut().shadow(NS_THAT);
 
                 let fq_ident = self.resolve_ident(&ident)?;
 
                 let decl = self.root_mod.module.get(&fq_ident).unwrap();
                 let decl_ty = decl.kind.as_ty().ok_or_else(|| {
-                    Error::new(Reason::Expected {
-                        who: None,
-                        expected: "a type".to_string(),
-                        found: decl.to_string(),
-                    })
+                    if decl.kind.is_unresolved() {
+                        Error::new_assert(format!(
+                            "bad resolution order: unresolved {fq_ident} while resolving {}",
+                            self.debug_current_decl
+                        ))
+                    } else {
+                        Error::new(Reason::Expected {
+                            who: None,
+                            expected: "a type".to_string(),
+                            found: decl.to_string(),
+                        })
+                    }
+                    .with_span(ty.span)
                 })?;
                 let mut ty = decl_ty.clone();
                 ty.name = ty.name.or(Some(fq_ident.name));
 
-                self.root_mod.module.unshadow(NS_THIS);
-                self.root_mod.module.unshadow(NS_THAT);
+                self.root_mod.local_mut().unshadow(NS_THIS);
+                self.root_mod.local_mut().unshadow(NS_THAT);
 
                 ty
             }
@@ -141,6 +149,13 @@ impl PlFold for Resolver<'_> {
                         .with_span(*span));
                     }
 
+                    DeclKind::Unresolved(_) => {
+                        return Err(Error::new_assert(format!(
+                            "bad resolution order: unresolved {fq_ident} while resolving {}",
+                            self.debug_current_decl
+                        )));
+                    }
+
                     _ => Expr {
                         kind: ExprKind::Ident(fq_ident),
                         ..node
@@ -251,7 +266,7 @@ impl Resolver<'_> {
         let except = self.coerce_into_tuple(expr)?;
 
         self.fold_expr(Expr::new(ExprKind::All {
-            within: Box::new(Expr::new(Ident::from_name(NS_THIS))),
+            within: Box::new(Expr::new(Ident::from_path(vec![NS_LOCAL, NS_THIS]))),
             except: Box::new(except),
         }))
     }
diff --git a/prqlc/prqlc/src/semantic/resolver/functions.rs b/prqlc/prqlc/src/semantic/resolver/functions.rs
index 6bbff4886b60..bb9455670ae1 100644
--- a/prqlc/prqlc/src/semantic/resolver/functions.rs
+++ b/prqlc/prqlc/src/semantic/resolver/functions.rs
@@ -8,7 +8,7 @@ use crate::ast::{Ty, TyFunc, TyKind};
 use crate::ir::decl::{Decl, DeclKind, Module};
 use crate::ir::pl::*;
 use crate::semantic::resolver::types;
-use crate::semantic::{NS_GENERIC, NS_PARAM, NS_THAT, NS_THIS};
+use crate::semantic::{NS_GENERIC, NS_LOCAL, NS_PARAM, NS_THAT, NS_THIS};
 use crate::{Error, Span, WithErrorInfo};
 
 use super::Resolver;
@@ -51,7 +51,7 @@ impl Resolver<'_> {
 
         // push the env
         let closure_env = Module::from_exprs(closure.env);
-        self.root_mod.module.stack_push(NS_PARAM, closure_env);
+        self.root_mod.local_mut().stack_push(NS_PARAM, closure_env);
         let closure = Box::new(Func {
             env: HashMap::new(),
             ..*closure
@@ -103,7 +103,7 @@ impl Resolver<'_> {
         };
 
         // pop the env
-        self.root_mod.module.stack_pop(NS_PARAM).unwrap();
+        self.root_mod.local_mut().stack_pop(NS_PARAM).unwrap();
 
         Ok(Expr { span, ..res })
     }
@@ -114,14 +114,14 @@ impl Resolver<'_> {
 
         let (func_env, body, return_ty) = env_of_closure(*closure);
 
-        self.root_mod.module.stack_push(NS_PARAM, func_env);
+        self.root_mod.local_mut().stack_push(NS_PARAM, func_env);
 
         // fold again, to resolve inner variables & functions
         let body = self.fold_expr(body)?;
 
         // remove param decls
         log::debug!("stack_pop: {:?}", body.id);
-        let func_env = self.root_mod.module.stack_pop(NS_PARAM).unwrap();
+        let func_env = self.root_mod.local_mut().stack_pop(NS_PARAM).unwrap();
 
         Ok(if let ExprKind::Func(mut inner_closure) = body.kind {
             // body couldn't been resolved - construct a closure to be evaluated later
@@ -176,7 +176,7 @@ impl Resolver<'_> {
             // insert _generic.name declaration
             let ident = Ident::from_path(vec![NS_GENERIC, generic_param.name.as_str()]);
             let decl = Decl::from(DeclKind::Ty(Ty::new(TyKind::GenericArg(generic_id))));
-            self.root_mod.module.insert(ident, decl).unwrap();
+            self.root_mod.local_mut().insert(ident, decl).unwrap();
         }
 
         func.params = func
@@ -191,7 +191,7 @@ impl Resolver<'_> {
             .try_collect()?;
         func.return_ty = fold_type_opt(self, func.return_ty)?;
 
-        self.root_mod.module.names.remove(NS_GENERIC);
+        self.root_mod.local_mut().names.remove(NS_GENERIC);
         Ok(func)
     }
 
@@ -255,8 +255,8 @@ impl Resolver<'_> {
 
         // resolve relational args
         if has_relations {
-            self.root_mod.module.shadow(NS_THIS);
-            self.root_mod.module.shadow(NS_THAT);
+            self.root_mod.local_mut().shadow(NS_THIS);
+            self.root_mod.local_mut().shadow(NS_THAT);
 
             for (pos, (index, (param, mut arg))) in relations.into_iter().with_position() {
                 let is_last = matches!(pos, Position::Last | Position::Only);
@@ -276,9 +276,9 @@ impl Resolver<'_> {
                 if partial_application_position.is_none() {
                     let frame = arg.lineage.as_ref().unwrap();
                     if is_last {
-                        self.root_mod.module.insert_frame(frame, NS_THIS);
+                        self.root_mod.local_mut().insert_frame(frame, NS_THIS);
                     } else {
-                        self.root_mod.module.insert_frame(frame, NS_THAT);
+                        self.root_mod.local_mut().insert_frame(frame, NS_THAT);
                     }
                 }
 
@@ -300,7 +300,9 @@ impl Resolver<'_> {
                         // add aliased columns into scope
                         if let Some(alias) = field.alias.clone() {
                             let id = field.id.unwrap();
-                            self.root_mod.module.insert_frame_col(NS_THIS, alias, id);
+                            self.root_mod
+                                .local_mut()
+                                .insert_frame_col(NS_THIS, alias, id);
                         }
                         fields_new.push(field);
                     }
@@ -323,8 +325,8 @@ impl Resolver<'_> {
         }
 
         if has_relations {
-            self.root_mod.module.unshadow(NS_THIS);
-            self.root_mod.module.unshadow(NS_THAT);
+            self.root_mod.local_mut().unshadow(NS_THIS);
+            self.root_mod.local_mut().unshadow(NS_THAT);
         }
 
         Ok(if let Some(position) = partial_application_position {
@@ -425,6 +427,7 @@ fn extract_partial_application(mut func: Box<Func>, position: usize) -> Box<Func
 
     let param_name = format!("_partial_{}", arg.id.unwrap());
     let substitute_arg = Expr::new(Ident::from_path(vec![
+        NS_LOCAL.to_string(),
         NS_PARAM.to_string(),
         param_name.clone(),
     ]));
diff --git a/prqlc/prqlc/src/semantic/resolver/mod.rs b/prqlc/prqlc/src/semantic/resolver/mod.rs
index 4cd1b9212a5e..21d4cce24569 100644
--- a/prqlc/prqlc/src/semantic/resolver/mod.rs
+++ b/prqlc/prqlc/src/semantic/resolver/mod.rs
@@ -17,7 +17,7 @@ mod types;
 pub struct Resolver<'a> {
     root_mod: &'a mut RootModule,
 
-    current_module_path: Vec<String>,
+    pub debug_current_decl: crate::ast::Ident,
 
     /// Sometimes ident closures must be resolved and sometimes not. See [test::test_func_call_resolve].
     in_func_call_name: bool,
@@ -34,12 +34,16 @@ pub struct ResolverOptions {}
 
 impl Resolver<'_> {
     pub fn new(root_mod: &mut RootModule, options: ResolverOptions) -> Resolver {
+        let mut id = IdGenerator::new();
+        let max_id = root_mod.span_map.keys().max().cloned().unwrap_or(0);
+        id.skip(max_id);
+
         Resolver {
             root_mod,
             options,
-            current_module_path: Vec::new(),
+            debug_current_decl: crate::ast::Ident::from_name("?"),
             in_func_call_name: false,
-            id: IdGenerator::new(),
+            id,
             generics: Default::default(),
         }
     }
@@ -123,7 +127,7 @@ pub(super) mod test {
 
             from db.employees
             derive {
-                net_salary = subtract gross_salary tax
+                net_salary = module.subtract gross_salary tax
             }
             "#
         )
@@ -135,10 +139,10 @@ pub(super) mod test {
         assert_yaml_snapshot!(resolve_derive(
             r#"
             let lag_day = x -> s"lag_day_todo({x})"
-            let ret = x dividend_return ->  x / (lag_day x) - 1 + dividend_return
+            let ret = x dividend_return ->  x / (module.lag_day x) - 1 + dividend_return
 
             from db.a
-            derive (ret b c)
+            derive (module.ret b c)
             "#
         )
         .unwrap());
@@ -160,7 +164,7 @@ pub(super) mod test {
             let plus = x y -> x + y
 
             from db.a
-            derive {b = (sum foo | plus_one | plus 2)}
+            derive {b = (sum foo | module.plus_one | module.plus 2)}
             "#
         )
         .unwrap());
@@ -173,8 +177,8 @@ pub(super) mod test {
 
             from db.foo_table
             derive {
-                added = add_one bar to:3,
-                added_default = add_one bar
+                added = module.add_one bar to:3,
+                added_default = module.add_one bar
             }
             "#
         )
diff --git a/prqlc/prqlc/src/semantic/resolver/names.rs b/prqlc/prqlc/src/semantic/resolver/names.rs
index b15da963ddb9..a4887a3d7b2a 100644
--- a/prqlc/prqlc/src/semantic/resolver/names.rs
+++ b/prqlc/prqlc/src/semantic/resolver/names.rs
@@ -8,7 +8,9 @@ use crate::ast::Ident;
 
 use crate::ir::decl::{Decl, DeclKind, Module};
 use crate::ir::pl::{Expr, ExprKind};
-use crate::semantic::{NS_INFER, NS_INFER_MODULE, NS_SELF, NS_THAT, NS_THIS};
+use crate::semantic::{
+    NS_GENERIC, NS_INFER, NS_INFER_MODULE, NS_LOCAL, NS_PARAM, NS_SELF, NS_THAT, NS_THIS,
+};
 use crate::Error;
 use crate::WithErrorInfo;
 
@@ -16,19 +18,11 @@ use super::Resolver;
 
 impl Resolver<'_> {
     pub(super) fn resolve_ident(&mut self, ident: &Ident) -> Result<Ident, Error> {
-        let mut ident = ident.clone().prepend(self.current_module_path.clone());
-
-        let mut res = self.resolve_ident_core(&ident);
-        for _ in 0..self.current_module_path.len() {
-            if res.is_ok() {
-                break;
-            }
-            ident = ident.pop_front().1.unwrap();
-            res = self.resolve_ident_core(&ident);
-        }
+        let mut res = self.resolve_ident_core(ident);
 
         match &res {
             Ok(fq_ident) => {
+                // handle imports
                 let decl = self.root_mod.module.get(fq_ident).unwrap();
                 if let DeclKind::Import(target) = &decl.kind {
                     let target = target.clone();
@@ -36,15 +30,25 @@ impl Resolver<'_> {
                 }
             }
             Err(e) => {
-                log::debug!(
-                    "cannot resolve `{ident}`: `{e:?}`, root_mod={:#?}",
-                    self.root_mod
-                );
+                if ident.iter().next().unwrap() == NS_LOCAL {
+                    log::debug!(
+                        "cannot resolve `{ident}`: `{e:?}`,\nthis={:#?}\nthat={:#?}\n_param={:#?}\n_generic={:#?}",
+                        self.root_mod.local().names.get(NS_THIS),
+                        self.root_mod.local().names.get(NS_THAT),
+                        self.root_mod.local().names.get(NS_PARAM),
+                        self.root_mod.local().names.get(NS_GENERIC),
+                    );
+                } else {
+                    log::debug!(
+                        "cannot resolve `{ident}`: `{e:?}`, root_mod={:#?}",
+                        self.root_mod.module
+                    );
+                }
 
                 // attach available names
                 let mut available_names = Vec::new();
-                available_names.extend(self.collect_columns_in_module(NS_THIS));
-                available_names.extend(self.collect_columns_in_module(NS_THAT));
+                available_names.extend(self.collect_columns_in_a_local_module(NS_THIS));
+                available_names.extend(self.collect_columns_in_a_local_module(NS_THAT));
                 if !available_names.is_empty() {
                     let available_names = available_names.iter().map(Ident::to_string).join(", ");
                     res = res.push_hint(format!("available columns: {available_names}"));
@@ -54,10 +58,10 @@ impl Resolver<'_> {
         res
     }
 
-    fn collect_columns_in_module(&mut self, mod_name: &str) -> Vec<Ident> {
+    fn collect_columns_in_a_local_module(&mut self, mod_name: &str) -> Vec<Ident> {
         let mut cols = Vec::new();
 
-        let Some(module) = self.root_mod.module.names.get(mod_name) else {
+        let Some(module) = self.root_mod.local().names.get(mod_name) else {
             return cols;
         };
 
@@ -113,9 +117,7 @@ impl Resolver<'_> {
             Ok(inferred_ident) => Ok(inferred_ident),
 
             // Was not able to infer.
-            Err(None) => Err(Error::new_simple(
-                format!("Unknown name `{}`", &ident).to_string(),
-            )),
+            Err(None) => Err(Error::new_simple(format!("Unknown name `{ident}`"))),
             Err(Some(msg)) => Err(msg),
         }
     }
@@ -220,7 +222,7 @@ impl Resolver<'_> {
 fn ambiguous_error(idents: HashSet<Ident>, replace_name: Option<&String>) -> Error {
     let all_this = idents.iter().all(|d| d.starts_with_part(NS_THIS));
 
-    let mut chunks = Vec::new();
+    let mut candidates = Vec::new();
     for mut ident in idents {
         if all_this {
             let (_, rem) = ident.pop_front();
@@ -234,9 +236,9 @@ fn ambiguous_error(idents: HashSet<Ident>, replace_name: Option<&String>) -> Err
         if let Some(name) = replace_name {
             ident.name = name.clone();
         }
-        chunks.push(ident.to_string());
+        candidates.push(ident.to_string());
     }
-    chunks.sort();
-    let hint = format!("could be any of: {}", chunks.join(", "));
+    candidates.sort();
+    let hint = format!("could be any of: {}", candidates.join(", "));
     Error::new_simple("Ambiguous name").push_hint(hint)
 }
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_1.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_1.snap
index e3d8374dd42d..e94376d5a8a1 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_1.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_1.snap
@@ -1,15 +1,17 @@
 ---
 source: prqlc/prqlc/src/semantic/resolver/mod.rs
-expression: "resolve_derive(r#\"\n            let subtract = a b -> a - b\n\n            from employees\n            derive {\n                net_salary = subtract gross_salary tax\n            }\n            \"#).unwrap()"
+expression: "resolve_derive(r#\"\n            let subtract = a b -> a - b\n\n            from db.employees\n            derive {\n                net_salary = module.subtract gross_salary tax\n            }\n            \"#).unwrap()"
 ---
 - RqOperator:
     name: std.sub
     args:
       - Ident:
+          - _local
           - this
           - employees
           - gross_salary
       - Ident:
+          - _local
           - this
           - employees
           - tax
@@ -39,4 +41,3 @@ expression: "resolve_derive(r#\"\n            let subtract = a b -> a - b\n\n
             name: ~
     span: "0:970-1003"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_nested.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_nested.snap
index 331b0eb58ed1..88161b184c98 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_nested.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_nested.snap
@@ -1,6 +1,6 @@
 ---
 source: prqlc/prqlc/src/semantic/resolver/mod.rs
-expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo({x})\"\n            let ret = x dividend_return ->  x / (lag_day x) - 1 + dividend_return\n\n            from a\n            derive (ret b c)\n            \"#).unwrap()"
+expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo({x})\"\n            let ret = x dividend_return ->  x / (module.lag_day x) - 1 + dividend_return\n\n            from db.a\n            derive (module.ret b c)\n            \"#).unwrap()"
 ---
 - RqOperator:
     name: std.add
@@ -12,6 +12,7 @@ expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo
                 name: std.div_f
                 args:
                   - Ident:
+                      - _local
                       - this
                       - a
                       - b
@@ -20,6 +21,7 @@ expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo
                       - Expr:
                           expr:
                             Ident:
+                              - _local
                               - this
                               - a
                               - b
@@ -73,6 +75,7 @@ expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo
           span: "0:970-1003"
           name: ~
       - Ident:
+          - _local
           - this
           - a
           - c
@@ -101,4 +104,3 @@ expression: "resolve_derive(r#\"\n            let lag_day = x -> s\"lag_day_todo
             name: ~
     span: "0:893-926"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline-2.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline-2.snap
index a4a2435a6848..aaa4812edeac 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline-2.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline-2.snap
@@ -1,6 +1,6 @@
 ---
 source: prqlc/prqlc/src/semantic/resolver/mod.rs
-expression: "resolve_derive(r#\"\n            let plus_one = x -> x + 1\n            let plus = x y -> x + y\n\n            from db.a\n            derive {b = (sum foo | plus_one | plus 2)}\n            \"#).unwrap()"
+expression: "resolve_derive(r#\"\n            let plus_one = x -> x + 1\n            let plus = x y -> x + y\n\n            from db.a\n            derive {b = (sum foo | module.plus_one | module.plus 2)}\n            \"#).unwrap()"
 ---
 - RqOperator:
     name: std.add
@@ -19,6 +19,7 @@ expression: "resolve_derive(r#\"\n            let plus_one = x -> x + 1\n
                 name: std.sum
                 args:
                   - Ident:
+                      - _local
                       - this
                       - a
                       - foo
@@ -36,14 +37,14 @@ expression: "resolve_derive(r#\"\n            let plus_one = x -> x + 1\n
                     - - ~
                       - kind:
                           Primitive: Int
-                        span: "0:4052-4055"
+                        span: "0:4279-4282"
                         name: ~
                     - - ~
                       - kind:
                           Primitive: Float
-                        span: "0:4059-4064"
+                        span: "0:4286-4291"
                         name: ~
-                span: "0:4052-4064"
+                span: "0:4279-4291"
                 name: ~
             - Literal:
                 Integer: 1
@@ -103,4 +104,3 @@ expression: "resolve_derive(r#\"\n            let plus_one = x -> x + 1\n
             name: ~
     span: "0:893-926"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline.snap
index 79229a47473d..b544b2ec87a3 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__functions_pipeline.snap
@@ -6,6 +6,7 @@ expression: "resolve_derive(r#\"\n            from db.a\n            derive one
     name: std.sum
     args:
       - Ident:
+          - _local
           - this
           - a
           - foo
@@ -24,13 +25,12 @@ expression: "resolve_derive(r#\"\n            from db.a\n            derive one
         - - ~
           - kind:
               Primitive: Int
-            span: "0:4052-4055"
+            span: "0:4279-4282"
             name: ~
         - - ~
           - kind:
               Primitive: Float
-            span: "0:4059-4064"
+            span: "0:4286-4291"
             name: ~
-    span: "0:4052-4064"
+    span: "0:4279-4291"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__named_args.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__named_args.snap
index 6ea582d6b261..fc6f5be3b719 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__named_args.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__named_args.snap
@@ -1,11 +1,12 @@
 ---
 source: prqlc/prqlc/src/semantic/resolver/mod.rs
-expression: "resolve_derive(r#\"\n            let add_one = x to:1 -> x + to\n\n            from foo_table\n            derive {\n                added = add_one bar to:3,\n                added_default = add_one bar\n            }\n            \"#).unwrap()"
+expression: "resolve_derive(r#\"\n            let add_one = x to:1 -> x + to\n\n            from db.foo_table\n            derive {\n                added = module.add_one bar to:3,\n                added_default = module.add_one bar\n            }\n            \"#).unwrap()"
 ---
 - RqOperator:
     name: std.add
     args:
       - Ident:
+          - _local
           - this
           - foo_table
           - bar
@@ -46,6 +47,7 @@ expression: "resolve_derive(r#\"\n            let add_one = x to:1 -> x + to\n\n
     name: std.add
     args:
       - Ident:
+          - _local
           - this
           - foo_table
           - bar
@@ -82,4 +84,3 @@ expression: "resolve_derive(r#\"\n            let add_one = x to:1 -> x + to\n\n
             name: ~
     span: "0:893-926"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__variables_1.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__variables_1.snap
index f4027b3e9a8a..0ed9228dce6a 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__variables_1.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__test__variables_1.snap
@@ -1,15 +1,17 @@
 ---
 source: prqlc/prqlc/src/semantic/resolver/mod.rs
-expression: "resolve_derive(r#\"\n            from employees\n            derive {\n                gross_salary = salary + payroll_tax,\n                gross_cost =   gross_salary + benefits_cost\n            }\n            \"#).unwrap()"
+expression: "resolve_derive(r#\"\n            from db.employees\n            derive {\n                gross_salary = salary + payroll_tax,\n                gross_cost =   gross_salary + benefits_cost\n            }\n            \"#).unwrap()"
 ---
 - RqOperator:
     name: std.add
     args:
       - Ident:
+          - _local
           - this
           - employees
           - salary
       - Ident:
+          - _local
           - this
           - employees
           - payroll_tax
@@ -43,9 +45,11 @@ expression: "resolve_derive(r#\"\n            from employees\n            derive
     name: std.add
     args:
       - Ident:
+          - _local
           - this
           - gross_salary
       - Ident:
+          - _local
           - this
           - employees
           - benefits_cost
@@ -75,4 +79,3 @@ expression: "resolve_derive(r#\"\n            from employees\n            derive
             name: ~
     span: "0:893-926"
     name: ~
-
diff --git a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__transforms__tests__aggregate_positional_arg-2.snap b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__transforms__tests__aggregate_positional_arg-2.snap
index d34a0a105a80..cdc43bcb4bfa 100644
--- a/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__transforms__tests__aggregate_positional_arg-2.snap
+++ b/prqlc/prqlc/src/semantic/resolver/snapshots/prqlc__semantic__resolver__transforms__tests__aggregate_positional_arg-2.snap
@@ -18,7 +18,7 @@ TransformCall:
                   name: ~
           span: "0:2042-2053"
           name: tuple
-      span: "0:2158-2165"
+      span: "0:2166-2180"
       name: relation
     lineage:
       columns:
@@ -39,6 +39,7 @@ TransformCall:
               name: std.average
               args:
                 - Ident:
+                    - _local
                     - this
                     - c_invoice
                     - amount
@@ -56,14 +57,14 @@ TransformCall:
                   - - ~
                     - kind:
                         Primitive: Float
-                      span: "0:4117-4122"
+                      span: "0:4344-4349"
                       name: ~
                   - - ~
                     - kind:
                         Singleton: "Null"
-                      span: "0:4126-4130"
+                      span: "0:4353-4357"
                       name: ~
-              span: "0:4117-4130"
+              span: "0:4344-4357"
               name: ~
         ty:
           kind:
@@ -75,20 +76,21 @@ TransformCall:
                         - - ~
                           - kind:
                               Primitive: Float
-                            span: "0:4117-4122"
+                            span: "0:4344-4349"
                             name: ~
                         - - ~
                           - kind:
                               Singleton: "Null"
-                            span: "0:4126-4130"
+                            span: "0:4353-4357"
                             name: ~
-                    span: "0:4117-4130"
+                    span: "0:4344-4357"
                     name: ~
           span: ~
           name: ~
   partition:
     Tuple:
       - Ident:
+          - _local
           - this
           - c_invoice
           - issued_at
@@ -149,7 +151,7 @@ TransformCall:
                           name: ~
                   span: "0:2042-2053"
                   name: tuple
-          span: "0:2981-2996"
+          span: "0:3072-3098"
           name: ~
     ty:
       kind:
@@ -212,7 +214,7 @@ TransformCall:
                                 name: ~
                         span: "0:2042-2053"
                         name: tuple
-                span: "0:2981-2996"
+                span: "0:3072-3098"
                 name: ~
       span: ~
       name: ~
@@ -279,7 +281,7 @@ ty:
                                 name: ~
                         span: "0:2042-2053"
                         name: tuple
-                span: "0:2981-2996"
+                span: "0:3072-3098"
                 name: ~
           - Single:
               - ~
@@ -288,14 +290,14 @@ ty:
                     - - ~
                       - kind:
                           Primitive: Float
-                        span: "0:4117-4122"
+                        span: "0:4344-4349"
                         name: ~
                     - - ~
                       - kind:
                           Singleton: "Null"
-                        span: "0:4126-4130"
+                        span: "0:4353-4357"
                         name: ~
-                span: "0:4117-4130"
+                span: "0:4344-4357"
                 name: ~
       span: ~
       name: ~
@@ -319,4 +321,3 @@ lineage:
       table:
         - db
         - c_invoice
-
diff --git a/prqlc/prqlc/src/semantic/resolver/stmt.rs b/prqlc/prqlc/src/semantic/resolver/stmt.rs
index dce25a766688..15698f6f915d 100644
--- a/prqlc/prqlc/src/semantic/resolver/stmt.rs
+++ b/prqlc/prqlc/src/semantic/resolver/stmt.rs
@@ -1,138 +1,94 @@
-use crate::Result;
-use std::collections::HashMap;
-
-use crate::ast::{Ty, TyKind, TyTupleField};
-use crate::ir::decl::{Decl, DeclKind, Module, TableDecl, TableExpr};
+use crate::ast::{Ty, TyTupleField};
+use crate::ir::decl::{DeclKind, TableDecl, TableExpr};
 use crate::ir::pl::*;
-use crate::WithErrorInfo;
+use crate::Result;
 
 impl super::Resolver<'_> {
-    // entry point to the resolver
-    pub fn fold_statements(&mut self, stmts: Vec<Stmt>) -> Result<()> {
-        for mut stmt in stmts {
-            stmt.id = Some(self.id.gen());
-            if let Some(span) = stmt.span {
-                self.root_mod.span_map.insert(stmt.id.unwrap(), span);
+    /// Entry point to the resolver.
+    /// fq_ident must point to an unresolved declaration.
+    pub fn resolve_decl(&mut self, fq_ident: Ident) -> Result<()> {
+        // take decl out of the module
+        let mut decl = {
+            let module = self.root_mod.module.get_submodule_mut(&fq_ident.path);
+            module.unwrap().names.remove(&fq_ident.name).unwrap()
+        };
+        let stmt = decl.kind.into_unresolved().unwrap();
+        self.debug_current_decl = fq_ident.clone();
+
+        // resolve
+        match stmt {
+            StmtKind::QueryDef(d) => {
+                decl.kind = DeclKind::QueryDef(*d);
             }
+            StmtKind::ModuleDef(_) => {
+                unreachable!("module def cannot be unresolved at this point")
+                // it should have been converted into Module in resolve_decls::init_module_tree
+            }
+            StmtKind::VarDef(var_def) => {
+                let mut def = self.fold_var_def(var_def)?;
 
-            let ident = Ident {
-                path: self.current_module_path.clone(),
-                name: stmt.name().to_string(),
-            };
-
-            let mut def = match stmt.kind {
-                StmtKind::QueryDef(d) => {
-                    let decl = DeclKind::QueryDef(*d);
-                    self.root_mod
-                        .declare(ident, decl, stmt.id, Vec::new())
-                        .with_span(stmt.span)?;
-                    continue;
-                }
-                StmtKind::VarDef(var_def) => self.fold_var_def(var_def)?,
-                StmtKind::TypeDef(ty_def) => {
-                    let value = if let Some(value) = ty_def.value {
-                        value
-                    } else {
-                        Ty::new(Literal::Null)
-                    };
-
-                    let ty = fold_type_opt(self, Some(value))?.unwrap();
-                    let mut ty = super::types::normalize_type(ty);
-                    ty.name = Some(ident.name.clone());
-
-                    let decl = DeclKind::Ty(ty);
-
-                    self.root_mod
-                        .declare(ident, decl, stmt.id, stmt.annotations)
-                        .with_span(stmt.span)?;
-                    continue;
+                if let Some(ExprKind::Func(closure)) = def.value.as_mut().map(|x| &mut x.kind) {
+                    if closure.name_hint.is_none() {
+                        closure.name_hint = Some(fq_ident.clone());
+                    }
                 }
-                StmtKind::ModuleDef(module_def) => {
-                    self.current_module_path.push(ident.name);
 
-                    let decl = Decl {
-                        declared_at: stmt.id,
-                        kind: DeclKind::Module(Module {
-                            names: HashMap::new(),
-                            redirects: Vec::new(),
-                            shadowed: None,
-                        }),
-                        annotations: stmt.annotations,
-                        ..Default::default()
-                    };
-                    let ident = Ident::from_path(self.current_module_path.clone());
-                    self.root_mod
-                        .module
-                        .insert(ident, decl)
-                        .with_span(stmt.span)?;
+                let expected_ty = fold_type_opt(self, def.ty)?;
 
-                    self.fold_statements(module_def.stmts)?;
-                    self.current_module_path.pop();
-                    continue;
-                }
-                StmtKind::ImportDef(target) => {
-                    let decl = Decl {
-                        declared_at: stmt.id,
-                        kind: DeclKind::Import(target.name),
-                        annotations: stmt.annotations,
-                        ..Default::default()
-                    };
+                decl.kind = match def.value {
+                    Some(mut def_value) => {
+                        // var value is provided
 
-                    self.root_mod
-                        .module
-                        .insert(ident, decl)
-                        .with_span(stmt.span)?;
-                    continue;
-                }
-            };
+                        // validate type
+                        if expected_ty.is_some() {
+                            let who = || Some(fq_ident.name.clone());
+                            self.validate_expr_type(&mut def_value, expected_ty.as_ref(), &who)?;
+                        }
 
-            if def.name == "main" {
-                def.ty = Some(Ty::new(TyKind::Ident(Ident::from_path(vec![
-                    "std", "relation",
-                ]))));
+                        prepare_expr_decl(def_value)
+                    }
+                    None => {
+                        // var value is not provided
+
+                        // is this a relation?
+                        if expected_ty.as_ref().map_or(false, |t| t.is_relation()) {
+                            // treat this var as a TableDecl
+                            DeclKind::TableDecl(TableDecl {
+                                ty: expected_ty,
+                                expr: TableExpr::LocalTable,
+                            })
+                        } else {
+                            // treat this var as a param
+                            let mut expr =
+                                Box::new(Expr::new(ExprKind::Param(fq_ident.name.clone())));
+                            expr.ty = expected_ty;
+                            DeclKind::Expr(expr)
+                        }
+                    }
+                };
             }
-
-            if let Some(ExprKind::Func(closure)) = def.value.as_mut().map(|x| &mut x.kind) {
-                if closure.name_hint.is_none() {
-                    closure.name_hint = Some(ident.clone());
-                }
+            StmtKind::TypeDef(ty_def) => {
+                let value = if let Some(value) = ty_def.value {
+                    value
+                } else {
+                    Ty::new(Literal::Null)
+                };
+
+                let ty = fold_type_opt(self, Some(value))?.unwrap();
+                let mut ty = super::types::normalize_type(ty);
+                ty.name = Some(fq_ident.name.clone());
+
+                decl.kind = DeclKind::Ty(ty);
             }
+            StmtKind::ImportDef(target) => {
+                decl.kind = DeclKind::Import(target.name);
+            }
+        };
 
-            let expected_ty = fold_type_opt(self, def.ty)?;
-
-            let decl = match def.value {
-                Some(mut def_value) => {
-                    // var value is provided
-
-                    // validate type
-                    if expected_ty.is_some() {
-                        let who = || Some(def.name.clone());
-                        self.validate_expr_type(&mut def_value, expected_ty.as_ref(), &who)?;
-                    }
-
-                    prepare_expr_decl(def_value)
-                }
-                None => {
-                    // var value is not provided
-
-                    // is this a relation?
-                    if expected_ty.as_ref().map_or(false, |t| t.is_relation()) {
-                        // treat this var as a TableDecl
-                        DeclKind::TableDecl(TableDecl {
-                            ty: expected_ty,
-                            expr: TableExpr::LocalTable,
-                        })
-                    } else {
-                        // treat this var as a param
-                        let mut expr = Box::new(Expr::new(ExprKind::Param(def.name)));
-                        expr.ty = expected_ty;
-                        DeclKind::Expr(expr)
-                    }
-                }
-            };
-            self.root_mod
-                .declare(ident, decl, stmt.id, stmt.annotations)
-                .with_span(stmt.span)?;
+        // put decl back in
+        {
+            let module = self.root_mod.module.get_submodule_mut(&fq_ident.path);
+            module.unwrap().names.insert(fq_ident.name, decl);
         }
         Ok(())
     }
diff --git a/prqlc/prqlc/src/semantic/resolver/transforms.rs b/prqlc/prqlc/src/semantic/resolver/transforms.rs
index 66606b10c118..2ea028c831a8 100644
--- a/prqlc/prqlc/src/semantic/resolver/transforms.rs
+++ b/prqlc/prqlc/src/semantic/resolver/transforms.rs
@@ -11,7 +11,7 @@ use crate::ir::pl::*;
 use crate::ast::{Ty, TyKind, TyTupleField};
 use crate::semantic::ast_expand::{restrict_null_literal, try_restrict_range};
 use crate::semantic::resolver::functions::expr_of_func;
-use crate::semantic::{write_pl, NS_PARAM, NS_THIS};
+use crate::semantic::{write_pl, NS_LOCAL, NS_PARAM, NS_THIS};
 use crate::{Error, Reason, Result, WithErrorInfo, COMPILER_VERSION};
 
 use super::types::{ty_tuple_kind, type_intersection};
@@ -102,7 +102,7 @@ impl Resolver<'_> {
                 let side = {
                     let span = side.span;
                     let ident = side.try_cast(ExprKind::into_ident, Some("side"), "ident")?;
-                    match ident.to_string().as_str() {
+                    match ident.name.as_str() {
                         "inner" => JoinSide::Inner,
                         "left" => JoinSide::Left,
                         "right" => JoinSide::Right,
@@ -132,7 +132,7 @@ impl Resolver<'_> {
                 // (when generics are a thing, this can be removed)
                 let partition = {
                     let partition = Expr::new(ExprKind::All {
-                        within: Box::new(Expr::new(Ident::from_name(NS_THIS))),
+                        within: Box::new(Expr::new(Ident::from_path(vec![NS_LOCAL, NS_THIS]))),
                         except: by.clone(),
                     });
                     // wrap into select, so the names are resolved correctly
@@ -348,7 +348,7 @@ impl Resolver<'_> {
                     let span = format.span;
                     let format = format
                         .try_cast(ExprKind::into_ident, Some("format"), "ident")?
-                        .to_string();
+                        .name;
                     match format.as_str() {
                         "csv" => from_text::parse_csv(&text)
                             .map_err(|r| Error::new_simple(r).with_span(span))?,
@@ -580,7 +580,9 @@ impl Resolver<'_> {
         // thats why we trick the resolver with a dummy node that acts as table
         // chunk and instruct resolver to apply the transform on that.
 
-        let mut dummy = Expr::new(ExprKind::Ident(Ident::from_name(param_name)));
+        let mut dummy = Expr::new(ExprKind::Ident(Ident::from_path(vec![
+            NS_LOCAL, NS_PARAM, param_name,
+        ])));
         dummy.lineage = val.lineage.clone();
         dummy.ty = val.ty.clone();
 
@@ -590,11 +592,11 @@ impl Resolver<'_> {
         )));
 
         let env = Module::singleton(param_name, Decl::from(DeclKind::Column(param_id)));
-        self.root_mod.module.stack_push(NS_PARAM, env);
+        self.root_mod.local_mut().stack_push(NS_PARAM, env);
 
         let mut pipeline = self.fold_expr(pipeline)?;
 
-        self.root_mod.module.stack_pop(NS_PARAM).unwrap();
+        self.root_mod.local_mut().stack_pop(NS_PARAM).unwrap();
 
         // now, we need wrap the result into a closure and replace
         // the dummy node with closure's parameter.
@@ -879,10 +881,14 @@ impl Lineage {
             return;
         }
 
+        fn pop_local_and_this(ident: &Ident) -> Ident {
+            ident.clone().pop_front().1.unwrap().pop_front().1.unwrap()
+        }
+
         // special case: an ref that should be inlined because this node
         // might not exist in the resulting AST
         if inline_refs && expr.target_id.is_some() {
-            let ident = expr.kind.as_ident().unwrap().clone().pop_front().1.unwrap();
+            let ident = pop_local_and_this(expr.kind.as_ident().unwrap());
             let target_id = expr.target_id.unwrap();
             let input = &self.find_input(target_id);
 
@@ -906,7 +912,7 @@ impl Lineage {
         let (target_id, target_name) = (expr.id.unwrap(), None);
 
         let alias = expr.alias.as_ref().map(Ident::from_name);
-        let name = alias.or_else(|| expr.kind.as_ident()?.clone().pop_front().1);
+        let name = alias.or_else(|| Some(pop_local_and_this(expr.kind.as_ident()?)));
 
         // remove names from columns with the same name
         if name.is_some() {
diff --git a/prqlc/prqlc/src/semantic/resolver/types.rs b/prqlc/prqlc/src/semantic/resolver/types.rs
index 2ffcc0720cf8..17cf28c65938 100644
--- a/prqlc/prqlc/src/semantic/resolver/types.rs
+++ b/prqlc/prqlc/src/semantic/resolver/types.rs
@@ -212,8 +212,9 @@ impl Resolver<'_> {
             | DeclKind::TableDecl(_)
             | DeclKind::Ty(_)
             | DeclKind::InstanceOf { .. }
-            | DeclKind::QueryDef(_)
-            | DeclKind::Import(_) => {
+            | DeclKind::Import(_)
+            | DeclKind::Unresolved(_)
+            | DeclKind::QueryDef(_) => {
                 panic!("declaration {decl} is not able to have a type")
             }
         }
diff --git a/prqlc/prqlc/src/semantic/std.prql b/prqlc/prqlc/src/semantic/std.prql
index 33629efefed2..c4eab1d428da 100644
--- a/prqlc/prqlc/src/semantic/std.prql
+++ b/prqlc/prqlc/src/semantic/std.prql
@@ -57,89 +57,89 @@ type scalar = int || float || bool || text || date || time || timestamp || null
 type tuple = {anytype..}
 
 ## Range
-type range = {start = scalar, end = scalar}
+type range = {start = std.scalar, end = std.scalar}
 
 ## Relation (an array of tuples)
-type relation = [tuple]
+type relation = [module.tuple]
 
 ## Transform
-type transform = func relation -> relation
+type transform = func std.relation -> std.relation
 
 # Functions
 
 ## Relational transforms
 let from = func
-  tbl <relation>
-  -> <relation> tbl
+  tbl <std.relation>
+  -> <std.relation> tbl
 
 let select = func
   columns <anytype>
-  tbl <relation>
-  -> <relation> internal select
+  tbl <std.relation>
+  -> <std.relation> internal select
 
 let filter = func
   condition <bool>
-  tbl <relation>
-  -> <relation> internal filter
+  tbl <std.relation>
+  -> <std.relation> internal filter
 
 let derive = func
   columns <anytype>
-  tbl <relation>
-  -> <relation> internal derive
+  tbl <std.relation>
+  -> <std.relation> internal derive
 
 let aggregate = func
   columns <anytype>
-  tbl <relation>
-  -> <relation> internal aggregate
+  tbl <std.relation>
+  -> <std.relation> internal aggregate
 
 let sort = func
   by <anytype>
-  tbl <relation>
-  -> <relation> internal sort
+  tbl <std.relation>
+  -> <std.relation> internal sort
 
 let take = func
   expr <anytype>
-  tbl <relation>
-  -> <relation> internal take
+  tbl <std.relation>
+  -> <std.relation> internal take
 
 let join = func
-  with <relation>
+  with <std.relation>
   condition <bool>
   `noresolve.side`:inner
-  tbl <relation>
-  -> <relation> internal join
+  tbl <std.relation>
+  -> <std.relation> internal join
 
 let group = func
-  by<scalar || tuple>
-  pipeline <transform>
-  tbl <relation>
-  -> <relation> internal group
+  by<std.scalar || module.tuple>
+  pipeline <module.transform>
+  tbl <std.relation>
+  -> <std.relation> internal group
 
 let window = func
   rows:0..-1
   range:0..-1
   expanding <bool>:false
   rolling <int>:0
-  pipeline <transform>
-  tbl <relation>
-  -> <relation> internal window
+  pipeline <module.transform>
+  tbl <std.relation>
+  -> <std.relation> internal window
 
-let append = bottom<relation> top<relation> -> <relation> internal append
-let intersect = bottom<relation> top<relation> -> <relation> (
+let append = bottom<std.relation> top<std.relation> -> <std.relation> internal append
+let intersect = bottom<std.relation> top<std.relation> -> <std.relation> (
   t = top
-  join (b = bottom) (tuple_every (tuple_map _eq (tuple_zip t.* b.*)))
+  join (b = bottom) (std.tuple_every (std.tuple_map std._eq (std.tuple_zip t.* b.*)))
   select t.*
 )
-let remove = bottom<relation> top<relation> -> <relation> (
+let remove = bottom<std.relation> top<std.relation> -> <std.relation> (
   t = top
-  join side:left (b = bottom) (tuple_every (tuple_map _eq (tuple_zip t.* b.*)))
-  filter (tuple_every (tuple_map _is_null b.*))
+  join side:left (b = bottom) (std.tuple_every (std.tuple_map std._eq (std.tuple_zip t.* b.*)))
+  filter (std.tuple_every (std.tuple_map std._is_null b.*))
   select t.*
 )
 let loop = func
-  pipeline <transform>
-  top <relation>
-  -> <relation> internal loop
+  pipeline <module.transform>
+  top <std.relation>
+  -> <std.relation> internal loop
 
 ## Aggregate functions
 # These return either a scalar when used within `aggregate`, or a column when used anywhere else.
@@ -197,11 +197,11 @@ module math {
   let tan = column -> <int || float> internal std.math.tan
   let atan = column -> <int || float> internal std.math.atan
   let pow = exponent<int || float> column -> <int || float> internal std.math.pow
-  let round = n_digits column -> <scalar> internal std.math.round
+  let round = n_digits column -> <super.scalar> internal std.math.round
 }
 
 ## Misc functions
-let as = `noresolve.type` column -> <scalar> internal std.as
+let as = `noresolve.type` column -> <std.scalar> internal std.as
 let in = pattern value -> <bool> internal in
 
 ## Tuple functions
diff --git a/prqlc/prqlc/src/sql/std.sql.prql b/prqlc/prqlc/src/sql/std.sql.prql
index a606250468c5..eef933f4dd57 100644
--- a/prqlc/prqlc/src/sql/std.sql.prql
+++ b/prqlc/prqlc/src/sql/std.sql.prql
@@ -171,7 +171,7 @@ let or = l r -> null
 
 let coalesce = l r -> s"COALESCE({l:0}, {r:0})"
 
-let regex_search = text pattern -> s"REGEXP({text:0}, {pattern:0})"
+let regex_search = haystack pattern -> s"REGEXP({haystack:0}, {pattern:0})"
 
 @{binding_strength=13}
 let neg = l -> s"-{l}"
@@ -195,7 +195,7 @@ module bigquery {
     let radians = column -> s"({column:0} * PI() / 180)"
   }
 
-  let regex_search = text pattern -> s"REGEXP_CONTAINS({text:0}, {pattern:0})"
+  let regex_search = haystack pattern -> s"REGEXP_CONTAINS({haystack:0}, {pattern:0})"
 }
 
 module clickhouse {
@@ -212,7 +212,7 @@ module clickhouse {
     let to_text = format column -> s"formatDateTimeInJodaSyntax({column:0}, {format:0})"
   }
 
-  let regex_search = text pattern -> s"match({text:0}, {pattern:0})"
+  let regex_search = haystack pattern -> s"match({haystack:0}, {pattern:0})"
 
   let read_csv = source -> s"file({source:0}, 'CSV')"
 
@@ -238,7 +238,7 @@ module duckdb {
     let to_text = format column -> s"strftime({column:0}, {format:0})"
   }
 
-  let regex_search = text pattern -> s"REGEXP_MATCHES({text:0}, {pattern:0})"
+  let regex_search = haystack pattern -> s"REGEXP_MATCHES({haystack:0}, {pattern:0})"
 
   let read_csv = source -> s"read_csv_auto({source:0})"
 }
@@ -287,7 +287,7 @@ module mysql {
   }
 
   # 'c' for case-sensitive
-  let regex_search = text pattern -> s"REGEXP_LIKE({text:0}, {pattern:0}, 'c')"
+  let regex_search = haystack pattern -> s"REGEXP_LIKE({haystack:0}, {pattern:0}, 'c')"
 }
 
 module postgres {
@@ -317,7 +317,7 @@ module postgres {
   }
 
   @{binding_strength=9}
-  let regex_search = text pattern -> s"{text} ~ {pattern}"
+  let regex_search = haystack pattern -> s"{haystack} ~ {pattern}"
 }
 
 module glaredb {
@@ -335,7 +335,7 @@ module glaredb {
   }
 
   @{binding_strength=9}
-  let regex_search = text pattern -> s"{text} ~ {pattern}"
+  let regex_search = haystack pattern -> s"{haystack} ~ {pattern}"
 
   let read_csv = source -> s"csv_scan({source:0})"
 
@@ -368,7 +368,7 @@ module sqlite {
   }
 
   @{binding_strength=9}
-  let regex_search = text pattern -> s"{text} REGEXP {pattern}"
+  let regex_search = haystack pattern -> s"{haystack} REGEXP {pattern}"
 }
 
 module snowflake {
diff --git a/prqlc/prqlc/src/utils/id_gen.rs b/prqlc/prqlc/src/utils/id_gen.rs
index b12ac953f3f5..54fe71db2daf 100644
--- a/prqlc/prqlc/src/utils/id_gen.rs
+++ b/prqlc/prqlc/src/utils/id_gen.rs
@@ -14,7 +14,7 @@ impl<T: From<usize>> IdGenerator<T> {
         Self::default()
     }
 
-    fn skip(&mut self, id: usize) {
+    pub fn skip(&mut self, id: usize) {
         self.next_id = self.next_id.max(id + 1);
     }
 
diff --git a/prqlc/prqlc/tests/integration/bad_error_messages.rs b/prqlc/prqlc/tests/integration/bad_error_messages.rs
index 9460906417b7..aecc03d61cb6 100644
--- a/prqlc/prqlc/tests/integration/bad_error_messages.rs
+++ b/prqlc/prqlc/tests/integration/bad_error_messages.rs
@@ -117,8 +117,9 @@ fn misplaced_type_error() {
     // (preferably in addition to the error that is currently generated)
     assert_snapshot!(compile(r###"
     let foo = 123
+
     from db.t
-    select (true && foo)
+    select (true && module.foo)
     "###).unwrap_err(), @r###"
     Error:
        ╭─[:2:15]
diff --git a/prqlc/prqlc/tests/integration/cli.rs b/prqlc/prqlc/tests/integration/cli.rs
index 64ccbbb30815..32e040cc4215 100644
--- a/prqlc/prqlc/tests/integration/cli.rs
+++ b/prqlc/prqlc/tests/integration/cli.rs
@@ -155,7 +155,7 @@ let long_query = (
   filter ct > 200
   take 20
 )
-long_query
+module.long_query
   "#), @r###"
     success: true
     exit_code: 0
diff --git a/prqlc/prqlc/tests/integration/error_messages.rs b/prqlc/prqlc/tests/integration/error_messages.rs
index 210efccf414d..ec5e7d465d2f 100644
--- a/prqlc/prqlc/tests/integration/error_messages.rs
+++ b/prqlc/prqlc/tests/integration/error_messages.rs
@@ -11,15 +11,15 @@ fn test_errors() {
     let addadd = a b -> a + b
 
     from db.x
-    derive y = (addadd 4 5 6)
+    derive y = (module.addadd 4 5 6)
     "###).unwrap_err(),
         @r###"
     Error:
        ╭─[:5:17]
        │
-     5 │     derive y = (addadd 4 5 6)
-       │                 ──────┬─────
-       │                       ╰─────── Too many arguments to function `addadd`
+     5 │     derive y = (module.addadd 4 5 6)
+       │                 ─────────┬─────────
+       │                          ╰─────────── Too many arguments to function `addadd`
     ───╯
     "###);
 
@@ -196,20 +196,22 @@ fn test_basic_type_checking() {
 fn test_type_error_placement() {
     assert_snapshot!(compile(r###"
     let foo = x -> (x | as integer)
+
     from db.t
-    select (true && (foo y))
+    select (true && (module.foo y))
     "###).unwrap_err(), @r###"
     Error:
-       ╭─[:4:22]
+       ╭─[:5:22]
        │
-     4 │     select (true && (foo y))
-       │                      ──┬──
-       │                        ╰──── function std.and, param `right` expected type `bool`, but found type `scalar`
+     5 │     select (true && (module.foo y))
+       │                      ──────┬─────
+       │                            ╰─────── function std.and, param `right` expected type `bool`, but found type `scalar`
     ───╯
     "###);
 }
 
 #[test]
+#[ignore]
 fn test_ambiguous() {
     assert_snapshot!(compile(r#"
     from db.a
@@ -247,7 +249,7 @@ fn test_ambiguous_join() {
        │            ┬
        │            ╰── Ambiguous name
        │
-       │ Help: could be any of: a.x, b.x
+       │ Help: could be any of: this.a.x, this.b.x
        │
        │ Note: available columns: a.x, b.x
     ───╯
@@ -269,7 +271,7 @@ fn test_ambiguous_inference() {
        │            ┬
        │            ╰── Ambiguous name
        │
-       │ Help: could be any of: a.x, b.x
+       │ Help: could be any of: this.a.x, this.b.x
     ───╯
     "###);
 }
@@ -279,14 +281,14 @@ fn date_to_text_generic() {
     assert_snapshot!(compile(r#"
   [{d = @2021-01-01}]
   derive {
-    d_str = d | date.to_text "%Y/%m/%d"
+    d_str = d | std.date.to_text "%Y/%m/%d"
   }"#).unwrap_err(), @r###"
     Error:
-       ╭─[:4:30]
+       ╭─[:4:34]
        │
-     4 │     d_str = d | date.to_text "%Y/%m/%d"
-       │                              ─────┬────
-       │                                   ╰────── Date formatting requires a dialect
+     4 │     d_str = d | std.date.to_text "%Y/%m/%d"
+       │                                  ─────┬────
+       │                                       ╰────── Date formatting requires a dialect
     ───╯
     "###);
 }
@@ -298,14 +300,14 @@ fn date_to_text_not_supported_dialect() {
 
   [{d = @2021-01-01}]
   derive {
-    d_str = d | date.to_text "%Y/%m/%d"
+    d_str = d | std.date.to_text "%Y/%m/%d"
   }"#).unwrap_err(), @r###"
     Error:
-       ╭─[:6:30]
+       ╭─[:6:34]
        │
-     6 │     d_str = d | date.to_text "%Y/%m/%d"
-       │                              ─────┬────
-       │                                   ╰────── Date formatting is not yet supported for this dialect
+     6 │     d_str = d | std.date.to_text "%Y/%m/%d"
+       │                                  ─────┬────
+       │                                       ╰────── Date formatting is not yet supported for this dialect
     ───╯
     "###);
 }
@@ -334,14 +336,14 @@ fn date_to_text_unsupported_chrono_item() {
 
     [{d = @2021-01-01}]
     derive {
-      d_str = d | date.to_text "%_j"
+      d_str = d | std.date.to_text "%_j"
     }"#).unwrap_err(), @r###"
     Error:
-       ╭─[:6:32]
+       ╭─[:6:36]
        │
-     6 │       d_str = d | date.to_text "%_j"
-       │                                ──┬──
-       │                                  ╰──── PRQL doesn't support this format specifier
+     6 │       d_str = d | std.date.to_text "%_j"
+       │                                    ──┬──
+       │                                      ╰──── PRQL doesn't support this format specifier
     ───╯
     "###);
 }
diff --git a/prqlc/prqlc/tests/integration/project/Project.prql b/prqlc/prqlc/tests/integration/project/Project.prql
index 32af7f312e0c..93610c10c945 100644
--- a/prqlc/prqlc/tests/integration/project/Project.prql
+++ b/prqlc/prqlc/tests/integration/project/Project.prql
@@ -3,5 +3,5 @@ let favorite_artists = [
   {artist_id = 7, last_listen = @2023-05-16},
 ]
 
-favorite_artists
-join side:left artists.input (==artist_id)
+project.favorite_artists
+join side:left project.artists.input (==artist_id)
diff --git a/prqlc/prqlc/tests/integration/project/artists.prql b/prqlc/prqlc/tests/integration/project/artists.prql
index 2a0d697aee37..487e1b56419f 100644
--- a/prqlc/prqlc/tests/integration/project/artists.prql
+++ b/prqlc/prqlc/tests/integration/project/artists.prql
@@ -1 +1 @@
-let input = read_parquet "artists.parquet"
+let input = std.read_parquet "artists.parquet"
diff --git a/prqlc/prqlc/tests/integration/queries/arithmetic.prql b/prqlc/prqlc/tests/integration/queries/arithmetic.prql
index e227aa0040dc..2cfe922d4340 100644
--- a/prqlc/prqlc/tests/integration/queries/arithmetic.prql
+++ b/prqlc/prqlc/tests/integration/queries/arithmetic.prql
@@ -23,9 +23,9 @@ select {
     r_fi = x_float % k_int,
     r_ff = x_float % k_float,
 
-    (q_ii * k_int + r_ii | math.round 0),
-    (q_if * k_float + r_if | math.round 0),
-    (q_fi * k_int + r_fi | math.round 0),
-    (q_ff * k_float + r_ff | math.round 0),
+    (q_ii * k_int + r_ii | std.math.round 0),
+    (q_if * k_float + r_if | std.math.round 0),
+    (q_fi * k_int + r_fi | std.math.round 0),
+    (q_ff * k_float + r_ff | std.math.round 0),
 }
 sort id
diff --git a/prqlc/prqlc/tests/integration/queries/date_to_text.prql b/prqlc/prqlc/tests/integration/queries/date_to_text.prql
index 6e6d6d36dda4..f386a3443a62 100644
--- a/prqlc/prqlc/tests/integration/queries/date_to_text.prql
+++ b/prqlc/prqlc/tests/integration/queries/date_to_text.prql
@@ -5,16 +5,16 @@
 from db.invoices
 take 20
 select {
-    d1 = (invoice_date | date.to_text "%Y/%m/%d"),
-    d2 = (invoice_date | date.to_text "%F"),
-    d3 = (invoice_date | date.to_text "%D"),
-    d4 = (invoice_date | date.to_text "%H:%M:%S.%f"),
-    d5 = (invoice_date | date.to_text "%r"),
-    d6 = (invoice_date | date.to_text "%A %B %-d %Y"),
-    d7 = (invoice_date | date.to_text "%a, %-d %b %Y at %I:%M:%S %p"),
-    d8 = (invoice_date | date.to_text "%+"),
-    d9 = (invoice_date | date.to_text "%-d/%-m/%y"),
-    d10 = (invoice_date | date.to_text "%-Hh %Mmin"),
-    d11 = (invoice_date | date.to_text "%M'%S\""),
-    d12 = (invoice_date | date.to_text "100%% in %d days"),
+    d1 = (invoice_date | std.date.to_text "%Y/%m/%d"),
+    d2 = (invoice_date | std.date.to_text "%F"),
+    d3 = (invoice_date | std.date.to_text "%D"),
+    d4 = (invoice_date | std.date.to_text "%H:%M:%S.%f"),
+    d5 = (invoice_date | std.date.to_text "%r"),
+    d6 = (invoice_date | std.date.to_text "%A %B %-d %Y"),
+    d7 = (invoice_date | std.date.to_text "%a, %-d %b %Y at %I:%M:%S %p"),
+    d8 = (invoice_date | std.date.to_text "%+"),
+    d9 = (invoice_date | std.date.to_text "%-d/%-m/%y"),
+    d10 = (invoice_date | std.date.to_text "%-Hh %Mmin"),
+    d11 = (invoice_date | std.date.to_text "%M'%S\""),
+    d12 = (invoice_date | std.date.to_text "100%% in %d days"),
 }
diff --git a/prqlc/prqlc/tests/integration/queries/genre_counts.prql b/prqlc/prqlc/tests/integration/queries/genre_counts.prql
index 5e72cc825b05..7abb9f786579 100644
--- a/prqlc/prqlc/tests/integration/queries/genre_counts.prql
+++ b/prqlc/prqlc/tests/integration/queries/genre_counts.prql
@@ -5,6 +5,6 @@ let genre_count = (
     aggregate {a = count name}
 )
 
-genre_count
+module.genre_count
 filter a > 0
 select a = -a
diff --git a/prqlc/prqlc/tests/integration/queries/group_all.prql b/prqlc/prqlc/tests/integration/queries/group_all.prql
index 0f3f0eda7660..7ca1fdc9cc9c 100644
--- a/prqlc/prqlc/tests/integration/queries/group_all.prql
+++ b/prqlc/prqlc/tests/integration/queries/group_all.prql
@@ -3,5 +3,7 @@ from db.albums
 select {a = this}
 take 10
 join db.tracks (==album_id)
-group {a.album_id, a.title} (aggregate price = (sum tracks.unit_price | math.round 2))
+group {a.album_id, a.title} (
+  aggregate price = (sum tracks.unit_price | std.math.round 2)
+)
 sort album_id
diff --git a/prqlc/prqlc/tests/integration/queries/math_module.prql b/prqlc/prqlc/tests/integration/queries/math_module.prql
index 2bc9d8ebb6f6..d180edbc7801 100644
--- a/prqlc/prqlc/tests/integration/queries/math_module.prql
+++ b/prqlc/prqlc/tests/integration/queries/math_module.prql
@@ -3,17 +3,17 @@
 from db.invoices
 take 5
 select {
-    total_original = total | math.round 2,
-    total_x = math.pi - total | math.round 2 | math.abs,
-    total_floor = math.floor total,
-    total_ceil = math.ceil total,
-    total_log10 = math.log10 total | math.round 3,
-    total_log2 = math.log 2 total | math.round 3,
-    total_sqrt = math.sqrt total | math.round 3,
-    total_ln = math.ln total | math.exp | math.round 2,
-    total_cos = math.cos total | math.acos | math.round 2,
-    total_sin = math.sin total | math.asin | math.round 2,
-    total_tan = math.tan total | math.atan | math.round 2,
-    total_deg = total | math.degrees | math.radians | math.round 2,
-    total_square = total | math.pow 2| math.round 2,
+    total_original = total | std.math.round 2,
+    total_x = std.math.pi - total | std.math.round 2 | std.math.abs,
+    total_floor = std.math.floor total,
+    total_ceil = std.math.ceil total,
+    total_log10 = std.math.log10 total | std.math.round 3,
+    total_log2 = std.math.log 2 total | std.math.round 3,
+    total_sqrt = std.math.sqrt total | std.math.round 3,
+    total_ln = std.math.ln total | std.math.exp | std.math.round 2,
+    total_cos = std.math.cos total | std.math.acos | std.math.round 2,
+    total_sin = std.math.sin total | std.math.asin | std.math.round 2,
+    total_tan = std.math.tan total | std.math.atan | std.math.round 2,
+    total_deg = total | std.math.degrees | std.math.radians | std.math.round 2,
+    total_square = total | std.math.pow 2| std.math.round 2,
 }
diff --git a/prqlc/prqlc/tests/integration/queries/read_csv.prql b/prqlc/prqlc/tests/integration/queries/read_csv.prql
index 46011c3a990d..256e8672c26b 100644
--- a/prqlc/prqlc/tests/integration/queries/read_csv.prql
+++ b/prqlc/prqlc/tests/integration/queries/read_csv.prql
@@ -1,5 +1,5 @@
 # sqlite:skip
 # postgres:skip
 # mysql:skip
-read_csv "data_file_root/media_types.csv"
+std.read_csv "data_file_root/media_types.csv"
 sort media_type_id
diff --git a/prqlc/prqlc/tests/integration/queries/set_ops_remove.prql b/prqlc/prqlc/tests/integration/queries/set_ops_remove.prql
index cf07d14f20ab..0eabbd69d493 100644
--- a/prqlc/prqlc/tests/integration/queries/set_ops_remove.prql
+++ b/prqlc/prqlc/tests/integration/queries/set_ops_remove.prql
@@ -1,7 +1,7 @@
 # mssql:test
 let distinct = rel -> (rel | group this (take 1))
 
-from_text format:json '{ "columns": ["a"], "data": [[1], [2], [2], [3]] }'
-distinct
-remove (from_text format:json '{ "columns": ["a"], "data": [[1], [2]] }')
+std.from_text format:json '{ "columns": ["a"], "data": [[1], [2], [2], [3]] }'
+module.distinct
+remove (std.from_text format:json '{ "columns": ["a"], "data": [[1], [2]] }')
 sort a
diff --git a/prqlc/prqlc/tests/integration/queries/text_module.prql b/prqlc/prqlc/tests/integration/queries/text_module.prql
index 0a51585bbd91..5ee8d925a1b0 100644
--- a/prqlc/prqlc/tests/integration/queries/text_module.prql
+++ b/prqlc/prqlc/tests/integration/queries/text_module.prql
@@ -3,14 +3,14 @@ from db.albums
 select {
     title,
     title_and_spaces = f"  {title}  ",
-    low = title | text.lower,
-    up = title | text.upper,
-    ltrimmed = title | text.ltrim,
-    rtrimmed = title | text.rtrim,
-    trimmed = title | text.trim,
-    len = title | text.length,
-    subs = title | text.extract 2 5,
-    replace = title | text.replace "al" "PIKA",
+    low = title | std.text.lower,
+    up = title | std.text.upper,
+    ltrimmed = title | std.text.ltrim,
+    rtrimmed = title | std.text.rtrim,
+    trimmed = title | std.text.trim,
+    len = title | std.text.length,
+    subs = title | std.text.extract 2 5,
+    replace = title | std.text.replace "al" "PIKA",
 }
 sort {title}
-filter (title | text.starts_with "Black") || (title | text.contains "Sabbath") || (title | text.ends_with "os")
+filter (title | std.text.starts_with "Black") || (title | std.text.contains "Sabbath") || (title | std.text.ends_with "os")
diff --git a/prqlc/prqlc/tests/integration/resolving.rs b/prqlc/prqlc/tests/integration/resolving.rs
index 364551d653dc..54fc0cf3f2ac 100644
--- a/prqlc/prqlc/tests/integration/resolving.rs
+++ b/prqlc/prqlc/tests/integration/resolving.rs
@@ -11,7 +11,7 @@ fn resolve(prql_source: &str) -> Result<String, ErrorMessages> {
 
     // resolved PL, restricted back into AST
     let mut root_module = prqlc::semantic::ast_expand::restrict_module(root_module.module);
-    drop_module_defs(&mut root_module.stmts, &["std", "db"]);
+    drop_module_defs(&mut root_module.stmts, &["std", "db", "_local"]);
 
     prqlc::pl_to_prql(&root_module)
 }
@@ -41,9 +41,7 @@ fn resolve_function_01() {
       param_1 + 1
     )
     "#).unwrap(), @r###"
-    let my_func = func param_1 <param_1_type> -> <Ret_ty> (
-      std.add param_1 1
-    )
+    let my_func = func param_1 <param_1_type> -> <Ret_ty> std.add param_1 1
     "###)
 }
 
@@ -113,8 +111,8 @@ fn resolve_generics_01() {
         r#"
     let add_one = func <A: int | float> a <A> -> <A> a + 1
         
-    let my_int = add_one 1
-    let my_float = add_one 1.0
+    let my_int = module.add_one 1
+    let my_float = module.add_one 1.0
     "#,
     )
     .unwrap(), @r###"
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__cli__debug.snap b/prqlc/prqlc/tests/integration/snapshots/integration__cli__debug.snap
index 1107fae7c66d..5e06495a7a44 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__cli__debug.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__cli__debug.snap
@@ -17,18 +17,19 @@ success: true
 exit_code: 0
 ----- stdout -----
 Module {
-    redirects: [
-        "this",
-        "that",
-        "_param",
-        "std",
-        "_generic",
-    ],
     names: {
-        "_param": Decl {
+        "_local": Decl {
             declared_at: None,
-            kind: LayeredModules(
-                [],
+            kind: Module(
+                Module {
+                    redirects: [
+                        "this",
+                        "that",
+                        "_param",
+                        "_generic",
+                    ],
+                    names: "... 40 entries ...",
+                },
             ),
             order: 0,
             annotations: [],
@@ -179,7 +180,7 @@ Module {
                     ),
                 },
             ),
-            order: 0,
+            order: 2,
             annotations: [],
         },
         "std": Decl {
@@ -191,7 +192,7 @@ Module {
                     names: "... 77 entries ...",
                 },
             ),
-            order: 0,
+            order: 1,
             annotations: [],
         },
     },
@@ -214,4 +215,3 @@ module db {
 let main <[{*..}]> = db.tracks
 
 ----- stderr -----
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__arithmetic.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__arithmetic.snap
index 732257fa1bd8..2a3b22df2840 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__arithmetic.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__arithmetic.snap
@@ -1,6 +1,6 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# mssql:test\n[\n    { id = 1, x_int =  13, x_float =  13.0, k_int =  5, k_float =  5.0 },\n    { id = 2, x_int = -13, x_float = -13.0, k_int =  5, k_float =  5.0 },\n    { id = 3, x_int =  13, x_float =  13.0, k_int = -5, k_float = -5.0 },\n    { id = 4, x_int = -13, x_float = -13.0, k_int = -5, k_float = -5.0 },\n]\nselect {\n    id,\n\n    x_int / k_int,\n    x_int / k_float,\n    x_float / k_int,\n    x_float / k_float,\n\n    q_ii = x_int // k_int,\n    q_if = x_int // k_float,\n    q_fi = x_float // k_int,\n    q_ff = x_float // k_float,\n\n    r_ii = x_int % k_int,\n    r_if = x_int % k_float,\n    r_fi = x_float % k_int,\n    r_ff = x_float % k_float,\n\n    (q_ii * k_int + r_ii | math.round 0),\n    (q_if * k_float + r_if | math.round 0),\n    (q_fi * k_int + r_fi | math.round 0),\n    (q_ff * k_float + r_ff | math.round 0),\n}\nsort id\n"
+expression: "# mssql:test\n[\n    { id = 1, x_int =  13, x_float =  13.0, k_int =  5, k_float =  5.0 },\n    { id = 2, x_int = -13, x_float = -13.0, k_int =  5, k_float =  5.0 },\n    { id = 3, x_int =  13, x_float =  13.0, k_int = -5, k_float = -5.0 },\n    { id = 4, x_int = -13, x_float = -13.0, k_int = -5, k_float = -5.0 },\n]\nselect {\n    id,\n\n    x_int / k_int,\n    x_int / k_float,\n    x_float / k_int,\n    x_float / k_float,\n\n    q_ii = x_int // k_int,\n    q_if = x_int // k_float,\n    q_fi = x_float // k_int,\n    q_ff = x_float // k_float,\n\n    r_ii = x_int % k_int,\n    r_if = x_int % k_float,\n    r_fi = x_float % k_int,\n    r_ff = x_float % k_float,\n\n    (q_ii * k_int + r_ii | std.math.round 0),\n    (q_if * k_float + r_if | std.math.round 0),\n    (q_fi * k_int + r_fi | std.math.round 0),\n    (q_ff * k_float + r_ff | std.math.round 0),\n}\nsort id\n"
 input_file: prqlc/prqlc/tests/integration/queries/arithmetic.prql
 ---
 [
@@ -47,10 +47,9 @@ select {
   r_if = x_int % k_float,
   r_fi = x_float % k_int,
   r_ff = x_float % k_float,
-  (q_ii * k_int + r_ii | math.round 0),
-  (q_if * k_float + r_if | math.round 0),
-  (q_fi * k_int + r_fi | math.round 0),
-  (q_ff * k_float + r_ff | math.round 0),
+  (q_ii * k_int + r_ii | std.math.round 0),
+  (q_if * k_float + r_if | std.math.round 0),
+  (q_fi * k_int + r_fi | std.math.round 0),
+  (q_ff * k_float + r_ff | std.math.round 0),
 }
 sort id
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__date_to_text.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__date_to_text.snap
index 8865d5fa139c..b8b3e80ee4db 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__date_to_text.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__date_to_text.snap
@@ -1,22 +1,21 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# generic:skip\n# glaredb:skip\n# sqlite:skip\n# mssql:test\nfrom db.invoices\ntake 20\nselect {\n    d1 = (invoice_date | date.to_text \"%Y/%m/%d\"),\n    d2 = (invoice_date | date.to_text \"%F\"),\n    d3 = (invoice_date | date.to_text \"%D\"),\n    d4 = (invoice_date | date.to_text \"%H:%M:%S.%f\"),\n    d5 = (invoice_date | date.to_text \"%r\"),\n    d6 = (invoice_date | date.to_text \"%A %B %-d %Y\"),\n    d7 = (invoice_date | date.to_text \"%a, %-d %b %Y at %I:%M:%S %p\"),\n    d8 = (invoice_date | date.to_text \"%+\"),\n    d9 = (invoice_date | date.to_text \"%-d/%-m/%y\"),\n    d10 = (invoice_date | date.to_text \"%-Hh %Mmin\"),\n    d11 = (invoice_date | date.to_text \"%M'%S\\\"\"),\n    d12 = (invoice_date | date.to_text \"100%% in %d days\"),\n}\n"
+expression: "# generic:skip\n# glaredb:skip\n# sqlite:skip\n# mssql:test\nfrom db.invoices\ntake 20\nselect {\n    d1 = (invoice_date | std.date.to_text \"%Y/%m/%d\"),\n    d2 = (invoice_date | std.date.to_text \"%F\"),\n    d3 = (invoice_date | std.date.to_text \"%D\"),\n    d4 = (invoice_date | std.date.to_text \"%H:%M:%S.%f\"),\n    d5 = (invoice_date | std.date.to_text \"%r\"),\n    d6 = (invoice_date | std.date.to_text \"%A %B %-d %Y\"),\n    d7 = (invoice_date | std.date.to_text \"%a, %-d %b %Y at %I:%M:%S %p\"),\n    d8 = (invoice_date | std.date.to_text \"%+\"),\n    d9 = (invoice_date | std.date.to_text \"%-d/%-m/%y\"),\n    d10 = (invoice_date | std.date.to_text \"%-Hh %Mmin\"),\n    d11 = (invoice_date | std.date.to_text \"%M'%S\\\"\"),\n    d12 = (invoice_date | std.date.to_text \"100%% in %d days\"),\n}\n"
 input_file: prqlc/prqlc/tests/integration/queries/date_to_text.prql
 ---
 from db.invoices
 take 20
 select {
-  d1 = (invoice_date | date.to_text "%Y/%m/%d"),
-  d2 = (invoice_date | date.to_text "%F"),
-  d3 = (invoice_date | date.to_text "%D"),
-  d4 = (invoice_date | date.to_text "%H:%M:%S.%f"),
-  d5 = (invoice_date | date.to_text "%r"),
-  d6 = (invoice_date | date.to_text "%A %B %-d %Y"),
-  d7 = (invoice_date | date.to_text "%a, %-d %b %Y at %I:%M:%S %p"),
-  d8 = (invoice_date | date.to_text "%+"),
-  d9 = (invoice_date | date.to_text "%-d/%-m/%y"),
-  d10 = (invoice_date | date.to_text "%-Hh %Mmin"),
-  d11 = (invoice_date | date.to_text ""%M'%S"""),
-  d12 = (invoice_date | date.to_text "100%% in %d days"),
+  d1 = (invoice_date | std.date.to_text "%Y/%m/%d"),
+  d2 = (invoice_date | std.date.to_text "%F"),
+  d3 = (invoice_date | std.date.to_text "%D"),
+  d4 = (invoice_date | std.date.to_text "%H:%M:%S.%f"),
+  d5 = (invoice_date | std.date.to_text "%r"),
+  d6 = (invoice_date | std.date.to_text "%A %B %-d %Y"),
+  d7 = (invoice_date | std.date.to_text "%a, %-d %b %Y at %I:%M:%S %p"),
+  d8 = (invoice_date | std.date.to_text "%+"),
+  d9 = (invoice_date | std.date.to_text "%-d/%-m/%y"),
+  d10 = (invoice_date | std.date.to_text "%-Hh %Mmin"),
+  d11 = (invoice_date | std.date.to_text ""%M'%S"""),
+  d12 = (invoice_date | std.date.to_text "100%% in %d days"),
 }
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__genre_counts.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__genre_counts.snap
index 7475ed148767..20a915e44725 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__genre_counts.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__genre_counts.snap
@@ -1,6 +1,6 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# clickhouse:skip (ClickHouse prefers aliases to column names https://github.com/PRQL/prql/issues/2827)\n# mssql:test\nlet genre_count = (\n    from db.genres\n    aggregate {a = count name}\n)\n\ngenre_count\nfilter a > 0\nselect a = -a\n"
+expression: "# clickhouse:skip (ClickHouse prefers aliases to column names https://github.com/PRQL/prql/issues/2827)\n# mssql:test\nlet genre_count = (\n    from db.genres\n    aggregate {a = count name}\n)\n\nmodule.genre_count\nfilter a > 0\nselect a = -a\n"
 input_file: prqlc/prqlc/tests/integration/queries/genre_counts.prql
 ---
 let genre_count = (
@@ -8,7 +8,6 @@ let genre_count = (
   aggregate {a = count name}
 )
 
-genre_count
+module.genre_count
 filter a > 0
 select a = -a
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__group_all.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__group_all.snap
index ae4980264b7b..fbccc4136935 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__group_all.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__group_all.snap
@@ -1,6 +1,6 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# mssql:test\nfrom db.albums\nselect {a = this}\ntake 10\njoin db.tracks (==album_id)\ngroup {a.album_id, a.title} (aggregate price = (sum tracks.unit_price | math.round 2))\nsort album_id\n"
+expression: "# mssql:test\nfrom db.albums\nselect {a = this}\ntake 10\njoin db.tracks (==album_id)\ngroup {a.album_id, a.title} (\n  aggregate price = (sum tracks.unit_price | std.math.round 2)\n)\nsort album_id\n"
 input_file: prqlc/prqlc/tests/integration/queries/group_all.prql
 ---
 from db.albums
@@ -9,7 +9,6 @@ take 10
 join db.tracks (==album_id)
 group {a.album_id, a.title} (aggregate price = (
   sum tracks.unit_price
-  math.round 2
+  std.math.round 2
 ))
 sort album_id
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__math_module.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__math_module.snap
index e8df7d88ae5f..6261f5bd8d4e 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__math_module.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__math_module.snap
@@ -1,52 +1,60 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# mssql:test\n# sqlite:skip (see https://github.com/rusqlite/rusqlite/issues/1211)\nfrom db.invoices\ntake 5\nselect {\n    total_original = total | math.round 2,\n    total_x = math.pi - total | math.round 2 | math.abs,\n    total_floor = math.floor total,\n    total_ceil = math.ceil total,\n    total_log10 = math.log10 total | math.round 3,\n    total_log2 = math.log 2 total | math.round 3,\n    total_sqrt = math.sqrt total | math.round 3,\n    total_ln = math.ln total | math.exp | math.round 2,\n    total_cos = math.cos total | math.acos | math.round 2,\n    total_sin = math.sin total | math.asin | math.round 2,\n    total_tan = math.tan total | math.atan | math.round 2,\n    total_deg = total | math.degrees | math.radians | math.round 2,\n    total_square = total | math.pow 2| math.round 2,\n}\n"
+expression: "# mssql:test\n# sqlite:skip (see https://github.com/rusqlite/rusqlite/issues/1211)\nfrom db.invoices\ntake 5\nselect {\n    total_original = total | std.math.round 2,\n    total_x = std.math.pi - total | std.math.round 2 | std.math.abs,\n    total_floor = std.math.floor total,\n    total_ceil = std.math.ceil total,\n    total_log10 = std.math.log10 total | std.math.round 3,\n    total_log2 = std.math.log 2 total | std.math.round 3,\n    total_sqrt = std.math.sqrt total | std.math.round 3,\n    total_ln = std.math.ln total | std.math.exp | std.math.round 2,\n    total_cos = std.math.cos total | std.math.acos | std.math.round 2,\n    total_sin = std.math.sin total | std.math.asin | std.math.round 2,\n    total_tan = std.math.tan total | std.math.atan | std.math.round 2,\n    total_deg = total | std.math.degrees | std.math.radians | std.math.round 2,\n    total_square = total | std.math.pow 2| std.math.round 2,\n}\n"
 input_file: prqlc/prqlc/tests/integration/queries/math_module.prql
 ---
 from db.invoices
 take 5
 select {
-  total_original = (total | math.round 2),
+  total_original = (total | std.math.round 2),
   total_x = (
-    math.pi - total
-    math.round 2
-    math.abs
-  ),
-  total_floor = math.floor total,
-  total_ceil = math.ceil total,
-  total_log10 = (math.log10 total | math.round 3),
-  total_log2 = (math.log 2 total | math.round 3),
-  total_sqrt = (math.sqrt total | math.round 3),
+    std.math.pi - total
+    std.math.round 2
+    std.math.abs
+  ),
+  total_floor = std.math.floor total,
+  total_ceil = std.math.ceil total,
+  total_log10 = (
+    std.math.log10 total
+    std.math.round 3
+  ),
+  total_log2 = (
+    std.math.log 2 total
+    std.math.round 3
+  ),
+  total_sqrt = (
+    std.math.sqrt total
+    std.math.round 3
+  ),
   total_ln = (
-    math.ln total
-    math.exp
-    math.round 2
+    std.math.ln total
+    std.math.exp
+    std.math.round 2
   ),
   total_cos = (
-    math.cos total
-    math.acos
-    math.round 2
+    std.math.cos total
+    std.math.acos
+    std.math.round 2
   ),
   total_sin = (
-    math.sin total
-    math.asin
-    math.round 2
+    std.math.sin total
+    std.math.asin
+    std.math.round 2
   ),
   total_tan = (
-    math.tan total
-    math.atan
-    math.round 2
+    std.math.tan total
+    std.math.atan
+    std.math.round 2
   ),
   total_deg = (
     total
-    math.degrees
-    math.radians
-    math.round 2
+    std.math.degrees
+    std.math.radians
+    std.math.round 2
   ),
   total_square = (
     total
-    math.pow 2
-    math.round 2
+    std.math.pow 2
+    std.math.round 2
   ),
 }
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__read_csv.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__read_csv.snap
index 2d610153ce85..441e5642329a 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__read_csv.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__read_csv.snap
@@ -1,8 +1,7 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# sqlite:skip\n# postgres:skip\n# mysql:skip\nread_csv \"data_file_root/media_types.csv\"\nsort media_type_id\n"
+expression: "# sqlite:skip\n# postgres:skip\n# mysql:skip\nstd.read_csv \"data_file_root/media_types.csv\"\nsort media_type_id\n"
 input_file: prqlc/prqlc/tests/integration/queries/read_csv.prql
 ---
-read_csv "data_file_root/media_types.csv"
+std.read_csv "data_file_root/media_types.csv"
 sort media_type_id
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__set_ops_remove.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__set_ops_remove.snap
index 387843ecf78d..ad6a5bddec13 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__set_ops_remove.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__set_ops_remove.snap
@@ -1,12 +1,11 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# mssql:test\nlet distinct = rel -> (rel | group this (take 1))\n\nfrom_text format:json '{ \"columns\": [\"a\"], \"data\": [[1], [2], [2], [3]] }'\ndistinct\nremove (from_text format:json '{ \"columns\": [\"a\"], \"data\": [[1], [2]] }')\nsort a\n"
+expression: "# mssql:test\nlet distinct = rel -> (rel | group this (take 1))\n\nstd.from_text format:json '{ \"columns\": [\"a\"], \"data\": [[1], [2], [2], [3]] }'\nmodule.distinct\nremove (std.from_text format:json '{ \"columns\": [\"a\"], \"data\": [[1], [2]] }')\nsort a\n"
 input_file: prqlc/prqlc/tests/integration/queries/set_ops_remove.prql
 ---
 let distinct = func rel -> (rel | group this (take 1))
 
-from_text format:json '{ "columns": ["a"], "data": [[1], [2], [2], [3]] }'
-distinct
-remove (from_text format:json '{ "columns": ["a"], "data": [[1], [2]] }')
+std.from_text format:json '{ "columns": ["a"], "data": [[1], [2], [2], [3]] }'
+module.distinct
+remove (std.from_text format:json '{ "columns": ["a"], "data": [[1], [2]] }')
 sort a
-
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__text_module.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__text_module.snap
index c57963a264b0..816489811436 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__text_module.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__fmt__text_module.snap
@@ -1,24 +1,25 @@
 ---
 source: prqlc/prqlc/tests/integration/queries.rs
-expression: "# mssql:test\nfrom db.albums\nselect {\n    title,\n    title_and_spaces = f\"  {title}  \",\n    low = title | text.lower,\n    up = title | text.upper,\n    ltrimmed = title | text.ltrim,\n    rtrimmed = title | text.rtrim,\n    trimmed = title | text.trim,\n    len = title | text.length,\n    subs = title | text.extract 2 5,\n    replace = title | text.replace \"al\" \"PIKA\",\n}\nsort {title}\nfilter (title | text.starts_with \"Black\") || (title | text.contains \"Sabbath\") || (title | text.ends_with \"os\")\n"
+expression: "# mssql:test\nfrom db.albums\nselect {\n    title,\n    title_and_spaces = f\"  {title}  \",\n    low = title | std.text.lower,\n    up = title | std.text.upper,\n    ltrimmed = title | std.text.ltrim,\n    rtrimmed = title | std.text.rtrim,\n    trimmed = title | std.text.trim,\n    len = title | std.text.length,\n    subs = title | std.text.extract 2 5,\n    replace = title | std.text.replace \"al\" \"PIKA\",\n}\nsort {title}\nfilter (title | std.text.starts_with \"Black\") || (title | std.text.contains \"Sabbath\") || (title | std.text.ends_with \"os\")\n"
 input_file: prqlc/prqlc/tests/integration/queries/text_module.prql
 ---
 from db.albums
 select {
   title,
   title_and_spaces = f"  {title}  ",
-  low = (title | text.lower),
-  up = (title | text.upper),
-  ltrimmed = (title | text.ltrim),
-  rtrimmed = (title | text.rtrim),
-  trimmed = (title | text.trim),
-  len = (title | text.length),
-  subs = (title | text.extract 2 5),
-  replace = (title | text.replace "al" "PIKA"),
+  low = (title | std.text.lower),
+  up = (title | std.text.upper),
+  ltrimmed = (title | std.text.ltrim),
+  rtrimmed = (title | std.text.rtrim),
+  trimmed = (title | std.text.trim),
+  len = (title | std.text.length),
+  subs = (title | std.text.extract 2 5),
+  replace = (title | std.text.replace "al" "PIKA"),
 }
 sort {title}
-filter ((title | text.starts_with "Black") || (
-  title
-  text.contains "Sabbath"
-)) || (title | text.ends_with "os")
-
+filter (
+  (title | std.text.starts_with "Black") || (
+    title
+    std.text.contains "Sabbath"
+  )
+) || (title | std.text.ends_with "os")
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__arithmetic.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__arithmetic.snap
index 990870cdf69f..7019552d4a8a 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__arithmetic.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__arithmetic.snap
@@ -203,58 +203,66 @@ TokenVec (
   664..665: Control('+'),
   666..670: Ident("r_ii"),
   671..672: Control('|'),
-  673..677: Ident("math"),
-  677..678: Control('.'),
-  678..683: Ident("round"),
-  684..685: Literal(Integer(0)),
-  685..686: Control(')'),
-  686..687: Control(','),
-  687..688: NewLine,
-  692..693: Control('('),
-  693..697: Ident("q_if"),
-  698..699: Control('*'),
-  700..707: Ident("k_float"),
-  708..709: Control('+'),
-  710..714: Ident("r_if"),
-  715..716: Control('|'),
-  717..721: Ident("math"),
-  721..722: Control('.'),
-  722..727: Ident("round"),
-  728..729: Literal(Integer(0)),
-  729..730: Control(')'),
-  730..731: Control(','),
-  731..732: NewLine,
-  736..737: Control('('),
-  737..741: Ident("q_fi"),
-  742..743: Control('*'),
-  744..749: Ident("k_int"),
-  750..751: Control('+'),
-  752..756: Ident("r_fi"),
-  757..758: Control('|'),
-  759..763: Ident("math"),
-  763..764: Control('.'),
-  764..769: Ident("round"),
-  770..771: Literal(Integer(0)),
-  771..772: Control(')'),
-  772..773: Control(','),
-  773..774: NewLine,
-  778..779: Control('('),
-  779..783: Ident("q_ff"),
-  784..785: Control('*'),
-  786..793: Ident("k_float"),
-  794..795: Control('+'),
-  796..800: Ident("r_ff"),
-  801..802: Control('|'),
-  803..807: Ident("math"),
-  807..808: Control('.'),
-  808..813: Ident("round"),
-  814..815: Literal(Integer(0)),
-  815..816: Control(')'),
-  816..817: Control(','),
-  817..818: NewLine,
-  818..819: Control('}'),
-  819..820: NewLine,
-  820..824: Ident("sort"),
-  825..827: Ident("id"),
-  827..828: NewLine,
+  673..676: Ident("std"),
+  676..677: Control('.'),
+  677..681: Ident("math"),
+  681..682: Control('.'),
+  682..687: Ident("round"),
+  688..689: Literal(Integer(0)),
+  689..690: Control(')'),
+  690..691: Control(','),
+  691..692: NewLine,
+  696..697: Control('('),
+  697..701: Ident("q_if"),
+  702..703: Control('*'),
+  704..711: Ident("k_float"),
+  712..713: Control('+'),
+  714..718: Ident("r_if"),
+  719..720: Control('|'),
+  721..724: Ident("std"),
+  724..725: Control('.'),
+  725..729: Ident("math"),
+  729..730: Control('.'),
+  730..735: Ident("round"),
+  736..737: Literal(Integer(0)),
+  737..738: Control(')'),
+  738..739: Control(','),
+  739..740: NewLine,
+  744..745: Control('('),
+  745..749: Ident("q_fi"),
+  750..751: Control('*'),
+  752..757: Ident("k_int"),
+  758..759: Control('+'),
+  760..764: Ident("r_fi"),
+  765..766: Control('|'),
+  767..770: Ident("std"),
+  770..771: Control('.'),
+  771..775: Ident("math"),
+  775..776: Control('.'),
+  776..781: Ident("round"),
+  782..783: Literal(Integer(0)),
+  783..784: Control(')'),
+  784..785: Control(','),
+  785..786: NewLine,
+  790..791: Control('('),
+  791..795: Ident("q_ff"),
+  796..797: Control('*'),
+  798..805: Ident("k_float"),
+  806..807: Control('+'),
+  808..812: Ident("r_ff"),
+  813..814: Control('|'),
+  815..818: Ident("std"),
+  818..819: Control('.'),
+  819..823: Ident("math"),
+  823..824: Control('.'),
+  824..829: Ident("round"),
+  830..831: Literal(Integer(0)),
+  831..832: Control(')'),
+  832..833: Control(','),
+  833..834: NewLine,
+  834..835: Control('}'),
+  835..836: NewLine,
+  836..840: Ident("sort"),
+  841..843: Ident("id"),
+  843..844: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__date_to_text.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__date_to_text.snap
index bdbe062eddd0..e1df1c792614 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__date_to_text.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__date_to_text.snap
@@ -28,145 +28,169 @@ TokenVec (
   100..101: Control('('),
   101..113: Ident("invoice_date"),
   114..115: Control('|'),
-  116..120: Ident("date"),
-  120..121: Control('.'),
-  121..128: Ident("to_text"),
-  129..139: Literal(String("%Y/%m/%d")),
-  139..140: Control(')'),
-  140..141: Control(','),
-  141..142: NewLine,
-  146..148: Ident("d2"),
-  149..150: Control('='),
-  151..152: Control('('),
-  152..164: Ident("invoice_date"),
-  165..166: Control('|'),
-  167..171: Ident("date"),
-  171..172: Control('.'),
-  172..179: Ident("to_text"),
-  180..184: Literal(String("%F")),
-  184..185: Control(')'),
-  185..186: Control(','),
-  186..187: NewLine,
-  191..193: Ident("d3"),
-  194..195: Control('='),
-  196..197: Control('('),
-  197..209: Ident("invoice_date"),
-  210..211: Control('|'),
-  212..216: Ident("date"),
-  216..217: Control('.'),
-  217..224: Ident("to_text"),
-  225..229: Literal(String("%D")),
-  229..230: Control(')'),
-  230..231: Control(','),
-  231..232: NewLine,
-  236..238: Ident("d4"),
-  239..240: Control('='),
-  241..242: Control('('),
-  242..254: Ident("invoice_date"),
-  255..256: Control('|'),
-  257..261: Ident("date"),
-  261..262: Control('.'),
-  262..269: Ident("to_text"),
-  270..283: Literal(String("%H:%M:%S.%f")),
-  283..284: Control(')'),
-  284..285: Control(','),
-  285..286: NewLine,
-  290..292: Ident("d5"),
-  293..294: Control('='),
-  295..296: Control('('),
-  296..308: Ident("invoice_date"),
-  309..310: Control('|'),
-  311..315: Ident("date"),
-  315..316: Control('.'),
-  316..323: Ident("to_text"),
-  324..328: Literal(String("%r")),
-  328..329: Control(')'),
-  329..330: Control(','),
-  330..331: NewLine,
-  335..337: Ident("d6"),
-  338..339: Control('='),
-  340..341: Control('('),
-  341..353: Ident("invoice_date"),
-  354..355: Control('|'),
-  356..360: Ident("date"),
-  360..361: Control('.'),
-  361..368: Ident("to_text"),
-  369..383: Literal(String("%A %B %-d %Y")),
-  383..384: Control(')'),
-  384..385: Control(','),
-  385..386: NewLine,
-  390..392: Ident("d7"),
-  393..394: Control('='),
-  395..396: Control('('),
-  396..408: Ident("invoice_date"),
-  409..410: Control('|'),
-  411..415: Ident("date"),
-  415..416: Control('.'),
-  416..423: Ident("to_text"),
-  424..454: Literal(String("%a, %-d %b %Y at %I:%M:%S %p")),
-  454..455: Control(')'),
-  455..456: Control(','),
-  456..457: NewLine,
-  461..463: Ident("d8"),
-  464..465: Control('='),
-  466..467: Control('('),
-  467..479: Ident("invoice_date"),
-  480..481: Control('|'),
-  482..486: Ident("date"),
-  486..487: Control('.'),
-  487..494: Ident("to_text"),
-  495..499: Literal(String("%+")),
-  499..500: Control(')'),
-  500..501: Control(','),
-  501..502: NewLine,
-  506..508: Ident("d9"),
-  509..510: Control('='),
-  511..512: Control('('),
-  512..524: Ident("invoice_date"),
-  525..526: Control('|'),
-  527..531: Ident("date"),
-  531..532: Control('.'),
-  532..539: Ident("to_text"),
-  540..552: Literal(String("%-d/%-m/%y")),
-  552..553: Control(')'),
-  553..554: Control(','),
-  554..555: NewLine,
-  559..562: Ident("d10"),
-  563..564: Control('='),
-  565..566: Control('('),
-  566..578: Ident("invoice_date"),
-  579..580: Control('|'),
-  581..585: Ident("date"),
-  585..586: Control('.'),
-  586..593: Ident("to_text"),
-  594..606: Literal(String("%-Hh %Mmin")),
-  606..607: Control(')'),
-  607..608: Control(','),
-  608..609: NewLine,
-  613..616: Ident("d11"),
-  617..618: Control('='),
-  619..620: Control('('),
-  620..632: Ident("invoice_date"),
-  633..634: Control('|'),
-  635..639: Ident("date"),
-  639..640: Control('.'),
-  640..647: Ident("to_text"),
-  648..657: Literal(String("%M'%S\"")),
-  657..658: Control(')'),
-  658..659: Control(','),
-  659..660: NewLine,
-  664..667: Ident("d12"),
-  668..669: Control('='),
-  670..671: Control('('),
-  671..683: Ident("invoice_date"),
-  684..685: Control('|'),
-  686..690: Ident("date"),
-  690..691: Control('.'),
-  691..698: Ident("to_text"),
-  699..717: Literal(String("100%% in %d days")),
-  717..718: Control(')'),
-  718..719: Control(','),
-  719..720: NewLine,
-  720..721: Control('}'),
-  721..722: NewLine,
+  116..119: Ident("std"),
+  119..120: Control('.'),
+  120..124: Ident("date"),
+  124..125: Control('.'),
+  125..132: Ident("to_text"),
+  133..143: Literal(String("%Y/%m/%d")),
+  143..144: Control(')'),
+  144..145: Control(','),
+  145..146: NewLine,
+  150..152: Ident("d2"),
+  153..154: Control('='),
+  155..156: Control('('),
+  156..168: Ident("invoice_date"),
+  169..170: Control('|'),
+  171..174: Ident("std"),
+  174..175: Control('.'),
+  175..179: Ident("date"),
+  179..180: Control('.'),
+  180..187: Ident("to_text"),
+  188..192: Literal(String("%F")),
+  192..193: Control(')'),
+  193..194: Control(','),
+  194..195: NewLine,
+  199..201: Ident("d3"),
+  202..203: Control('='),
+  204..205: Control('('),
+  205..217: Ident("invoice_date"),
+  218..219: Control('|'),
+  220..223: Ident("std"),
+  223..224: Control('.'),
+  224..228: Ident("date"),
+  228..229: Control('.'),
+  229..236: Ident("to_text"),
+  237..241: Literal(String("%D")),
+  241..242: Control(')'),
+  242..243: Control(','),
+  243..244: NewLine,
+  248..250: Ident("d4"),
+  251..252: Control('='),
+  253..254: Control('('),
+  254..266: Ident("invoice_date"),
+  267..268: Control('|'),
+  269..272: Ident("std"),
+  272..273: Control('.'),
+  273..277: Ident("date"),
+  277..278: Control('.'),
+  278..285: Ident("to_text"),
+  286..299: Literal(String("%H:%M:%S.%f")),
+  299..300: Control(')'),
+  300..301: Control(','),
+  301..302: NewLine,
+  306..308: Ident("d5"),
+  309..310: Control('='),
+  311..312: Control('('),
+  312..324: Ident("invoice_date"),
+  325..326: Control('|'),
+  327..330: Ident("std"),
+  330..331: Control('.'),
+  331..335: Ident("date"),
+  335..336: Control('.'),
+  336..343: Ident("to_text"),
+  344..348: Literal(String("%r")),
+  348..349: Control(')'),
+  349..350: Control(','),
+  350..351: NewLine,
+  355..357: Ident("d6"),
+  358..359: Control('='),
+  360..361: Control('('),
+  361..373: Ident("invoice_date"),
+  374..375: Control('|'),
+  376..379: Ident("std"),
+  379..380: Control('.'),
+  380..384: Ident("date"),
+  384..385: Control('.'),
+  385..392: Ident("to_text"),
+  393..407: Literal(String("%A %B %-d %Y")),
+  407..408: Control(')'),
+  408..409: Control(','),
+  409..410: NewLine,
+  414..416: Ident("d7"),
+  417..418: Control('='),
+  419..420: Control('('),
+  420..432: Ident("invoice_date"),
+  433..434: Control('|'),
+  435..438: Ident("std"),
+  438..439: Control('.'),
+  439..443: Ident("date"),
+  443..444: Control('.'),
+  444..451: Ident("to_text"),
+  452..482: Literal(String("%a, %-d %b %Y at %I:%M:%S %p")),
+  482..483: Control(')'),
+  483..484: Control(','),
+  484..485: NewLine,
+  489..491: Ident("d8"),
+  492..493: Control('='),
+  494..495: Control('('),
+  495..507: Ident("invoice_date"),
+  508..509: Control('|'),
+  510..513: Ident("std"),
+  513..514: Control('.'),
+  514..518: Ident("date"),
+  518..519: Control('.'),
+  519..526: Ident("to_text"),
+  527..531: Literal(String("%+")),
+  531..532: Control(')'),
+  532..533: Control(','),
+  533..534: NewLine,
+  538..540: Ident("d9"),
+  541..542: Control('='),
+  543..544: Control('('),
+  544..556: Ident("invoice_date"),
+  557..558: Control('|'),
+  559..562: Ident("std"),
+  562..563: Control('.'),
+  563..567: Ident("date"),
+  567..568: Control('.'),
+  568..575: Ident("to_text"),
+  576..588: Literal(String("%-d/%-m/%y")),
+  588..589: Control(')'),
+  589..590: Control(','),
+  590..591: NewLine,
+  595..598: Ident("d10"),
+  599..600: Control('='),
+  601..602: Control('('),
+  602..614: Ident("invoice_date"),
+  615..616: Control('|'),
+  617..620: Ident("std"),
+  620..621: Control('.'),
+  621..625: Ident("date"),
+  625..626: Control('.'),
+  626..633: Ident("to_text"),
+  634..646: Literal(String("%-Hh %Mmin")),
+  646..647: Control(')'),
+  647..648: Control(','),
+  648..649: NewLine,
+  653..656: Ident("d11"),
+  657..658: Control('='),
+  659..660: Control('('),
+  660..672: Ident("invoice_date"),
+  673..674: Control('|'),
+  675..678: Ident("std"),
+  678..679: Control('.'),
+  679..683: Ident("date"),
+  683..684: Control('.'),
+  684..691: Ident("to_text"),
+  692..701: Literal(String("%M'%S\"")),
+  701..702: Control(')'),
+  702..703: Control(','),
+  703..704: NewLine,
+  708..711: Ident("d12"),
+  712..713: Control('='),
+  714..715: Control('('),
+  715..727: Ident("invoice_date"),
+  728..729: Control('|'),
+  730..733: Ident("std"),
+  733..734: Control('.'),
+  734..738: Ident("date"),
+  738..739: Control('.'),
+  739..746: Ident("to_text"),
+  747..765: Literal(String("100%% in %d days")),
+  765..766: Control(')'),
+  766..767: Control(','),
+  767..768: NewLine,
+  768..769: Control('}'),
+  769..770: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__genre_counts.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__genre_counts.snap
index 88ee27c768e4..fa155cc38088 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__genre_counts.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__genre_counts.snap
@@ -29,17 +29,19 @@ TokenVec (
   187..188: Control(')'),
   188..189: NewLine,
   189..190: NewLine,
-  190..201: Ident("genre_count"),
-  201..202: NewLine,
-  202..208: Ident("filter"),
-  209..210: Ident("a"),
-  211..212: Control('>'),
-  213..214: Literal(Integer(0)),
-  214..215: NewLine,
-  215..221: Ident("select"),
-  222..223: Ident("a"),
-  224..225: Control('='),
-  226..227: Control('-'),
-  227..228: Ident("a"),
-  228..229: NewLine,
+  190..196: Ident("module"),
+  196..197: Control('.'),
+  197..208: Ident("genre_count"),
+  208..209: NewLine,
+  209..215: Ident("filter"),
+  216..217: Ident("a"),
+  218..219: Control('>'),
+  220..221: Literal(Integer(0)),
+  221..222: NewLine,
+  222..228: Ident("select"),
+  229..230: Ident("a"),
+  231..232: Control('='),
+  233..234: Control('-'),
+  234..235: Ident("a"),
+  235..236: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__group_all.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__group_all.snap
index 140d48ef546a..2d74c5744e91 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__group_all.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__group_all.snap
@@ -41,23 +41,27 @@ TokenVec (
   103..108: Ident("title"),
   108..109: Control('}'),
   110..111: Control('('),
-  111..120: Ident("aggregate"),
-  121..126: Ident("price"),
-  127..128: Control('='),
-  129..130: Control('('),
-  130..133: Ident("sum"),
-  134..140: Ident("tracks"),
-  140..141: Control('.'),
-  141..151: Ident("unit_price"),
-  152..153: Control('|'),
-  154..158: Ident("math"),
-  158..159: Control('.'),
-  159..164: Ident("round"),
-  165..166: Literal(Integer(2)),
-  166..167: Control(')'),
-  167..168: Control(')'),
-  168..169: NewLine,
-  169..173: Ident("sort"),
-  174..182: Ident("album_id"),
-  182..183: NewLine,
+  111..112: NewLine,
+  114..123: Ident("aggregate"),
+  124..129: Ident("price"),
+  130..131: Control('='),
+  132..133: Control('('),
+  133..136: Ident("sum"),
+  137..143: Ident("tracks"),
+  143..144: Control('.'),
+  144..154: Ident("unit_price"),
+  155..156: Control('|'),
+  157..160: Ident("std"),
+  160..161: Control('.'),
+  161..165: Ident("math"),
+  165..166: Control('.'),
+  166..171: Ident("round"),
+  172..173: Literal(Integer(2)),
+  173..174: Control(')'),
+  174..175: NewLine,
+  175..176: Control(')'),
+  176..177: NewLine,
+  177..181: Ident("sort"),
+  182..190: Ident("album_id"),
+  190..191: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__math_module.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__math_module.snap
index 04da9461d699..4b14e9f9e1a7 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__math_module.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__math_module.snap
@@ -23,187 +23,245 @@ TokenVec (
   134..135: Control('='),
   136..141: Ident("total"),
   142..143: Control('|'),
-  144..148: Ident("math"),
-  148..149: Control('.'),
-  149..154: Ident("round"),
-  155..156: Literal(Integer(2)),
-  156..157: Control(','),
-  157..158: NewLine,
-  162..169: Ident("total_x"),
-  170..171: Control('='),
-  172..176: Ident("math"),
-  176..177: Control('.'),
-  177..179: Ident("pi"),
-  180..181: Control('-'),
-  182..187: Ident("total"),
-  188..189: Control('|'),
-  190..194: Ident("math"),
-  194..195: Control('.'),
-  195..200: Ident("round"),
-  201..202: Literal(Integer(2)),
-  203..204: Control('|'),
-  205..209: Ident("math"),
-  209..210: Control('.'),
-  210..213: Ident("abs"),
-  213..214: Control(','),
-  214..215: NewLine,
-  219..230: Ident("total_floor"),
-  231..232: Control('='),
-  233..237: Ident("math"),
-  237..238: Control('.'),
-  238..243: Ident("floor"),
-  244..249: Ident("total"),
-  249..250: Control(','),
-  250..251: NewLine,
-  255..265: Ident("total_ceil"),
-  266..267: Control('='),
-  268..272: Ident("math"),
-  272..273: Control('.'),
-  273..277: Ident("ceil"),
-  278..283: Ident("total"),
-  283..284: Control(','),
-  284..285: NewLine,
-  289..300: Ident("total_log10"),
-  301..302: Control('='),
-  303..307: Ident("math"),
-  307..308: Control('.'),
-  308..313: Ident("log10"),
-  314..319: Ident("total"),
-  320..321: Control('|'),
-  322..326: Ident("math"),
-  326..327: Control('.'),
-  327..332: Ident("round"),
-  333..334: Literal(Integer(3)),
-  334..335: Control(','),
-  335..336: NewLine,
-  340..350: Ident("total_log2"),
-  351..352: Control('='),
-  353..357: Ident("math"),
-  357..358: Control('.'),
-  358..361: Ident("log"),
-  362..363: Literal(Integer(2)),
-  364..369: Ident("total"),
-  370..371: Control('|'),
-  372..376: Ident("math"),
-  376..377: Control('.'),
-  377..382: Ident("round"),
-  383..384: Literal(Integer(3)),
-  384..385: Control(','),
-  385..386: NewLine,
-  390..400: Ident("total_sqrt"),
-  401..402: Control('='),
-  403..407: Ident("math"),
-  407..408: Control('.'),
-  408..412: Ident("sqrt"),
-  413..418: Ident("total"),
-  419..420: Control('|'),
-  421..425: Ident("math"),
-  425..426: Control('.'),
-  426..431: Ident("round"),
-  432..433: Literal(Integer(3)),
-  433..434: Control(','),
-  434..435: NewLine,
-  439..447: Ident("total_ln"),
-  448..449: Control('='),
-  450..454: Ident("math"),
-  454..455: Control('.'),
-  455..457: Ident("ln"),
-  458..463: Ident("total"),
-  464..465: Control('|'),
-  466..470: Ident("math"),
-  470..471: Control('.'),
-  471..474: Ident("exp"),
-  475..476: Control('|'),
-  477..481: Ident("math"),
-  481..482: Control('.'),
-  482..487: Ident("round"),
-  488..489: Literal(Integer(2)),
-  489..490: Control(','),
-  490..491: NewLine,
-  495..504: Ident("total_cos"),
-  505..506: Control('='),
-  507..511: Ident("math"),
-  511..512: Control('.'),
-  512..515: Ident("cos"),
-  516..521: Ident("total"),
-  522..523: Control('|'),
-  524..528: Ident("math"),
-  528..529: Control('.'),
-  529..533: Ident("acos"),
-  534..535: Control('|'),
-  536..540: Ident("math"),
-  540..541: Control('.'),
-  541..546: Ident("round"),
-  547..548: Literal(Integer(2)),
-  548..549: Control(','),
-  549..550: NewLine,
-  554..563: Ident("total_sin"),
-  564..565: Control('='),
-  566..570: Ident("math"),
+  144..147: Ident("std"),
+  147..148: Control('.'),
+  148..152: Ident("math"),
+  152..153: Control('.'),
+  153..158: Ident("round"),
+  159..160: Literal(Integer(2)),
+  160..161: Control(','),
+  161..162: NewLine,
+  166..173: Ident("total_x"),
+  174..175: Control('='),
+  176..179: Ident("std"),
+  179..180: Control('.'),
+  180..184: Ident("math"),
+  184..185: Control('.'),
+  185..187: Ident("pi"),
+  188..189: Control('-'),
+  190..195: Ident("total"),
+  196..197: Control('|'),
+  198..201: Ident("std"),
+  201..202: Control('.'),
+  202..206: Ident("math"),
+  206..207: Control('.'),
+  207..212: Ident("round"),
+  213..214: Literal(Integer(2)),
+  215..216: Control('|'),
+  217..220: Ident("std"),
+  220..221: Control('.'),
+  221..225: Ident("math"),
+  225..226: Control('.'),
+  226..229: Ident("abs"),
+  229..230: Control(','),
+  230..231: NewLine,
+  235..246: Ident("total_floor"),
+  247..248: Control('='),
+  249..252: Ident("std"),
+  252..253: Control('.'),
+  253..257: Ident("math"),
+  257..258: Control('.'),
+  258..263: Ident("floor"),
+  264..269: Ident("total"),
+  269..270: Control(','),
+  270..271: NewLine,
+  275..285: Ident("total_ceil"),
+  286..287: Control('='),
+  288..291: Ident("std"),
+  291..292: Control('.'),
+  292..296: Ident("math"),
+  296..297: Control('.'),
+  297..301: Ident("ceil"),
+  302..307: Ident("total"),
+  307..308: Control(','),
+  308..309: NewLine,
+  313..324: Ident("total_log10"),
+  325..326: Control('='),
+  327..330: Ident("std"),
+  330..331: Control('.'),
+  331..335: Ident("math"),
+  335..336: Control('.'),
+  336..341: Ident("log10"),
+  342..347: Ident("total"),
+  348..349: Control('|'),
+  350..353: Ident("std"),
+  353..354: Control('.'),
+  354..358: Ident("math"),
+  358..359: Control('.'),
+  359..364: Ident("round"),
+  365..366: Literal(Integer(3)),
+  366..367: Control(','),
+  367..368: NewLine,
+  372..382: Ident("total_log2"),
+  383..384: Control('='),
+  385..388: Ident("std"),
+  388..389: Control('.'),
+  389..393: Ident("math"),
+  393..394: Control('.'),
+  394..397: Ident("log"),
+  398..399: Literal(Integer(2)),
+  400..405: Ident("total"),
+  406..407: Control('|'),
+  408..411: Ident("std"),
+  411..412: Control('.'),
+  412..416: Ident("math"),
+  416..417: Control('.'),
+  417..422: Ident("round"),
+  423..424: Literal(Integer(3)),
+  424..425: Control(','),
+  425..426: NewLine,
+  430..440: Ident("total_sqrt"),
+  441..442: Control('='),
+  443..446: Ident("std"),
+  446..447: Control('.'),
+  447..451: Ident("math"),
+  451..452: Control('.'),
+  452..456: Ident("sqrt"),
+  457..462: Ident("total"),
+  463..464: Control('|'),
+  465..468: Ident("std"),
+  468..469: Control('.'),
+  469..473: Ident("math"),
+  473..474: Control('.'),
+  474..479: Ident("round"),
+  480..481: Literal(Integer(3)),
+  481..482: Control(','),
+  482..483: NewLine,
+  487..495: Ident("total_ln"),
+  496..497: Control('='),
+  498..501: Ident("std"),
+  501..502: Control('.'),
+  502..506: Ident("math"),
+  506..507: Control('.'),
+  507..509: Ident("ln"),
+  510..515: Ident("total"),
+  516..517: Control('|'),
+  518..521: Ident("std"),
+  521..522: Control('.'),
+  522..526: Ident("math"),
+  526..527: Control('.'),
+  527..530: Ident("exp"),
+  531..532: Control('|'),
+  533..536: Ident("std"),
+  536..537: Control('.'),
+  537..541: Ident("math"),
+  541..542: Control('.'),
+  542..547: Ident("round"),
+  548..549: Literal(Integer(2)),
+  549..550: Control(','),
+  550..551: NewLine,
+  555..564: Ident("total_cos"),
+  565..566: Control('='),
+  567..570: Ident("std"),
   570..571: Control('.'),
-  571..574: Ident("sin"),
-  575..580: Ident("total"),
-  581..582: Control('|'),
-  583..587: Ident("math"),
-  587..588: Control('.'),
-  588..592: Ident("asin"),
-  593..594: Control('|'),
-  595..599: Ident("math"),
-  599..600: Control('.'),
-  600..605: Ident("round"),
-  606..607: Literal(Integer(2)),
-  607..608: Control(','),
-  608..609: NewLine,
-  613..622: Ident("total_tan"),
-  623..624: Control('='),
-  625..629: Ident("math"),
-  629..630: Control('.'),
-  630..633: Ident("tan"),
-  634..639: Ident("total"),
-  640..641: Control('|'),
+  571..575: Ident("math"),
+  575..576: Control('.'),
+  576..579: Ident("cos"),
+  580..585: Ident("total"),
+  586..587: Control('|'),
+  588..591: Ident("std"),
+  591..592: Control('.'),
+  592..596: Ident("math"),
+  596..597: Control('.'),
+  597..601: Ident("acos"),
+  602..603: Control('|'),
+  604..607: Ident("std"),
+  607..608: Control('.'),
+  608..612: Ident("math"),
+  612..613: Control('.'),
+  613..618: Ident("round"),
+  619..620: Literal(Integer(2)),
+  620..621: Control(','),
+  621..622: NewLine,
+  626..635: Ident("total_sin"),
+  636..637: Control('='),
+  638..641: Ident("std"),
+  641..642: Control('.'),
   642..646: Ident("math"),
   646..647: Control('.'),
-  647..651: Ident("atan"),
-  652..653: Control('|'),
-  654..658: Ident("math"),
-  658..659: Control('.'),
-  659..664: Ident("round"),
-  665..666: Literal(Integer(2)),
-  666..667: Control(','),
-  667..668: NewLine,
-  672..681: Ident("total_deg"),
-  682..683: Control('='),
-  684..689: Ident("total"),
-  690..691: Control('|'),
-  692..696: Ident("math"),
-  696..697: Control('.'),
-  697..704: Ident("degrees"),
-  705..706: Control('|'),
-  707..711: Ident("math"),
-  711..712: Control('.'),
-  712..719: Ident("radians"),
-  720..721: Control('|'),
-  722..726: Ident("math"),
-  726..727: Control('.'),
-  727..732: Ident("round"),
-  733..734: Literal(Integer(2)),
-  734..735: Control(','),
-  735..736: NewLine,
-  740..752: Ident("total_square"),
-  753..754: Control('='),
-  755..760: Ident("total"),
-  761..762: Control('|'),
-  763..767: Ident("math"),
-  767..768: Control('.'),
-  768..771: Ident("pow"),
-  772..773: Literal(Integer(2)),
-  773..774: Control('|'),
-  775..779: Ident("math"),
-  779..780: Control('.'),
-  780..785: Ident("round"),
-  786..787: Literal(Integer(2)),
-  787..788: Control(','),
-  788..789: NewLine,
-  789..790: Control('}'),
-  790..791: NewLine,
+  647..650: Ident("sin"),
+  651..656: Ident("total"),
+  657..658: Control('|'),
+  659..662: Ident("std"),
+  662..663: Control('.'),
+  663..667: Ident("math"),
+  667..668: Control('.'),
+  668..672: Ident("asin"),
+  673..674: Control('|'),
+  675..678: Ident("std"),
+  678..679: Control('.'),
+  679..683: Ident("math"),
+  683..684: Control('.'),
+  684..689: Ident("round"),
+  690..691: Literal(Integer(2)),
+  691..692: Control(','),
+  692..693: NewLine,
+  697..706: Ident("total_tan"),
+  707..708: Control('='),
+  709..712: Ident("std"),
+  712..713: Control('.'),
+  713..717: Ident("math"),
+  717..718: Control('.'),
+  718..721: Ident("tan"),
+  722..727: Ident("total"),
+  728..729: Control('|'),
+  730..733: Ident("std"),
+  733..734: Control('.'),
+  734..738: Ident("math"),
+  738..739: Control('.'),
+  739..743: Ident("atan"),
+  744..745: Control('|'),
+  746..749: Ident("std"),
+  749..750: Control('.'),
+  750..754: Ident("math"),
+  754..755: Control('.'),
+  755..760: Ident("round"),
+  761..762: Literal(Integer(2)),
+  762..763: Control(','),
+  763..764: NewLine,
+  768..777: Ident("total_deg"),
+  778..779: Control('='),
+  780..785: Ident("total"),
+  786..787: Control('|'),
+  788..791: Ident("std"),
+  791..792: Control('.'),
+  792..796: Ident("math"),
+  796..797: Control('.'),
+  797..804: Ident("degrees"),
+  805..806: Control('|'),
+  807..810: Ident("std"),
+  810..811: Control('.'),
+  811..815: Ident("math"),
+  815..816: Control('.'),
+  816..823: Ident("radians"),
+  824..825: Control('|'),
+  826..829: Ident("std"),
+  829..830: Control('.'),
+  830..834: Ident("math"),
+  834..835: Control('.'),
+  835..840: Ident("round"),
+  841..842: Literal(Integer(2)),
+  842..843: Control(','),
+  843..844: NewLine,
+  848..860: Ident("total_square"),
+  861..862: Control('='),
+  863..868: Ident("total"),
+  869..870: Control('|'),
+  871..874: Ident("std"),
+  874..875: Control('.'),
+  875..879: Ident("math"),
+  879..880: Control('.'),
+  880..883: Ident("pow"),
+  884..885: Literal(Integer(2)),
+  885..886: Control('|'),
+  887..890: Ident("std"),
+  890..891: Control('.'),
+  891..895: Ident("math"),
+  895..896: Control('.'),
+  896..901: Ident("round"),
+  902..903: Literal(Integer(2)),
+  903..904: Control(','),
+  904..905: NewLine,
+  905..906: Control('}'),
+  906..907: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__read_csv.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__read_csv.snap
index c2927c9b4b91..0ee6b5851cf1 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__read_csv.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__read_csv.snap
@@ -10,10 +10,12 @@ TokenVec (
   29..30: NewLine,
   30..42: Comment(" mysql:skip"),
   42..43: NewLine,
-  43..51: Ident("read_csv"),
-  52..84: Literal(String("data_file_root/media_types.csv")),
-  84..85: NewLine,
-  85..89: Ident("sort"),
-  90..103: Ident("media_type_id"),
-  103..104: NewLine,
+  43..46: Ident("std"),
+  46..47: Control('.'),
+  47..55: Ident("read_csv"),
+  56..88: Literal(String("data_file_root/media_types.csv")),
+  88..89: NewLine,
+  89..93: Ident("sort"),
+  94..107: Ident("media_type_id"),
+  107..108: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__set_ops_remove.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__set_ops_remove.snap
index c37211e46612..c70052f01bcf 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__set_ops_remove.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__set_ops_remove.snap
@@ -23,24 +23,30 @@ TokenVec (
   61..62: Control(')'),
   62..63: NewLine,
   63..64: NewLine,
-  64..73: Ident("from_text"),
-  74..80: Ident("format"),
-  80..81: Control(':'),
-  81..85: Ident("json"),
-  86..138: Literal(String("{ \"columns\": [\"a\"], \"data\": [[1], [2], [2], [3]] }")),
-  138..139: NewLine,
-  139..147: Ident("distinct"),
-  147..148: NewLine,
-  148..154: Ident("remove"),
-  155..156: Control('('),
-  156..165: Ident("from_text"),
-  166..172: Ident("format"),
-  172..173: Control(':'),
-  173..177: Ident("json"),
-  178..220: Literal(String("{ \"columns\": [\"a\"], \"data\": [[1], [2]] }")),
-  220..221: Control(')'),
-  221..222: NewLine,
-  222..226: Ident("sort"),
-  227..228: Ident("a"),
-  228..229: NewLine,
+  64..67: Ident("std"),
+  67..68: Control('.'),
+  68..77: Ident("from_text"),
+  78..84: Ident("format"),
+  84..85: Control(':'),
+  85..89: Ident("json"),
+  90..142: Literal(String("{ \"columns\": [\"a\"], \"data\": [[1], [2], [2], [3]] }")),
+  142..143: NewLine,
+  143..149: Ident("module"),
+  149..150: Control('.'),
+  150..158: Ident("distinct"),
+  158..159: NewLine,
+  159..165: Ident("remove"),
+  166..167: Control('('),
+  167..170: Ident("std"),
+  170..171: Control('.'),
+  171..180: Ident("from_text"),
+  181..187: Ident("format"),
+  187..188: Control(':'),
+  188..192: Ident("json"),
+  193..235: Literal(String("{ \"columns\": [\"a\"], \"data\": [[1], [2]] }")),
+  235..236: Control(')'),
+  236..237: NewLine,
+  237..241: Ident("sort"),
+  242..243: Ident("a"),
+  243..244: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__text_module.snap b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__text_module.snap
index 3ec462cd7d51..13bcd3161da3 100644
--- a/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__text_module.snap
+++ b/prqlc/prqlc/tests/integration/snapshots/integration__queries__lex__text_module.snap
@@ -26,111 +26,133 @@ TokenVec (
   95..96: Control('='),
   97..102: Ident("title"),
   103..104: Control('|'),
-  105..109: Ident("text"),
-  109..110: Control('.'),
-  110..115: Ident("lower"),
-  115..116: Control(','),
-  116..117: NewLine,
-  121..123: Ident("up"),
-  124..125: Control('='),
-  126..131: Ident("title"),
-  132..133: Control('|'),
-  134..138: Ident("text"),
-  138..139: Control('.'),
-  139..144: Ident("upper"),
-  144..145: Control(','),
-  145..146: NewLine,
-  150..158: Ident("ltrimmed"),
-  159..160: Control('='),
-  161..166: Ident("title"),
-  167..168: Control('|'),
-  169..173: Ident("text"),
-  173..174: Control('.'),
-  174..179: Ident("ltrim"),
-  179..180: Control(','),
-  180..181: NewLine,
-  185..193: Ident("rtrimmed"),
-  194..195: Control('='),
-  196..201: Ident("title"),
-  202..203: Control('|'),
-  204..208: Ident("text"),
-  208..209: Control('.'),
-  209..214: Ident("rtrim"),
-  214..215: Control(','),
-  215..216: NewLine,
-  220..227: Ident("trimmed"),
-  228..229: Control('='),
-  230..235: Ident("title"),
-  236..237: Control('|'),
-  238..242: Ident("text"),
-  242..243: Control('.'),
-  243..247: Ident("trim"),
-  247..248: Control(','),
-  248..249: NewLine,
-  253..256: Ident("len"),
-  257..258: Control('='),
-  259..264: Ident("title"),
-  265..266: Control('|'),
-  267..271: Ident("text"),
-  271..272: Control('.'),
-  272..278: Ident("length"),
-  278..279: Control(','),
-  279..280: NewLine,
-  284..288: Ident("subs"),
-  289..290: Control('='),
-  291..296: Ident("title"),
-  297..298: Control('|'),
-  299..303: Ident("text"),
-  303..304: Control('.'),
-  304..311: Ident("extract"),
-  312..313: Literal(Integer(2)),
-  314..315: Literal(Integer(5)),
-  315..316: Control(','),
-  316..317: NewLine,
-  321..328: Ident("replace"),
-  329..330: Control('='),
-  331..336: Ident("title"),
-  337..338: Control('|'),
-  339..343: Ident("text"),
-  343..344: Control('.'),
-  344..351: Ident("replace"),
-  352..356: Literal(String("al")),
-  357..363: Literal(String("PIKA")),
-  363..364: Control(','),
-  364..365: NewLine,
-  365..366: Control('}'),
-  366..367: NewLine,
-  367..371: Ident("sort"),
-  372..373: Control('{'),
-  373..378: Ident("title"),
-  378..379: Control('}'),
-  379..380: NewLine,
-  380..386: Ident("filter"),
-  387..388: Control('('),
-  388..393: Ident("title"),
-  394..395: Control('|'),
-  396..400: Ident("text"),
-  400..401: Control('.'),
-  401..412: Ident("starts_with"),
-  413..420: Literal(String("Black")),
-  420..421: Control(')'),
-  422..424: Or,
-  425..426: Control('('),
-  426..431: Ident("title"),
-  432..433: Control('|'),
-  434..438: Ident("text"),
-  438..439: Control('.'),
-  439..447: Ident("contains"),
-  448..457: Literal(String("Sabbath")),
-  457..458: Control(')'),
-  459..461: Or,
-  462..463: Control('('),
-  463..468: Ident("title"),
-  469..470: Control('|'),
-  471..475: Ident("text"),
-  475..476: Control('.'),
-  476..485: Ident("ends_with"),
-  486..490: Literal(String("os")),
-  490..491: Control(')'),
-  491..492: NewLine,
+  105..108: Ident("std"),
+  108..109: Control('.'),
+  109..113: Ident("text"),
+  113..114: Control('.'),
+  114..119: Ident("lower"),
+  119..120: Control(','),
+  120..121: NewLine,
+  125..127: Ident("up"),
+  128..129: Control('='),
+  130..135: Ident("title"),
+  136..137: Control('|'),
+  138..141: Ident("std"),
+  141..142: Control('.'),
+  142..146: Ident("text"),
+  146..147: Control('.'),
+  147..152: Ident("upper"),
+  152..153: Control(','),
+  153..154: NewLine,
+  158..166: Ident("ltrimmed"),
+  167..168: Control('='),
+  169..174: Ident("title"),
+  175..176: Control('|'),
+  177..180: Ident("std"),
+  180..181: Control('.'),
+  181..185: Ident("text"),
+  185..186: Control('.'),
+  186..191: Ident("ltrim"),
+  191..192: Control(','),
+  192..193: NewLine,
+  197..205: Ident("rtrimmed"),
+  206..207: Control('='),
+  208..213: Ident("title"),
+  214..215: Control('|'),
+  216..219: Ident("std"),
+  219..220: Control('.'),
+  220..224: Ident("text"),
+  224..225: Control('.'),
+  225..230: Ident("rtrim"),
+  230..231: Control(','),
+  231..232: NewLine,
+  236..243: Ident("trimmed"),
+  244..245: Control('='),
+  246..251: Ident("title"),
+  252..253: Control('|'),
+  254..257: Ident("std"),
+  257..258: Control('.'),
+  258..262: Ident("text"),
+  262..263: Control('.'),
+  263..267: Ident("trim"),
+  267..268: Control(','),
+  268..269: NewLine,
+  273..276: Ident("len"),
+  277..278: Control('='),
+  279..284: Ident("title"),
+  285..286: Control('|'),
+  287..290: Ident("std"),
+  290..291: Control('.'),
+  291..295: Ident("text"),
+  295..296: Control('.'),
+  296..302: Ident("length"),
+  302..303: Control(','),
+  303..304: NewLine,
+  308..312: Ident("subs"),
+  313..314: Control('='),
+  315..320: Ident("title"),
+  321..322: Control('|'),
+  323..326: Ident("std"),
+  326..327: Control('.'),
+  327..331: Ident("text"),
+  331..332: Control('.'),
+  332..339: Ident("extract"),
+  340..341: Literal(Integer(2)),
+  342..343: Literal(Integer(5)),
+  343..344: Control(','),
+  344..345: NewLine,
+  349..356: Ident("replace"),
+  357..358: Control('='),
+  359..364: Ident("title"),
+  365..366: Control('|'),
+  367..370: Ident("std"),
+  370..371: Control('.'),
+  371..375: Ident("text"),
+  375..376: Control('.'),
+  376..383: Ident("replace"),
+  384..388: Literal(String("al")),
+  389..395: Literal(String("PIKA")),
+  395..396: Control(','),
+  396..397: NewLine,
+  397..398: Control('}'),
+  398..399: NewLine,
+  399..403: Ident("sort"),
+  404..405: Control('{'),
+  405..410: Ident("title"),
+  410..411: Control('}'),
+  411..412: NewLine,
+  412..418: Ident("filter"),
+  419..420: Control('('),
+  420..425: Ident("title"),
+  426..427: Control('|'),
+  428..431: Ident("std"),
+  431..432: Control('.'),
+  432..436: Ident("text"),
+  436..437: Control('.'),
+  437..448: Ident("starts_with"),
+  449..456: Literal(String("Black")),
+  456..457: Control(')'),
+  458..460: Or,
+  461..462: Control('('),
+  462..467: Ident("title"),
+  468..469: Control('|'),
+  470..473: Ident("std"),
+  473..474: Control('.'),
+  474..478: Ident("text"),
+  478..479: Control('.'),
+  479..487: Ident("contains"),
+  488..497: Literal(String("Sabbath")),
+  497..498: Control(')'),
+  499..501: Or,
+  502..503: Control('('),
+  503..508: Ident("title"),
+  509..510: Control('|'),
+  511..514: Ident("std"),
+  514..515: Control('.'),
+  515..519: Ident("text"),
+  519..520: Control('.'),
+  520..529: Ident("ends_with"),
+  530..534: Literal(String("os")),
+  534..535: Control(')'),
+  535..536: NewLine,
 )
diff --git a/prqlc/prqlc/tests/integration/sql.rs b/prqlc/prqlc/tests/integration/sql.rs
index 7ace6378d184..d8d177f535bb 100644
--- a/prqlc/prqlc/tests/integration/sql.rs
+++ b/prqlc/prqlc/tests/integration/sql.rs
@@ -41,7 +41,7 @@ fn test_stdlib() {
     assert_snapshot!(compile(r###"
     from db.employees
     aggregate (
-        {salary_usd = (math.round 2 salary)}
+        {salary_usd = (std.math.round 2 salary)}
     )
     "###).unwrap(),
         @r###"
@@ -58,24 +58,24 @@ fn test_stdlib_math_module() {
     assert_snapshot!(compile(r#"
     from db.employees
     select {
-      salary_abs = math.abs salary,
-      salary_floor = math.floor salary,
-      salary_ceil = math.ceil salary,
-      salary_pi = math.pi,
-      salary_exp = math.exp salary,
-      salary_ln = math.ln salary,
-      salary_log10 = math.log10 salary,
-      salary_log = math.log 2 salary,
-      salary_sqrt = math.sqrt salary,
-      salary_degrees = math.degrees salary,
-      salary_radians = math.radians salary,
-      salary_cos = math.cos salary,
-      salary_acos = math.acos salary,
-      salary_sin = math.sin salary,
-      salary_asin = math.asin salary,
-      salary_tan = math.tan salary,
-      salary_atan = math.atan salary,
-      salary_pow = salary | math.pow 2,
+      salary_abs = std.math.abs salary,
+      salary_floor = std.math.floor salary,
+      salary_ceil = std.math.ceil salary,
+      salary_pi = std.math.pi,
+      salary_exp = std.math.exp salary,
+      salary_ln = std.math.ln salary,
+      salary_log10 = std.math.log10 salary,
+      salary_log = std.math.log 2 salary,
+      salary_sqrt = std.math.sqrt salary,
+      salary_degrees = std.math.degrees salary,
+      salary_radians = std.math.radians salary,
+      salary_cos = std.math.cos salary,
+      salary_acos = std.math.acos salary,
+      salary_sin = std.math.sin salary,
+      salary_asin = std.math.asin salary,
+      salary_tan = std.math.tan salary,
+      salary_atan = std.math.atan salary,
+      salary_pow = salary | std.math.pow 2,
     }
     "#).unwrap(), @r#"
     SELECT
@@ -110,24 +110,24 @@ fn test_stdlib_math_module_mssql() {
 
   from db.employees
   select {
-    salary_abs = math.abs salary,
-    salary_floor = math.floor salary,
-    salary_ceil = math.ceil salary,
-    salary_pi = math.pi,
-    salary_exp = math.exp salary,
-    salary_ln = math.ln salary,
-    salary_log10 = math.log10 salary,
-    salary_log = math.log 2 salary,
-    salary_sqrt = math.sqrt salary,
-    salary_degrees = math.degrees salary,
-    salary_radians = math.radians salary,
-    salary_cos = math.cos salary,
-    salary_acos = math.acos salary,
-    salary_sin = math.sin salary,
-    salary_asin = math.asin salary,
-    salary_tan = math.tan salary,
-    salary_atan = math.atan salary,
-    salary_pow = salary | math.pow 2,
+    salary_abs = std.math.abs salary,
+    salary_floor = std.math.floor salary,
+    salary_ceil = std.math.ceil salary,
+    salary_pi = std.math.pi,
+    salary_exp = std.math.exp salary,
+    salary_ln = std.math.ln salary,
+    salary_log10 = std.math.log10 salary,
+    salary_log = std.math.log 2 salary,
+    salary_sqrt = std.math.sqrt salary,
+    salary_degrees = std.math.degrees salary,
+    salary_radians = std.math.radians salary,
+    salary_cos = std.math.cos salary,
+    salary_acos = std.math.acos salary,
+    salary_sin = std.math.sin salary,
+    salary_asin = std.math.asin salary,
+    salary_tan = std.math.tan salary,
+    salary_atan = std.math.atan salary,
+    salary_pow = salary | std.math.pow 2,
   }
   "#).unwrap(), @r#"
   SELECT
@@ -160,17 +160,17 @@ fn test_stdlib_text_module() {
     assert_snapshot!(compile(r#"
     from db.employees
     select {
-      name_lower = name | text.lower,
-      name_upper = name | text.upper,
-      name_ltrim = name | text.ltrim,
-      name_rtrim = name | text.rtrim,
-      name_trim = name | text.trim,
-      name_length = name | text.length,
-      name_extract = name | text.extract 3 5,
-      name_replace = name | text.replace "pika" "chu",
-      name_starts_with = name | text.starts_with "pika",
-      name_contains = name | text.contains "pika",
-      name_ends_with = name | text.ends_with "pika",
+      name_lower = name | std.text.lower,
+      name_upper = name | std.text.upper,
+      name_ltrim = name | std.text.ltrim,
+      name_rtrim = name | std.text.rtrim,
+      name_trim = name | std.text.trim,
+      name_length = name | std.text.length,
+      name_extract = name | std.text.extract 3 5,
+      name_replace = name | std.text.replace "pika" "chu",
+      name_starts_with = name | std.text.starts_with "pika",
+      name_contains = name | std.text.contains "pika",
+      name_ends_with = name | std.text.ends_with "pika",
     }
     "#).unwrap(), @r###"
     SELECT
@@ -198,7 +198,7 @@ fn like_concat(#[case] dialect: sql::Dialect, #[case] expected_like: &'static st
     let query = r#"
   from db.employees
   select {
-    name_ends_with = name | text.contains "pika",
+    name_ends_with = name | std.text.contains "pika",
   }
   "#;
     let expected = format!(
@@ -231,7 +231,7 @@ fn date_to_text_operator(
     let query = r#"
     from db.invoices
     select {
-      invoice_date = invoice_date | date.to_text "%d/%m/%Y"
+      invoice_date = invoice_date | std.date.to_text "%d/%m/%Y"
     }"#;
     let expected = format!(
         r#"
@@ -329,7 +329,7 @@ fn test_precedence_03() {
     from db.numbers
     derive {
       sum_1 = a + b,
-      sum_2 = add a b,
+      sum_2 = std.add a b,
       g = -a
     }
     select {
@@ -491,10 +491,10 @@ fn test_append() {
 
     assert_snapshot!(compile(r###"
     let distinct = rel -> (_param.rel | group this (take 1))
-    let union = func bottom top -> (top | append bottom | distinct)
+    let union = func bottom top -> (top | append bottom | module.distinct)
 
     from db.employees
-    union db.managers
+    module.union db.managers
     "###).unwrap(), @r###"
     SELECT
       *
@@ -510,11 +510,11 @@ fn test_append() {
 
     assert_snapshot!(compile(r###"
     let distinct = rel -> (_param.rel | group this (take 1))
-    let union = func bottom top -> (top | append bottom | distinct)
+    let union = func bottom top -> (top | append bottom | module.distinct)
 
     from db.employees
     append db.managers
-    union db.all_employees_of_some_other_company
+    module.union db.all_employees_of_some_other_company
     "###).unwrap(), @r###"
     SELECT
       *
@@ -635,11 +635,11 @@ fn test_remove_05() {
     prql target:sql.sqlite
 
     let distinct = rel -> (_param.rel | group this (take 1))
-    let except = func bottom top -> (top | distinct | remove bottom)
+    let except = func bottom top -> (top | module.distinct | remove bottom)
 
     from db.album
     select {artist_id, title}
-    except (from db.artist | select {artist_id, name})
+    module.except (from db.artist | select {artist_id, name})
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -669,10 +669,10 @@ fn test_remove_06() {
     prql target:sql.sqlite
 
     let distinct = rel -> (_param.rel | group this (take 1))
-    let except = func bottom top -> (top | distinct | remove bottom)
+    let except = func bottom top -> (top | module.distinct | remove bottom)
 
     from db.album
-    except db.artist
+    module.except db.artist
     "#).unwrap(),
         @r###"
     SELECT
@@ -746,11 +746,11 @@ fn test_intersect_03() {
 
     from db.album
     select artist_id
-    distinct
+    module.distinct
     intersect (
         from db.artist | select artist_id
     )
-    distinct
+    module.distinct
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -789,7 +789,7 @@ fn test_intersect_04() {
     intersect (
         from db.artist | select artist_id
     )
-    distinct
+    module.distinct
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -825,7 +825,7 @@ fn test_intersect_05() {
 
     from db.album
     select artist_id
-    distinct
+    module.distinct
     intersect (
         from db.artist | select artist_id
     )
@@ -928,7 +928,7 @@ fn test_quoting() {
     let UPPER = (
         from db.lower
     )
-    UPPER
+    module.UPPER
     join db.`some_schema.tablename` (==id)
     derive `from` = 5
     "###).unwrap()), @r###"
@@ -1046,7 +1046,7 @@ fn test_sorts_02() {
       sort index
       select {fieldA}
     )
-    x
+    module.x
     "###
     ).unwrap()), @r###"
     WITH table_0 AS (
@@ -2508,7 +2508,7 @@ fn test_bare_s_string() {
           GROUPING SETS
           ((b, c, d), (d), (b, d))
       """
-    grouping
+    module.grouping
     "#;
 
     let sql = compile(query).unwrap();
@@ -2532,7 +2532,7 @@ fn test_bare_s_string() {
     // Test that case insensitive SELECT is accepted. We allow it as it is valid SQL.
     let query = r#"
     let a = s"select insensitive from rude"
-    a
+    module.a
     "#;
 
     let sql = compile(query).unwrap();
@@ -2554,7 +2554,7 @@ fn test_bare_s_string() {
     // Check a mixture of cases for good measure.
     let query = r#"
     let a = s"sElEcT insensitive from rude"
-    a
+    module.a
     "#;
 
     let sql = compile(query).unwrap();
@@ -2581,7 +2581,7 @@ fn test_bare_s_string() {
     FROM
       bar"
 
-    a
+    module.a
     "#;
 
     let sql = compile(query).unwrap();
@@ -2613,7 +2613,7 @@ fn test_table_definition_with_expr_call() {
     let query = r###"
     let e = take 4 (from db.employees)
 
-    e
+    module.e
     "###;
 
     let sql = compile(query).unwrap();
@@ -2775,8 +2775,8 @@ fn test_prql_to_sql_table() {
             }
         )
     )
-    newest_employees
-    join average_salaries (==country)
+    module.newest_employees
+    join module.average_salaries (==country)
     select {name, salary, average_country_salary}
     "#;
     let sql = compile(query).unwrap();
@@ -2908,7 +2908,7 @@ fn test_nonatomic_table() {
         take 50
         group country (aggregate {s"count(*)"})
     )
-    a
+    module.a
     join db.b (==country)
     select {name, salary, average_country_salary}
 "#;
@@ -3197,8 +3197,8 @@ from db.y_table
 select foo
 )
 
-x
-join y (foo == only_in_x)
+module.x
+join module.y (foo == only_in_x)
 "###;
 
     assert_snapshot!(compile(query).unwrap(),
@@ -3323,10 +3323,10 @@ fn test_toposort() {
     )
 
     let a = (
-        b
+        project.b
     )
 
-    b
+    project.b
     "###).unwrap(),
         @r###"
     WITH b AS (
@@ -3556,7 +3556,7 @@ fn test_table_s_string_05() {
     let weeks_between = start end -> s"SELECT generate_series({start}, {end}, '1 week') as date"
     let current_week = -> s"date(date_trunc('week', current_date))"
 
-    weeks_between @2022-06-03 (current_week + 4)
+    module.weeks_between @2022-06-03 (module.current_week + 4)
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -3848,17 +3848,17 @@ fn test_static_analysis() {
 #[test]
 fn test_closures_and_pipelines() {
     assert_snapshot!(compile(
-        r#"
+    r#"
     let addthree = a b c -> s"{a} || {b} || {c}"
     let arg = myarg myfunc <func> -> ( myfunc myarg )
 
     from db.y
     select x = (
-        addthree "apples"
-        arg "bananas"
-        arg "citrus"
+        module.addthree "apples"
+        module.arg "bananas"
+        module.arg "citrus"
     )
-        "#).unwrap(),
+    "#).unwrap(),
         @r###"
     SELECT
       'apples' || 'bananas' || 'citrus' AS x
@@ -4022,7 +4022,7 @@ fn test_custom_transforms() {
     )
 
     from db.tab
-    my_transform
+    module.my_transform
     take 3
     "#).unwrap(),
         @r###"
@@ -4088,7 +4088,7 @@ fn test_name_inference() {
 #[test]
 fn test_from_text() {
     assert_snapshot!(compile(r#"
-    from_text format:csv """
+    std.from_text format:csv """
 a,b,c
 1,2,3
 4,5,6
@@ -4117,7 +4117,7 @@ a,b,c
     );
 
     assert_snapshot!(compile(r#"
-    from_text format:json '''
+    std.from_text format:json '''
       [{"a": 1, "b": "x", "c": false }, {"a": 4, "b": "y", "c": null }]
     '''
     select {b, c}
@@ -4144,7 +4144,7 @@ a,b,c
     );
 
     assert_snapshot!(compile(r#"
-    from_text format:json '''{
+    std.from_text format:json '''{
         "columns": ["a", "b", "c"],
         "data": [
             [1, "x", false],
@@ -4323,7 +4323,7 @@ fn test_loop() {
 #[test]
 fn test_loop_2() {
     assert_snapshot!(compile(r#"
-    read_csv 'employees.csv'
+    std.read_csv 'employees.csv'
     filter last_name=="Mitchell"
     loop (
       join (db.employees | select {manager = this}) (manager.employee_id==this.reports_to)
@@ -4467,7 +4467,7 @@ fn test_datetime_parsing() {
 fn test_lower() {
     assert_snapshot!(compile(r#"
     from db.test_tables
-    derive {lower_name = (name | text.lower)}
+    derive {lower_name = (name | std.text.lower)}
     "#).unwrap(),
         @r###"
     SELECT
@@ -4483,7 +4483,7 @@ fn test_lower() {
 fn test_upper() {
     assert_snapshot!(compile(r#"
     from db.test_tables
-    derive {upper_name = text.upper name}
+    derive {upper_name = std.text.upper name}
     select {upper_name}
     "#).unwrap(),
         @r###"
@@ -4512,8 +4512,8 @@ fn test_1535() {
 #[test]
 fn test_read_parquet_duckdb() {
     assert_snapshot!(compile(r#"
-    read_parquet 'x.parquet'
-    join (read_parquet "y.parquet") (==foo)
+    std.read_parquet 'x.parquet'
+    join (std.read_parquet "y.parquet") (==foo)
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -4604,7 +4604,7 @@ fn test_into() {
     from db.data
     into table_a
 
-    table_a
+    module.table_a
     select {x, y}
     "#).unwrap(),
         @r###"
@@ -4640,7 +4640,7 @@ fn test_array_01() {
         {a = 4, b = true},
     ]
 
-    let main = (my_relation | filter b)
+    let main = (module.my_relation | filter b)
     "#).unwrap(),
         @r###"
     WITH table_0 AS (
@@ -4756,7 +4756,7 @@ fn test_double_stars() {
 fn test_lineage() {
     // #2627
     assert_snapshot!(compile(r#"
-    from_text """
+    std.from_text """
     a
     1
     2
@@ -4787,7 +4787,7 @@ fn test_lineage() {
 
     // #2392
     assert_snapshot!(compile(r#"
-    from_text format:json """{
+    std.from_text format:json """{
         "columns": ["a"],
         "data": [[1]]
     }"""
@@ -4817,7 +4817,8 @@ fn test_type_as_column_name() {
     )
 
     from db.foo
-    f"#)
+    module.f
+    "#)
     .unwrap(), @r###"
     SELECT
       date
@@ -5008,7 +5009,7 @@ fn test_relation_var_name_clashes_01() {
         r###"
     let table_0 = (from db.a)
 
-    table_0
+    project.table_0
     take 10
     filter x > 0
         "###,
@@ -5127,7 +5128,7 @@ fn test_table_declarations() {
       let another_table <[{ id = int, b = text }]>
     }
 
-    from db.my_schema.my_table | join db.another_table (==id) | take 10
+    from module.db.my_schema.my_table | join module.db.another_table (==id) | take 10
         "###,
     )
     .unwrap(), @r###"
@@ -5150,7 +5151,7 @@ fn test_param_declarations() {
         r###"
     let a <int>
 
-    from db.x | filter b == a
+    from db.x | filter b == module.a
         "###,
     )
     .unwrap(), @r###"
@@ -5186,9 +5187,9 @@ fn test_import() {
         let world = 1
     }
 
-    import a = hello.world
+    import a = module.hello.world
 
-    from db.x | select a
+    from db.x | select module.a
         "###,
     )
     .unwrap(), @r###"
@@ -5198,3 +5199,55 @@ fn test_import() {
       x
     "###);
 }
+
+#[test]
+fn test_ordering_declarations() {
+    // declarations must be resolved in the correct order:
+    // - hello.world
+    // - foo.bar.baz
+    // - main
+
+    assert_snapshot!(compile(
+    r###"
+    let main = (from db.h | filter j == (module.foo.bar.baz + 1))
+
+    module foo {
+      module bar {
+        let baz = project.hello.world
+      }
+    }
+
+    module hello {
+      let world = 1
+    }
+    "###).unwrap(), @r###"
+    SELECT
+      *
+    FROM
+      h
+    WHERE
+      j = 1 + 1
+    "###);
+}
+
+#[test]
+#[ignore]
+fn test_local_ref() {
+    assert_snapshot!(compile(
+        r###"
+    let hello = 10
+
+    from db.x
+    select {this.hello}
+    select {hello}
+        "###,
+    )
+    .unwrap(), @r###"
+    SELECT
+      *
+    FROM
+      h
+    WHERE
+      j = 1 + 1
+    "###);
+}
