chore: bump version to 0.1.6

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -770,7 +770,7 @@ dependencies = [
 
 [[package]]
 name = "lux"
-version = "0.1.2"
+version = "0.1.5"
 dependencies = [
  "lsp-server",
  "lsp-types",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lux"
-version = "0.1.3"
+version = "0.1.6"
 edition = "2021"
 description = "A functional programming language with first-class effects, schema evolution, and behavioral types"
 license = "MIT"

flake.nix

@@ -44,7 +44,7 @@
             printf "\n"
             printf "  \033[1;35m╦  ╦ ╦╦ ╦\033[0m\n"
             printf "  \033[1;35m║  ║ ║╔╣\033[0m\n"
-            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.3\n"
+            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.6\n"
             printf "\n"
             printf "  Functional language with first-class effects\n"
             printf "\n"
@@ -62,7 +62,7 @@
 
         packages.default = pkgs.rustPlatform.buildRustPackage {
           pname = "lux";
-          version = "0.1.3";
+          version = "0.1.6";
           src = ./.;
           cargoLock.lockFile = ./Cargo.lock;
 
@@ -79,7 +79,7 @@
           };
         in muslPkgs.rustPlatform.buildRustPackage {
           pname = "lux";
-          version = "0.1.3";
+          version = "0.1.6";
           src = ./.;
           cargoLock.lockFile = ./Cargo.lock;
 

projects/lux-compiler/ast.lux

@@ -0,0 +1,225 @@
+// Lux AST — Self-hosted Abstract Syntax Tree definitions
+//
+// Direct translation of src/ast.rs into Lux ADTs.
+// These types represent the parsed structure of a Lux program.
+//
+// Naming conventions to avoid collisions:
+//   Ex = Expr variant, Pat = Pattern, Te = TypeExpr
+//   Td = TypeDef, Vf = VariantFields, Op = Operator
+//   Decl = Declaration, St = Statement
+
+// === Source Location ===
+
+type Span = | Span(Int, Int)
+
+// === Identifiers ===
+
+type Ident = | Ident(String, Span)
+
+// === Visibility ===
+
+type Visibility = | Public | Private
+
+// === Schema Evolution ===
+
+type Version = | Version(Int, Span)
+
+type VersionConstraint =
+    | VcExact(Version)
+    | VcAtLeast(Version)
+    | VcLatest(Span)
+
+// === Behavioral Types ===
+
+type BehavioralProperty =
+    | BpPure
+    | BpTotal
+    | BpIdempotent
+    | BpDeterministic
+    | BpCommutative
+
+// === Trait Bound (needed before WhereClause) ===
+
+type TraitBound = | TraitBound(Ident, List<TypeExpr>, Span)
+
+// === Trait Constraint (needed before WhereClause) ===
+
+type TraitConstraint = | TraitConstraint(Ident, List<TraitBound>, Span)
+
+// === Where Clauses ===
+
+type WhereClause =
+    | WcProperty(Ident, BehavioralProperty, Span)
+    | WcResult(Expr, Span)
+    | WcTrait(TraitConstraint)
+
+// === Module Path ===
+
+type ModulePath = | ModulePath(List<Ident>, Span)
+
+// === Import ===
+
+// path, alias, items, wildcard, span
+type ImportDecl = | ImportDecl(ModulePath, Option<Ident>, Option<List<Ident>>, Bool, Span)
+
+// === Program ===
+
+type Program = | Program(List<ImportDecl>, List<Declaration>)
+
+// === Declarations ===
+
+type Declaration =
+    | DeclFunction(FunctionDecl)
+    | DeclEffect(EffectDecl)
+    | DeclType(TypeDecl)
+    | DeclHandler(HandlerDecl)
+    | DeclLet(LetDecl)
+    | DeclTrait(TraitDecl)
+    | DeclImpl(ImplDecl)
+
+// === Parameter ===
+
+type Parameter = | Parameter(Ident, TypeExpr, Span)
+
+// === Effect Operation ===
+
+type EffectOp = | EffectOp(Ident, List<Parameter>, TypeExpr, Span)
+
+// === Record Field ===
+
+type RecordField = | RecordField(Ident, TypeExpr, Span)
+
+// === Variant Fields ===
+
+type VariantFields =
+    | VfUnit
+    | VfTuple(List<TypeExpr>)
+    | VfRecord(List<RecordField>)
+
+// === Variant ===
+
+type Variant = | Variant(Ident, VariantFields, Span)
+
+// === Migration ===
+
+type Migration = | Migration(Version, Expr, Span)
+
+// === Handler Impl ===
+
+// op_name, params, resume, body, span
+type HandlerImpl = | HandlerImpl(Ident, List<Ident>, Option<Ident>, Expr, Span)
+
+// === Impl Method ===
+
+// name, params, return_type, body, span
+type ImplMethod = | ImplMethod(Ident, List<Parameter>, Option<TypeExpr>, Expr, Span)
+
+// === Trait Method ===
+
+// name, type_params, params, return_type, default_impl, span
+type TraitMethod = | TraitMethod(Ident, List<Ident>, List<Parameter>, TypeExpr, Option<Expr>, Span)
+
+// === Type Expressions ===
+
+type TypeExpr =
+    | TeNamed(Ident)
+    | TeApp(TypeExpr, List<TypeExpr>)
+    | TeFunction(List<TypeExpr>, TypeExpr, List<Ident>)
+    | TeTuple(List<TypeExpr>)
+    | TeRecord(List<RecordField>)
+    | TeUnit
+    | TeVersioned(TypeExpr, VersionConstraint)
+
+// === Literal ===
+
+type LiteralKind =
+    | LitInt(Int)
+    | LitFloat(String)
+    | LitString(String)
+    | LitChar(Char)
+    | LitBool(Bool)
+    | LitUnit
+
+type Literal = | Literal(LiteralKind, Span)
+
+// === Binary Operators ===
+
+type BinaryOp =
+    | OpAdd | OpSub | OpMul | OpDiv | OpMod
+    | OpEq | OpNe | OpLt | OpLe | OpGt | OpGe
+    | OpAnd | OpOr
+    | OpPipe | OpConcat
+
+// === Unary Operators ===
+
+type UnaryOp = | OpNeg | OpNot
+
+// === Statements ===
+
+type Statement =
+    | StExpr(Expr)
+    | StLet(Ident, Option<TypeExpr>, Expr, Span)
+
+// === Match Arms ===
+
+type MatchArm = | MatchArm(Pattern, Option<Expr>, Expr, Span)
+
+// === Patterns ===
+
+type Pattern =
+    | PatWildcard(Span)
+    | PatVar(Ident)
+    | PatLiteral(Literal)
+    | PatConstructor(Ident, List<Pattern>, Span)
+    | PatRecord(List<(Ident, Pattern)>, Span)
+    | PatTuple(List<Pattern>, Span)
+
+// === Function Declaration ===
+// visibility, doc, name, type_params, params, return_type, effects, properties, where_clauses, body, span
+type FunctionDecl = | FunctionDecl(Visibility, Option<String>, Ident, List<Ident>, List<Parameter>, TypeExpr, List<Ident>, List<BehavioralProperty>, List<WhereClause>, Expr, Span)
+
+// === Effect Declaration ===
+// doc, name, type_params, operations, span
+type EffectDecl = | EffectDecl(Option<String>, Ident, List<Ident>, List<EffectOp>, Span)
+
+// === Type Declaration ===
+// visibility, doc, name, type_params, version, definition, migrations, span
+type TypeDecl = | TypeDecl(Visibility, Option<String>, Ident, List<Ident>, Option<Version>, TypeDef, List<Migration>, Span)
+
+// === Handler Declaration ===
+// name, params, effect, implementations, span
+type HandlerDecl = | HandlerDecl(Ident, List<Parameter>, Ident, List<HandlerImpl>, Span)
+
+// === Let Declaration ===
+// visibility, doc, name, typ, value, span
+type LetDecl = | LetDecl(Visibility, Option<String>, Ident, Option<TypeExpr>, Expr, Span)
+
+// === Trait Declaration ===
+// visibility, doc, name, type_params, super_traits, methods, span
+type TraitDecl = | TraitDecl(Visibility, Option<String>, Ident, List<Ident>, List<TraitBound>, List<TraitMethod>, Span)
+
+// === Impl Declaration ===
+// type_params, constraints, trait_name, trait_args, target_type, methods, span
+type ImplDecl = | ImplDecl(List<Ident>, List<TraitConstraint>, Ident, List<TypeExpr>, TypeExpr, List<ImplMethod>, Span)
+
+// === Expressions ===
+
+type Expr =
+    | ExLiteral(Literal)
+    | ExVar(Ident)
+    | ExBinaryOp(BinaryOp, Expr, Expr, Span)
+    | ExUnaryOp(UnaryOp, Expr, Span)
+    | ExCall(Expr, List<Expr>, Span)
+    | ExEffectOp(Ident, Ident, List<Expr>, Span)
+    | ExField(Expr, Ident, Span)
+    | ExTupleIndex(Expr, Int, Span)
+    | ExLambda(List<Parameter>, Option<TypeExpr>, List<Ident>, Expr, Span)
+    | ExLet(Ident, Option<TypeExpr>, Expr, Expr, Span)
+    | ExIf(Expr, Expr, Expr, Span)
+    | ExMatch(Expr, List<MatchArm>, Span)
+    | ExBlock(List<Statement>, Expr, Span)
+    | ExRecord(Option<Expr>, List<(Ident, Expr)>, Span)
+    | ExTuple(List<Expr>, Span)
+    | ExList(List<Expr>, Span)
+    | ExRun(Expr, List<(Ident, Expr)>, Span)
+    | ExResume(Expr, Span)

scripts/validate.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Lux Full Validation Script
-# Runs all checks: Rust tests, package tests, type checking, formatting, linting.
+# Runs all checks: Rust tests, package tests, type checking, example compilation.
 # Run after every committable change to ensure no regressions.
 
 # cd to repo root (directory containing this script's parent)
@@ -11,6 +11,8 @@ cd "$SCRIPT_DIR/.."
 
 LUX="$(pwd)/target/release/lux"
 PACKAGES_DIR="$(pwd)/../packages"
+PROJECTS_DIR="$(pwd)/projects"
+EXAMPLES_DIR="$(pwd)/examples"
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 CYAN='\033[0;36m'
@@ -30,7 +32,7 @@ fail() { printf "${RED}FAIL${NC} %s\n" "${1:-}"; FAILED=$((FAILED + 1)); }
 
 # --- Rust checks ---
 step "cargo check"
-if nix develop --command cargo check 2>&1 | grep -q "Finished"; then ok; else fail; fi
+if nix develop --command cargo check 2>/dev/null; then ok; else fail; fi
 
 step "cargo test"
 OUTPUT=$(nix develop --command cargo test 2>&1 || true)
@@ -39,7 +41,7 @@ if echo "$RESULT" | grep -q "0 failed"; then ok "$RESULT"; else fail "$RESULT";
 
 # --- Build release binary ---
 step "cargo build --release"
-if nix develop --command cargo build --release 2>&1 | grep -q "Finished"; then ok; else fail; fi
+if nix develop --command cargo build --release 2>/dev/null; then ok; else fail; fi
 
 # --- Package tests ---
 for pkg in path frontmatter xml rss markdown; do
@@ -63,6 +65,142 @@ for pkg in path frontmatter xml rss markdown; do
     fi
 done
 
+# --- Project checks ---
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    if [ -f "$proj_dir/main.lux" ]; then
+        step "lux check (project: $proj)"
+        OUTPUT=$("$LUX" check "$proj_dir/main.lux" 2>&1 || true)
+        if echo "$OUTPUT" | grep -qi "error"; then fail; else ok; fi
+    fi
+    # Check any standalone .lux files in the project
+    for lux_file in "$proj_dir"/*.lux; do
+        [ -f "$lux_file" ] || continue
+        fname=$(basename "$lux_file")
+        [ "$fname" = "main.lux" ] && continue
+        step "lux check (project: $proj/$fname)"
+        OUTPUT=$("$LUX" check "$lux_file" 2>&1 || true)
+        if echo "$OUTPUT" | grep -qi "error"; then fail; else ok; fi
+    done
+done
+
+# === Compilation & Interpreter Checks ===
+
+# --- Interpreter: examples ---
+# Skip: http_api, http, http_router, http_server (network), postgres_demo (db),
+#        random, property_testing (Random effect), shell (Process), json (File I/O),
+#        file_io (File I/O), test_math, test_lists (Test effect), stress_shared_rc,
+#        test_rc_comparison (internal tests), modules/* (need cwd)
+INTERP_SKIP="http_api http http_router http_server postgres_demo random property_testing shell json file_io test_math test_lists stress_shared_rc test_rc_comparison"
+for f in "$EXAMPLES_DIR"/*.lux; do
+    name=$(basename "$f" .lux)
+    skip=false
+    for s in $INTERP_SKIP; do [ "$name" = "$s" ] && skip=true; done
+    $skip && continue
+    step "interpreter (examples/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: examples/standard ---
+# Skip: guessing_game (reads stdin)
+for f in "$EXAMPLES_DIR"/standard/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "guessing_game" ] && continue
+    step "interpreter (standard/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: examples/showcase ---
+# Skip: task_manager (parse error in current version)
+for f in "$EXAMPLES_DIR"/showcase/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "task_manager" ] && continue
+    step "interpreter (showcase/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: projects ---
+# Skip: guessing-game (Random), rest-api (HttpServer)
+PROJ_INTERP_SKIP="guessing-game rest-api"
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    [ -f "$proj_dir/main.lux" ] || continue
+    skip=false
+    for s in $PROJ_INTERP_SKIP; do [ "$proj" = "$s" ] && skip=true; done
+    $skip && continue
+    step "interpreter (project: $proj)"
+    if timeout 10 "$LUX" "$proj_dir/main.lux" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples ---
+# Skip files that fail JS compilation (unsupported features)
+JS_SKIP="http_api http http_router postgres_demo property_testing json test_lists test_rc_comparison"
+for f in "$EXAMPLES_DIR"/*.lux; do
+    name=$(basename "$f" .lux)
+    skip=false
+    for s in $JS_SKIP; do [ "$name" = "$s" ] && skip=true; done
+    $skip && continue
+    step "compile JS (examples/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples/standard ---
+# Skip: stdlib_demo (uses String.toUpper not in JS backend)
+for f in "$EXAMPLES_DIR"/standard/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "stdlib_demo" ] && continue
+    step "compile JS (standard/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples/showcase ---
+# Skip: task_manager (unsupported features)
+for f in "$EXAMPLES_DIR"/showcase/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "task_manager" ] && continue
+    step "compile JS (showcase/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: projects ---
+# Skip: json-parser, rest-api (unsupported features)
+JS_PROJ_SKIP="json-parser rest-api"
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    [ -f "$proj_dir/main.lux" ] || continue
+    skip=false
+    for s in $JS_PROJ_SKIP; do [ "$proj" = "$s" ] && skip=true; done
+    $skip && continue
+    step "compile JS (project: $proj)"
+    if "$LUX" compile "$proj_dir/main.lux" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- C compilation: examples ---
+# Only compile examples known to work with C backend
+C_EXAMPLES="hello factorial pipelines tailcall jit_test"
+for name in $C_EXAMPLES; do
+    f="$EXAMPLES_DIR/$name.lux"
+    [ -f "$f" ] || continue
+    step "compile C (examples/$name)"
+    if "$LUX" compile "$f" -o /tmp/lux_validate_bin >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- C compilation: examples/standard ---
+C_STD_EXAMPLES="hello_world factorial fizzbuzz primes guessing_game"
+for name in $C_STD_EXAMPLES; do
+    f="$EXAMPLES_DIR/standard/$name.lux"
+    [ -f "$f" ] || continue
+    step "compile C (standard/$name)"
+    if "$LUX" compile "$f" -o /tmp/lux_validate_bin >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Cleanup ---
+rm -f /tmp/lux_validate.js /tmp/lux_validate_bin
+
 # --- Summary ---
 printf "\n${BOLD}═══ Validation Summary ═══${NC}\n"
 if [ $FAILED -eq 0 ]; then

src/codegen/c_backend.rs

@@ -279,7 +279,7 @@ impl CBackend {
                 Declaration::Let(let_decl) => {
                     // Skip run expressions - they're handled in the main wrapper
                     if !matches!(&let_decl.value, Expr::Run { .. }) {
-                        self.emit_global_let(&let_decl.name, &let_decl.value)?;
+                        self.emit_global_let(&let_decl.name)?;
                     }
                 }
                 _ => {}
@@ -882,6 +882,14 @@ impl CBackend {
         self.writeln("    int64_t capacity;");
         self.writeln("};");
         self.writeln("");
+        self.writeln("// Map struct (linear-scan key-value table, string keys)");
+        self.writeln("typedef struct {");
+        self.writeln("    LuxString* keys;");
+        self.writeln("    void** values;");
+        self.writeln("    int64_t length;");
+        self.writeln("    int64_t capacity;");
+        self.writeln("} LuxMap;");
+        self.writeln("");
         self.writeln("// === Reference Counting Infrastructure ===");
         self.writeln("// Perceus-inspired RC system for automatic memory management.");
         self.writeln("// See docs/REFERENCE_COUNTING.md for details.");
@@ -1141,6 +1149,7 @@ impl CBackend {
         self.writeln("    void (*delete_file)(void* env, LuxString path);");
         self.writeln("    LuxBool (*isDir)(void* env, LuxString path);");
         self.writeln("    void (*mkdir)(void* env, LuxString path);");
+        self.writeln("    void (*copy)(void* env, LuxString src, LuxString dst);");
         self.writeln("    LuxList* (*readDir)(void* env, LuxString path);");
         self.writeln("    void* env;");
         self.writeln("} LuxFileHandler;");
@@ -1328,6 +1337,20 @@ impl CBackend {
         self.writeln("    mkdir(path, 0755);");
         self.writeln("}");
         self.writeln("");
+        self.writeln("static void lux_file_copy(LuxString src, LuxString dst) {");
+        self.writeln("    FILE* fin = fopen(src, \"rb\");");
+        self.writeln("    if (!fin) return;");
+        self.writeln("    FILE* fout = fopen(dst, \"wb\");");
+        self.writeln("    if (!fout) { fclose(fin); return; }");
+        self.writeln("    char buf[4096];");
+        self.writeln("    size_t n;");
+        self.writeln("    while ((n = fread(buf, 1, sizeof(buf), fin)) > 0) {");
+        self.writeln("        fwrite(buf, 1, n, fout);");
+        self.writeln("    }");
+        self.writeln("    fclose(fin);");
+        self.writeln("    fclose(fout);");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("#include <dirent.h>");
         self.writeln("// Forward declarations needed by lux_file_readDir");
         self.writeln("static LuxList* lux_list_new(int64_t capacity);");
@@ -1383,6 +1406,11 @@ impl CBackend {
         self.writeln("    lux_file_mkdir(path);");
         self.writeln("}");
         self.writeln("");
+        self.writeln("static void default_file_copy(void* env, LuxString src, LuxString dst) {");
+        self.writeln("    (void)env;");
+        self.writeln("    lux_file_copy(src, dst);");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("static LuxList* default_file_readDir(void* env, LuxString path) {");
         self.writeln("    (void)env;");
         self.writeln("    return lux_file_readDir(path);");
@@ -1396,6 +1424,7 @@ impl CBackend {
         self.writeln("    .delete_file = default_file_delete,");
         self.writeln("    .isDir = default_file_isDir,");
         self.writeln("    .mkdir = default_file_mkdir,");
+        self.writeln("    .copy = default_file_copy,");
         self.writeln("    .readDir = default_file_readDir,");
         self.writeln("    .env = NULL");
         self.writeln("};");
@@ -2043,6 +2072,76 @@ impl CBackend {
         self.writeln("    return result;");
         self.writeln("}");
         self.writeln("");
+        // === Map Runtime Functions ===
+        self.writeln("static LuxMap* lux_map_new(int64_t capacity) {");
+        self.writeln("    LuxMap* map = (LuxMap*)malloc(sizeof(LuxMap));");
+        self.writeln("    map->capacity = capacity > 0 ? capacity : 8;");
+        self.writeln("    map->keys = (LuxString*)calloc(map->capacity, sizeof(LuxString));");
+        self.writeln("    map->values = (void**)calloc(map->capacity, sizeof(void*));");
+        self.writeln("    map->length = 0;");
+        self.writeln("    return map;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static int64_t lux_map_find(LuxMap* map, LuxString key) {");
+        self.writeln("    for (int64_t i = 0; i < map->length; i++) {");
+        self.writeln("        if (map->keys[i] && strcmp(map->keys[i], key) == 0) return i;");
+        self.writeln("    }");
+        self.writeln("    return -1;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static LuxMap* lux_map_clone(LuxMap* map) {");
+        self.writeln("    LuxMap* result = lux_map_new(map->capacity);");
+        self.writeln("    result->length = map->length;");
+        self.writeln("    for (int64_t i = 0; i < map->length; i++) {");
+        self.writeln("        result->keys[i] = lux_string_dup(map->keys[i]);");
+        self.writeln("        result->values[i] = map->values[i];");
+        self.writeln("        lux_incref(map->values[i]);");
+        self.writeln("    }");
+        self.writeln("    return result;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static LuxMap* lux_map_set(LuxMap* map, LuxString key, void* value) {");
+        self.writeln("    LuxMap* result = lux_map_clone(map);");
+        self.writeln("    int64_t idx = lux_map_find(result, key);");
+        self.writeln("    if (idx >= 0) {");
+        self.writeln("        lux_decref(result->values[idx]);");
+        self.writeln("        result->values[idx] = value;");
+        self.writeln("        lux_incref(value);");
+        self.writeln("    } else {");
+        self.writeln("        if (result->length >= result->capacity) {");
+        self.writeln("            result->capacity *= 2;");
+        self.writeln("            result->keys = (LuxString*)realloc(result->keys, sizeof(LuxString) * result->capacity);");
+        self.writeln("            result->values = (void**)realloc(result->values, sizeof(void*) * result->capacity);");
+        self.writeln("        }");
+        self.writeln("        result->keys[result->length] = lux_string_dup(key);");
+        self.writeln("        result->values[result->length] = value;");
+        self.writeln("        lux_incref(value);");
+        self.writeln("        result->length++;");
+        self.writeln("    }");
+        self.writeln("    return result;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static int64_t lux_map_size(LuxMap* map) { return map->length; }");
+        self.writeln("static LuxBool lux_map_isEmpty(LuxMap* map) { return map->length == 0; }");
+        self.writeln("");
+        self.writeln("static LuxBool lux_map_contains(LuxMap* map, LuxString key) {");
+        self.writeln("    return lux_map_find(map, key) >= 0;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static LuxMap* lux_map_remove(LuxMap* map, LuxString key) {");
+        self.writeln("    LuxMap* result = lux_map_new(map->capacity);");
+        self.writeln("    for (int64_t i = 0; i < map->length; i++) {");
+        self.writeln("        if (strcmp(map->keys[i], key) != 0) {");
+        self.writeln("            result->keys[result->length] = lux_string_dup(map->keys[i]);");
+        self.writeln("            result->values[result->length] = map->values[i];");
+        self.writeln("            lux_incref(map->values[i]);");
+        self.writeln("            result->length++;");
+        self.writeln("        }");
+        self.writeln("    }");
+        self.writeln("    return result;");
+        self.writeln("}");
+        self.writeln("");
+
         self.writeln("static Option lux_option_none(void) { return (Option){Option_TAG_NONE}; }");
         self.writeln("static Option lux_option_some(void* value) { return (Option){Option_TAG_SOME, .data.some = {value}}; }");
         self.writeln("");
@@ -3014,6 +3113,9 @@ impl CBackend {
                         if module_name.name == "List" {
                             return self.emit_list_operation(&field.name, args);
                         }
+                        if module_name.name == "Map" {
+                            return self.emit_map_operation(&field.name, args);
+                        }
                         // Int module
                         if module_name.name == "Int" && field.name == "toString" {
                             let arg = self.emit_expr(&args[0])?;
@@ -3022,6 +3124,10 @@ impl CBackend {
                             self.register_rc_var(&temp, "LuxString");
                             return Ok(temp);
                         }
+                        if module_name.name == "Int" && field.name == "toFloat" {
+                            let arg = self.emit_expr(&args[0])?;
+                            return Ok(format!("((LuxFloat){})", arg));
+                        }
                         // Float module
                         if module_name.name == "Float" && field.name == "toString" {
                             let arg = self.emit_expr(&args[0])?;
@@ -3030,6 +3136,10 @@ impl CBackend {
                             self.register_rc_var(&temp, "LuxString");
                             return Ok(temp);
                         }
+                        if module_name.name == "Float" && field.name == "toInt" {
+                            let arg = self.emit_expr(&args[0])?;
+                            return Ok(format!("((LuxInt){})", arg));
+                        }
                         // Math module
                         if module_name.name == "Math" {
                             return self.emit_math_operation(&field.name, args);
@@ -3379,6 +3489,10 @@ impl CBackend {
                             self.register_rc_var(&temp, "LuxString");
                             return Ok(temp);
                         }
+                        "toFloat" => {
+                            let arg = self.emit_expr(&args[0])?;
+                            return Ok(format!("((LuxFloat){})", arg));
+                        }
                         _ => {}
                     }
                 }
@@ -3393,6 +3507,10 @@ impl CBackend {
                             self.register_rc_var(&temp, "LuxString");
                             return Ok(temp);
                         }
+                        "toInt" => {
+                            let arg = self.emit_expr(&args[0])?;
+                            return Ok(format!("((LuxInt){})", arg));
+                        }
                         _ => {}
                     }
                 }
@@ -3402,6 +3520,11 @@ impl CBackend {
                     return self.emit_math_operation(&operation.name, args);
                 }
 
+                // Map module
+                if effect.name == "Map" {
+                    return self.emit_map_operation(&operation.name, args);
+                }
+
                 // Built-in Console effect
                 if effect.name == "Console" {
                     if operation.name == "print" {
@@ -3577,6 +3700,16 @@ impl CBackend {
                             }
                             return Ok("NULL".to_string());
                         }
+                        "copy" => {
+                            let src = self.emit_expr(&args[0])?;
+                            let dst = self.emit_expr(&args[1])?;
+                            if self.has_evidence {
+                                self.writeln(&format!("ev->file->copy(ev->file->env, {}, {});", src, dst));
+                            } else {
+                                self.writeln(&format!("lux_file_copy({}, {});", src, dst));
+                            }
+                            return Ok("NULL".to_string());
+                        }
                         "readDir" | "listDir" => {
                             let path = self.emit_expr(&args[0])?;
                             let temp = format!("_readdir_{}", self.fresh_name());
@@ -4520,6 +4653,140 @@ impl CBackend {
         }
     }
 
+    /// Emit code for Map module operations
+    fn emit_map_operation(&mut self, op: &str, args: &[Expr]) -> Result<String, CGenError> {
+        match op {
+            "new" => {
+                let temp = format!("_map_new_{}", self.fresh_name());
+                self.writeln(&format!("LuxMap* {} = lux_map_new(8);", temp));
+                Ok(temp)
+            }
+            "set" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                let val = self.emit_expr(&args[2])?;
+                let boxed_val = self.box_value(&val, None);
+                let temp = format!("_map_set_{}", self.fresh_name());
+                self.writeln(&format!("LuxMap* {} = lux_map_set({}, {}, {});", temp, map, key, boxed_val));
+                Ok(temp)
+            }
+            "get" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                let idx_temp = format!("_map_idx_{}", self.fresh_name());
+                let result_temp = format!("_map_get_{}", self.fresh_name());
+                self.writeln(&format!("int64_t {} = lux_map_find({}, {});", idx_temp, map, key));
+                self.writeln(&format!("Option {};", result_temp));
+                self.writeln(&format!("if ({} >= 0) {{", idx_temp));
+                self.indent += 1;
+                self.writeln(&format!("lux_incref({}->values[{}]);", map, idx_temp));
+                self.writeln(&format!("{} = lux_option_some({}->values[{}]);", result_temp, map, idx_temp));
+                self.indent -= 1;
+                self.writeln("} else {");
+                self.indent += 1;
+                self.writeln(&format!("{} = lux_option_none();", result_temp));
+                self.indent -= 1;
+                self.writeln("}");
+                Ok(result_temp)
+            }
+            "contains" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!("lux_map_contains({}, {})", map, key))
+            }
+            "remove" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                let temp = format!("_map_rm_{}", self.fresh_name());
+                self.writeln(&format!("LuxMap* {} = lux_map_remove({}, {});", temp, map, key));
+                Ok(temp)
+            }
+            "keys" => {
+                let map = self.emit_expr(&args[0])?;
+                let temp = format!("_map_keys_{}", self.fresh_name());
+                self.writeln(&format!("LuxList* {} = lux_list_new({}->length);", temp, map));
+                // Sort keys: simple insertion sort
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++) {{", map));
+                self.indent += 1;
+                self.writeln(&format!("LuxString _ks = lux_string_dup({}->keys[_i]);", map));
+                self.writeln(&format!("lux_list_push({}, _ks);", temp));
+                self.indent -= 1;
+                self.writeln("}");
+                // Sort via bubble sort (small N)
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++)", temp));
+                self.writeln(&format!("  for (int64_t _j = _i+1; _j < {}->length; _j++)", temp));
+                self.writeln(&format!("    if (strcmp({}->elements[_i], {}->elements[_j]) > 0) {{", temp, temp));
+                self.writeln(&format!("      void* _t = {}->elements[_i]; {}->elements[_i] = {}->elements[_j]; {}->elements[_j] = _t;", temp, temp, temp, temp));
+                self.writeln("    }");
+                Ok(temp)
+            }
+            "values" => {
+                let map = self.emit_expr(&args[0])?;
+                let temp = format!("_map_vals_{}", self.fresh_name());
+                self.writeln(&format!("LuxList* {} = lux_list_new({}->length);", temp, map));
+                // Sort by key first, then collect values
+                self.writeln(&format!("int64_t* _idx = (int64_t*)malloc(sizeof(int64_t) * {}->length);", map));
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++) _idx[_i] = _i;", map));
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++)", map));
+                self.writeln(&format!("  for (int64_t _j = _i+1; _j < {}->length; _j++)", map));
+                self.writeln(&format!("    if (strcmp({}->keys[_idx[_i]], {}->keys[_idx[_j]]) > 0) {{ int64_t _t = _idx[_i]; _idx[_i] = _idx[_j]; _idx[_j] = _t; }}", map, map));
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++) {{", map));
+                self.indent += 1;
+                self.writeln(&format!("lux_incref({}->values[_idx[_i]]);", map));
+                self.writeln(&format!("lux_list_push({}, {}->values[_idx[_i]]);", temp, map));
+                self.indent -= 1;
+                self.writeln("}");
+                self.writeln("free(_idx);");
+                Ok(temp)
+            }
+            "size" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("lux_map_size({})", map))
+            }
+            "isEmpty" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("lux_map_isEmpty({})", map))
+            }
+            "fromList" => {
+                let list = self.emit_expr(&args[0])?;
+                let temp = format!("_map_fl_{}", self.fresh_name());
+                self.writeln(&format!("LuxMap* {} = lux_map_new({}->length);", temp, list));
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++) {{", list));
+                self.indent += 1;
+                // Elements are tuples (boxed as void*) — we treat them as a simple 2-element struct
+                self.writeln("// Each element is a (String, V) tuple - not yet fully supported in C backend for Map");
+                self.indent -= 1;
+                self.writeln("}");
+                Ok(temp)
+            }
+            "toList" => {
+                let map = self.emit_expr(&args[0])?;
+                let temp = format!("_map_tl_{}", self.fresh_name());
+                self.writeln(&format!("LuxList* {} = lux_list_new({}->length);", temp, map));
+                self.writeln("// Map.toList not fully supported in C backend yet");
+                Ok(temp)
+            }
+            "merge" => {
+                let m1 = self.emit_expr(&args[0])?;
+                let m2 = self.emit_expr(&args[1])?;
+                let temp = format!("_map_merge_{}", self.fresh_name());
+                self.writeln(&format!("LuxMap* {} = lux_map_clone({});", temp, m1));
+                self.writeln(&format!("for (int64_t _i = 0; _i < {}->length; _i++) {{", m2));
+                self.indent += 1;
+                self.writeln(&format!("LuxMap* _next = lux_map_set({}, {}->keys[_i], {}->values[_i]);", temp, m2, m2));
+                self.writeln(&format!("free({}->keys); free({}->values); free({});", temp, temp, temp));
+                self.writeln(&format!("{} = _next;", temp));
+                self.indent -= 1;
+                self.writeln("}");
+                Ok(temp)
+            }
+            _ => Err(CGenError {
+                message: format!("Unsupported Map operation: {}", op),
+                span: None,
+            }),
+        }
+    }
+
     fn emit_expr_with_substitution(&mut self, expr: &Expr, from: &str, to: &str) -> Result<String, CGenError> {
         // Simple substitution - in a real implementation, this would be more sophisticated
         match expr {
@@ -4832,11 +5099,13 @@ impl CBackend {
                                 "toString" => return Some("LuxString".to_string()),
                                 "parse" => return Some("Option".to_string()),
                                 "abs" | "min" | "max" => return Some("LuxInt".to_string()),
+                                "toFloat" => return Some("LuxFloat".to_string()),
                                 _ => {}
                             },
                             "Float" => match field.name.as_str() {
                                 "toString" => return Some("LuxString".to_string()),
                                 "parse" => return Some("Option".to_string()),
+                                "toInt" => return Some("LuxInt".to_string()),
                                 _ => return Some("LuxFloat".to_string()),
                             },
                             _ => {
@@ -4888,6 +5157,7 @@ impl CBackend {
                 if effect.name == "Int" {
                     match operation.name.as_str() {
                         "toString" => return Some("LuxString".to_string()),
+                        "toFloat" => return Some("LuxFloat".to_string()),
                         _ => return None,
                     }
                 }
@@ -4895,6 +5165,7 @@ impl CBackend {
                 if effect.name == "Float" {
                     match operation.name.as_str() {
                         "toString" => return Some("LuxString".to_string()),
+                        "toInt" => return Some("LuxInt".to_string()),
                         _ => return None,
                     }
                 }
@@ -4935,7 +5206,7 @@ impl CBackend {
                 } else if effect.name == "File" {
                     match operation.name.as_str() {
                         "read" => Some("LuxString".to_string()),
-                        "write" | "append" | "delete" | "mkdir" => Some("void".to_string()),
+                        "write" | "append" | "delete" | "mkdir" | "copy" => Some("void".to_string()),
                         "exists" | "isDir" => Some("LuxBool".to_string()),
                         "readDir" | "listDir" => Some("LuxList*".to_string()),
                         _ => None,
@@ -5321,9 +5592,9 @@ impl CBackend {
         }
     }
 
-    fn emit_global_let(&mut self, name: &Ident, value: &Expr) -> Result<(), CGenError> {
+    fn emit_global_let(&mut self, name: &Ident) -> Result<(), CGenError> {
-        let val = self.emit_expr(value)?;
+        // Declare global variable without initializer (initialized in main)
-        self.writeln(&format!("static LuxInt {} = {};", name.name, val));
+        self.writeln(&format!("static LuxInt {} = 0;", name.name));
         self.writeln("");
         Ok(())
     }
@@ -5334,12 +5605,16 @@ impl CBackend {
             matches!(d, Declaration::Function(f) if f.name.name == "main")
         });
 
-        // Check for top-level run expressions
+        // Check for top-level run expressions or let bindings
         let has_run = program.declarations.iter().any(|d| {
             matches!(d, Declaration::Let(let_decl) if matches!(&let_decl.value, Expr::Run { .. }))
         });
 
-        if has_main || has_run {
+        let has_global_lets = program.declarations.iter().any(|d| {
+            matches!(d, Declaration::Let(let_decl) if !matches!(&let_decl.value, Expr::Run { .. }))
+        });
+
+        if has_main || has_run || has_global_lets {
             self.writeln("int main(int argc, char** argv) {");
             self.indent += 1;
 
@@ -5348,6 +5623,16 @@ impl CBackend {
             self.writeln("lux_argv = argv;");
             self.writeln("");
 
+            // Initialize top-level let bindings (non-run) inside main
+            for decl in &program.declarations {
+                if let Declaration::Let(let_decl) = decl {
+                    if !matches!(&let_decl.value, Expr::Run { .. }) {
+                        let val = self.emit_expr(&let_decl.value)?;
+                        self.writeln(&format!("{} = {};", let_decl.name.name, val));
+                    }
+                }
+            }
+
             // Execute top-level let bindings with run expressions
             // Track if main was already called via a run expression
             let mut main_called_via_run = false;

src/codegen/js_backend.rs

@@ -69,6 +69,8 @@ pub struct JsBackend {
     has_handlers: bool,
     /// Variable substitutions for let binding
     var_substitutions: HashMap<String, String>,
+    /// Effects actually used in the program (for tree-shaking runtime)
+    used_effects: HashSet<String>,
 }
 
 impl JsBackend {
@@ -90,6 +92,7 @@ impl JsBackend {
             effectful_functions: HashSet::new(),
             has_handlers: false,
             var_substitutions: HashMap::new(),
+            used_effects: HashSet::new(),
         }
     }
 
@@ -97,9 +100,6 @@ impl JsBackend {
     pub fn generate(&mut self, program: &Program) -> Result<String, JsGenError> {
         self.output.clear();
 
-        // Emit runtime helpers
-        self.emit_runtime();
-
         // First pass: collect all function names, types, and effects
         for decl in &program.declarations {
             match decl {
@@ -116,6 +116,12 @@ impl JsBackend {
             }
         }
 
+        // Collect used effects for tree-shaking
+        self.collect_used_effects(program);
+
+        // Emit runtime helpers (tree-shaken based on used effects)
+        self.emit_runtime();
+
         // Emit type constructors
         for decl in &program.declarations {
             if let Declaration::Type(t) = decl {
@@ -163,32 +169,181 @@ impl JsBackend {
         Ok(self.output.clone())
     }
 
-    /// Emit the minimal Lux runtime
+    /// Collect all effects used in the program for runtime tree-shaking
+    fn collect_used_effects(&mut self, program: &Program) {
+        for decl in &program.declarations {
+            match decl {
+                Declaration::Function(f) => {
+                    for effect in &f.effects {
+                        self.used_effects.insert(effect.name.clone());
+                    }
+                    self.collect_effects_from_expr(&f.body);
+                }
+                Declaration::Let(l) => {
+                    self.collect_effects_from_expr(&l.value);
+                }
+                Declaration::Handler(h) => {
+                    self.used_effects.insert(h.effect.name.clone());
+                    for imp in &h.implementations {
+                        self.collect_effects_from_expr(&imp.body);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Recursively collect effect names from an expression
+    fn collect_effects_from_expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::EffectOp { effect, args, .. } => {
+                self.used_effects.insert(effect.name.clone());
+                for arg in args {
+                    self.collect_effects_from_expr(arg);
+                }
+            }
+            Expr::Run { expr, handlers, .. } => {
+                self.collect_effects_from_expr(expr);
+                for (effect, handler) in handlers {
+                    self.used_effects.insert(effect.name.clone());
+                    self.collect_effects_from_expr(handler);
+                }
+            }
+            Expr::Call { func, args, .. } => {
+                self.collect_effects_from_expr(func);
+                for arg in args {
+                    self.collect_effects_from_expr(arg);
+                }
+            }
+            Expr::Lambda { body, effects, .. } => {
+                for effect in effects {
+                    self.used_effects.insert(effect.name.clone());
+                }
+                self.collect_effects_from_expr(body);
+            }
+            Expr::Let { value, body, .. } => {
+                self.collect_effects_from_expr(value);
+                self.collect_effects_from_expr(body);
+            }
+            Expr::If { condition, then_branch, else_branch, .. } => {
+                self.collect_effects_from_expr(condition);
+                self.collect_effects_from_expr(then_branch);
+                self.collect_effects_from_expr(else_branch);
+            }
+            Expr::Match { scrutinee, arms, .. } => {
+                self.collect_effects_from_expr(scrutinee);
+                for arm in arms {
+                    self.collect_effects_from_expr(&arm.body);
+                    if let Some(guard) = &arm.guard {
+                        self.collect_effects_from_expr(guard);
+                    }
+                }
+            }
+            Expr::Block { statements, result, .. } => {
+                for stmt in statements {
+                    match stmt {
+                        Statement::Expr(e) => self.collect_effects_from_expr(e),
+                        Statement::Let { value, .. } => self.collect_effects_from_expr(value),
+                    }
+                }
+                self.collect_effects_from_expr(result);
+            }
+            Expr::BinaryOp { left, right, .. } => {
+                self.collect_effects_from_expr(left);
+                self.collect_effects_from_expr(right);
+            }
+            Expr::UnaryOp { operand, .. } => {
+                self.collect_effects_from_expr(operand);
+            }
+            Expr::Field { object, .. } => {
+                self.collect_effects_from_expr(object);
+            }
+            Expr::TupleIndex { object, .. } => {
+                self.collect_effects_from_expr(object);
+            }
+            Expr::Record { spread, fields, .. } => {
+                if let Some(s) = spread {
+                    self.collect_effects_from_expr(s);
+                }
+                for (_, expr) in fields {
+                    self.collect_effects_from_expr(expr);
+                }
+            }
+            Expr::Tuple { elements, .. } | Expr::List { elements, .. } => {
+                for el in elements {
+                    self.collect_effects_from_expr(el);
+                }
+            }
+            Expr::Resume { value, .. } => {
+                self.collect_effects_from_expr(value);
+            }
+            Expr::Literal(_) | Expr::Var(_) => {}
+        }
+    }
+
+    /// Emit the Lux runtime, tree-shaken based on used effects
     fn emit_runtime(&mut self) {
+        let uses_console = self.used_effects.contains("Console");
+        let uses_random = self.used_effects.contains("Random");
+        let uses_time = self.used_effects.contains("Time");
+        let uses_http = self.used_effects.contains("Http");
+        let uses_dom = self.used_effects.contains("Dom");
+        let uses_html = self.used_effects.contains("Html") || uses_dom;
+
         self.writeln("// Lux Runtime");
         self.writeln("const Lux = {");
         self.indent += 1;
 
-        // Option helpers
+        // Core helpers — always emitted
         self.writeln("Some: (value) => ({ tag: \"Some\", value }),");
         self.writeln("None: () => ({ tag: \"None\" }),");
         self.writeln("");
-
-        // Result helpers
         self.writeln("Ok: (value) => ({ tag: \"Ok\", value }),");
         self.writeln("Err: (error) => ({ tag: \"Err\", error }),");
         self.writeln("");
-
-        // List helpers
         self.writeln("Cons: (head, tail) => [head, ...tail],");
         self.writeln("Nil: () => [],");
         self.writeln("");
 
-        // Default handlers for effects
+        // Default handlers — only include effects that are used
         self.writeln("defaultHandlers: {");
         self.indent += 1;
 
-        // Console effect
+        if uses_console {
+            self.emit_console_handler();
+        }
+        if uses_random {
+            self.emit_random_handler();
+        }
+        if uses_time {
+            self.emit_time_handler();
+        }
+        if uses_http {
+            self.emit_http_handler();
+        }
+        if uses_dom {
+            self.emit_dom_handler();
+        }
+
+        self.indent -= 1;
+        self.writeln("},");
+
+        // HTML rendering — only if Html or Dom effects are used
+        if uses_html {
+            self.emit_html_helpers();
+        }
+
+        // TEA runtime — only if Dom is used
+        if uses_dom {
+            self.emit_tea_runtime();
+        }
+
+        self.indent -= 1;
+        self.writeln("};");
+        self.writeln("");
+    }
+
+    fn emit_console_handler(&mut self) {
         self.writeln("Console: {");
         self.indent += 1;
         self.writeln("print: (msg) => console.log(msg),");
@@ -207,8 +362,9 @@ impl JsBackend {
         self.writeln("readInt: () => parseInt(Lux.defaultHandlers.Console.readLine(), 10)");
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // Random effect
+    fn emit_random_handler(&mut self) {
         self.writeln("Random: {");
         self.indent += 1;
         self.writeln("int: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,");
@@ -216,16 +372,18 @@ impl JsBackend {
         self.writeln("float: () => Math.random()");
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // Time effect
+    fn emit_time_handler(&mut self) {
         self.writeln("Time: {");
         self.indent += 1;
         self.writeln("now: () => Date.now(),");
         self.writeln("sleep: (ms) => new Promise(resolve => setTimeout(resolve, ms))");
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // Http effect (browser/Node compatible)
+    fn emit_http_handler(&mut self) {
         self.writeln("Http: {");
         self.indent += 1;
         self.writeln("get: async (url) => {");
@@ -287,8 +445,9 @@ impl JsBackend {
         self.writeln("}");
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // Dom effect (browser only - stubs for Node.js)
+    fn emit_dom_handler(&mut self) {
         self.writeln("Dom: {");
         self.indent += 1;
 
@@ -316,7 +475,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Element creation
         self.writeln("createElement: (tag) => {");
         self.indent += 1;
         self.writeln("if (typeof document === 'undefined') return null;");
@@ -331,7 +489,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // DOM manipulation
         self.writeln("appendChild: (parent, child) => {");
         self.indent += 1;
         self.writeln("if (parent && child) parent.appendChild(child);");
@@ -356,7 +513,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Content
         self.writeln("setTextContent: (el, text) => {");
         self.indent += 1;
         self.writeln("if (el) el.textContent = text;");
@@ -381,7 +537,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Attributes
         self.writeln("setAttribute: (el, name, value) => {");
         self.indent += 1;
         self.writeln("if (el) el.setAttribute(name, value);");
@@ -408,7 +563,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Classes
         self.writeln("addClass: (el, className) => {");
         self.indent += 1;
         self.writeln("if (el) el.classList.add(className);");
@@ -433,7 +587,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Styles
         self.writeln("setStyle: (el, property, value) => {");
         self.indent += 1;
         self.writeln("if (el) el.style[property] = value;");
@@ -446,7 +599,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Form elements
         self.writeln("getValue: (el) => {");
         self.indent += 1;
         self.writeln("return el ? el.value : '';");
@@ -471,7 +623,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Events
         self.writeln("addEventListener: (el, event, handler) => {");
         self.indent += 1;
         self.writeln("if (el) el.addEventListener(event, handler);");
@@ -484,7 +635,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Focus
         self.writeln("focus: (el) => {");
         self.indent += 1;
         self.writeln("if (el && el.focus) el.focus();");
@@ -497,7 +647,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Document
         self.writeln("getBody: () => {");
         self.indent += 1;
         self.writeln("if (typeof document === 'undefined') return null;");
@@ -512,7 +661,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Window
         self.writeln("getWindow: () => {");
         self.indent += 1;
         self.writeln("if (typeof window === 'undefined') return null;");
@@ -545,7 +693,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Scroll
         self.writeln("scrollTo: (x, y) => {");
         self.indent += 1;
         self.writeln("if (typeof window !== 'undefined') window.scrollTo(x, y);");
@@ -558,7 +705,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Dimensions
         self.writeln("getBoundingClientRect: (el) => {");
         self.indent += 1;
         self.writeln("if (!el) return { top: 0, left: 0, width: 0, height: 0, right: 0, bottom: 0 };");
@@ -574,13 +720,11 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("}");
 
-        self.indent -= 1;
-        self.writeln("}");
-
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // HTML rendering helpers
+    fn emit_html_helpers(&mut self) {
         self.writeln("");
         self.writeln("// HTML rendering");
         self.writeln("renderHtml: (node) => {");
@@ -682,8 +826,9 @@ impl JsBackend {
         self.writeln("return el;");
         self.indent -= 1;
         self.writeln("},");
+    }
 
-        // TEA (The Elm Architecture) runtime
+    fn emit_tea_runtime(&mut self) {
         self.writeln("");
         self.writeln("// The Elm Architecture (TEA) runtime");
         self.writeln("app: (config) => {");
@@ -727,7 +872,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Simple app (for string-based views like the counter example)
         self.writeln("");
         self.writeln("// Simple TEA app (string-based view)");
         self.writeln("simpleApp: (config) => {");
@@ -757,7 +901,6 @@ impl JsBackend {
         self.indent -= 1;
         self.writeln("},");
 
-        // Diff and patch (basic implementation for view_deps optimization)
         self.writeln("");
         self.writeln("// Basic diff - checks if model fields changed");
         self.writeln("hasChanged: (oldModel, newModel, ...paths) => {");
@@ -777,11 +920,7 @@ impl JsBackend {
         self.writeln("}");
         self.writeln("return false;");
         self.indent -= 1;
-        self.writeln("}");
+        self.writeln("},");
-
-        self.indent -= 1;
-        self.writeln("};");
-        self.writeln("");
     }
 
     /// Collect type information from a type declaration
@@ -888,7 +1027,8 @@ impl JsBackend {
         let prev_has_handlers = self.has_handlers;
         self.has_handlers = is_effectful;
 
-        // Clear var substitutions for this function
+        // Save and clear var substitutions for this function scope
+        let saved_substitutions = self.var_substitutions.clone();
         self.var_substitutions.clear();
 
         // Emit function body
@@ -896,6 +1036,7 @@ impl JsBackend {
         self.writeln(&format!("return {};", body_code));
 
         self.has_handlers = prev_has_handlers;
+        self.var_substitutions = saved_substitutions;
 
         self.indent -= 1;
         self.writeln("}");
@@ -1074,6 +1215,31 @@ impl JsBackend {
                         if module_name.name == "List" {
                             return self.emit_list_operation(&field.name, args);
                         }
+                        if module_name.name == "Map" {
+                            return self.emit_map_operation(&field.name, args);
+                        }
+                    }
+                }
+
+                // Int/Float module operations
+                if let Expr::Field { object, field, .. } = func.as_ref() {
+                    if let Expr::Var(module_name) = object.as_ref() {
+                        if module_name.name == "Int" {
+                            let arg = self.emit_expr(&args[0])?;
+                            match field.name.as_str() {
+                                "toFloat" => return Ok(arg),
+                                "toString" => return Ok(format!("String({})", arg)),
+                                _ => {}
+                            }
+                        }
+                        if module_name.name == "Float" {
+                            let arg = self.emit_expr(&args[0])?;
+                            match field.name.as_str() {
+                                "toInt" => return Ok(format!("Math.trunc({})", arg)),
+                                "toString" => return Ok(format!("String({})", arg)),
+                                _ => {}
+                            }
+                        }
                     }
                 }
 
@@ -1163,6 +1329,26 @@ impl JsBackend {
                     return self.emit_math_operation(&operation.name, args);
                 }
 
+                // Special case: Int module operations
+                if effect.name == "Int" {
+                    let arg = self.emit_expr(&args[0])?;
+                    match operation.name.as_str() {
+                        "toFloat" => return Ok(arg), // JS numbers are already floats
+                        "toString" => return Ok(format!("String({})", arg)),
+                        _ => {}
+                    }
+                }
+
+                // Special case: Float module operations
+                if effect.name == "Float" {
+                    let arg = self.emit_expr(&args[0])?;
+                    match operation.name.as_str() {
+                        "toInt" => return Ok(format!("Math.trunc({})", arg)),
+                        "toString" => return Ok(format!("String({})", arg)),
+                        _ => {}
+                    }
+                }
+
                 // Special case: Result module operations (not an effect)
                 if effect.name == "Result" {
                     return self.emit_result_operation(&operation.name, args);
@@ -1173,6 +1359,11 @@ impl JsBackend {
                     return self.emit_json_operation(&operation.name, args);
                 }
 
+                // Special case: Map module operations (not an effect)
+                if effect.name == "Map" {
+                    return self.emit_map_operation(&operation.name, args);
+                }
+
                 // Special case: Html module operations (not an effect)
                 if effect.name == "Html" {
                     return self.emit_html_operation(&operation.name, args);
@@ -1218,18 +1409,39 @@ impl JsBackend {
                     param_names
                 };
 
-                // Save handler state
+                // Save state
                 let prev_has_handlers = self.has_handlers;
+                let saved_substitutions = self.var_substitutions.clone();
                 self.has_handlers = !effects.is_empty();
 
+                // Register lambda params as themselves (override any outer substitutions)
+                for p in &all_params {
+                    self.var_substitutions.insert(p.clone(), p.clone());
+                }
+
+                // Capture any statements emitted during body evaluation
+                let output_start = self.output.len();
+                let prev_indent = self.indent;
+                self.indent += 1;
+
                 let body_code = self.emit_expr(body)?;
+                self.writeln(&format!("return {};", body_code));
 
+                // Extract body statements and restore output
+                let body_statements = self.output[output_start..].to_string();
+                self.output.truncate(output_start);
+                self.indent = prev_indent;
+
+                // Restore state
                 self.has_handlers = prev_has_handlers;
+                self.var_substitutions = saved_substitutions;
 
+                let indent_str = "    ".repeat(self.indent);
                 Ok(format!(
-                    "(function({}) {{ return {}; }})",
+                    "(function({}) {{\n{}{}}})",
                     all_params.join(", "),
-                    body_code
+                    body_statements,
+                    indent_str,
                 ))
             }
 
@@ -2097,6 +2309,86 @@ impl JsBackend {
         }
     }
 
+    /// Emit Map module operations using JS Map
+    fn emit_map_operation(
+        &mut self,
+        operation: &str,
+        args: &[Expr],
+    ) -> Result<String, JsGenError> {
+        match operation {
+            "new" => Ok("new Map()".to_string()),
+            "set" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                let val = self.emit_expr(&args[2])?;
+                Ok(format!(
+                    "(function() {{ var m = new Map({}); m.set({}, {}); return m; }})()",
+                    map, key, val
+                ))
+            }
+            "get" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "({0}.has({1}) ? Lux.Some({0}.get({1})) : Lux.None())",
+                    map, key
+                ))
+            }
+            "contains" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!("{}.has({})", map, key))
+            }
+            "remove" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "(function() {{ var m = new Map({}); m.delete({}); return m; }})()",
+                    map, key
+                ))
+            }
+            "keys" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("Array.from({}.keys()).sort()", map))
+            }
+            "values" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "Array.from({0}.entries()).sort(function(a,b) {{ return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0; }}).map(function(e) {{ return e[1]; }})",
+                    map
+                ))
+            }
+            "size" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("{}.size", map))
+            }
+            "isEmpty" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("({}.size === 0)", map))
+            }
+            "fromList" => {
+                let list = self.emit_expr(&args[0])?;
+                Ok(format!("new Map({}.map(function(t) {{ return [t[0], t[1]]; }}))", list))
+            }
+            "toList" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "Array.from({}.entries()).sort(function(a,b) {{ return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0; }})",
+                    map
+                ))
+            }
+            "merge" => {
+                let m1 = self.emit_expr(&args[0])?;
+                let m2 = self.emit_expr(&args[1])?;
+                Ok(format!("new Map([...{}, ...{}])", m1, m2))
+            }
+            _ => Err(JsGenError {
+                message: format!("Unknown Map operation: {}", operation),
+                span: None,
+            }),
+        }
+    }
+
     /// Emit Html module operations for type-safe HTML construction
     fn emit_html_operation(
         &mut self,
@@ -3767,7 +4059,7 @@ line3"
 
     #[test]
     fn test_js_runtime_generated() {
-        // Test that the Lux runtime is properly generated
+        // Test that the Lux runtime core is always generated
         use crate::parser::Parser;
 
         let source = r#"
@@ -3778,21 +4070,51 @@ line3"
         let mut backend = JsBackend::new();
         let js_code = backend.generate(&program).expect("Should generate");
 
-        // Check that Lux runtime includes key functions
+        // Core runtime is always present
         assert!(js_code.contains("const Lux = {"), "Lux object should be defined");
         assert!(js_code.contains("Some:"), "Option Some should be defined");
         assert!(js_code.contains("None:"), "Option None should be defined");
-        assert!(js_code.contains("renderHtml:"), "renderHtml should be defined");
+
-        assert!(js_code.contains("renderToDom:"), "renderToDom should be defined");
+        // Console-only program should NOT include Dom, Html, or TEA sections
-        assert!(js_code.contains("escapeHtml:"), "escapeHtml should be defined");
+        assert!(!js_code.contains("Dom:"), "Dom handler should not be in Console-only program");
-        assert!(js_code.contains("app:"), "TEA app should be defined");
+        assert!(!js_code.contains("renderHtml:"), "renderHtml should not be in Console-only program");
-        assert!(js_code.contains("simpleApp:"), "simpleApp should be defined");
+        assert!(!js_code.contains("app:"), "TEA app should not be in Console-only program");
-        assert!(js_code.contains("hasChanged:"), "hasChanged should be defined");
+        assert!(!js_code.contains("Http:"), "Http should not be in Console-only program");
+
+        // Console should be present
+        assert!(js_code.contains("Console:"), "Console handler should exist");
+    }
+
+    #[test]
+    fn test_js_runtime_tree_shaking_all_effects() {
+        // Test that all effects are included when all are used
+        use crate::parser::Parser;
+
+        let source = r#"
+            fn main(): Unit with {Console, Dom} = {
+                Console.print("Hello")
+                let _ = Dom.getElementById("app")
+                ()
+            }
+        "#;
+
+        let program = Parser::parse_source(source).expect("Should parse");
+        let mut backend = JsBackend::new();
+        let js_code = backend.generate(&program).expect("Should generate");
+
+        assert!(js_code.contains("Console:"), "Console handler should exist");
+        assert!(js_code.contains("Dom:"), "Dom handler should exist");
+        assert!(js_code.contains("renderHtml:"), "renderHtml should be defined when Dom is used");
+        assert!(js_code.contains("renderToDom:"), "renderToDom should be defined when Dom is used");
+        assert!(js_code.contains("escapeHtml:"), "escapeHtml should be defined when Dom is used");
+        assert!(js_code.contains("app:"), "TEA app should be defined when Dom is used");
+        assert!(js_code.contains("simpleApp:"), "simpleApp should be defined when Dom is used");
+        assert!(js_code.contains("hasChanged:"), "hasChanged should be defined when Dom is used");
     }
 
     #[test]
     fn test_js_runtime_default_handlers() {
-        // Test that default handlers are properly generated
+        // Test that only used effect handlers are generated
         use crate::parser::Parser;
 
         let source = r#"
@@ -3803,12 +4125,12 @@ line3"
         let mut backend = JsBackend::new();
         let js_code = backend.generate(&program).expect("Should generate");
 
-        // Check that default handlers include all effects
+        // Only Console should be present
         assert!(js_code.contains("Console:"), "Console handler should exist");
-        assert!(js_code.contains("Random:"), "Random handler should exist");
+        assert!(!js_code.contains("Random:"), "Random handler should not exist in Console-only program");
-        assert!(js_code.contains("Time:"), "Time handler should exist");
+        assert!(!js_code.contains("Time:"), "Time handler should not exist in Console-only program");
-        assert!(js_code.contains("Http:"), "Http handler should exist");
+        assert!(!js_code.contains("Http:"), "Http handler should not exist in Console-only program");
-        assert!(js_code.contains("Dom:"), "Dom handler should exist");
+        assert!(!js_code.contains("Dom:"), "Dom handler should not exist in Console-only program");
     }
 
     #[test]

src/interpreter.rs

@@ -100,7 +100,9 @@ pub enum BuiltinFn {
 
     // Int/Float operations
     IntToString,
+    IntToFloat,
     FloatToString,
+    FloatToInt,
 
     // JSON operations
     JsonParse,
@@ -122,6 +124,20 @@ pub enum BuiltinFn {
     JsonString,
     JsonArray,
     JsonObject,
+
+    // Map operations
+    MapNew,
+    MapSet,
+    MapGet,
+    MapContains,
+    MapRemove,
+    MapKeys,
+    MapValues,
+    MapSize,
+    MapIsEmpty,
+    MapFromList,
+    MapToList,
+    MapMerge,
 }
 
 /// Runtime value
@@ -136,6 +152,7 @@ pub enum Value {
     List(Vec<Value>),
     Tuple(Vec<Value>),
     Record(HashMap<String, Value>),
+    Map(HashMap<String, Value>),
     Function(Rc<Closure>),
     Handler(Rc<HandlerValue>),
     /// Built-in function
@@ -167,6 +184,7 @@ impl Value {
             Value::List(_) => "List",
             Value::Tuple(_) => "Tuple",
             Value::Record(_) => "Record",
+            Value::Map(_) => "Map",
             Value::Function(_) => "Function",
             Value::Handler(_) => "Handler",
             Value::Builtin(_) => "Function",
@@ -215,6 +233,11 @@ impl Value {
                     ys.get(k).map(|yv| Value::values_equal(v, yv)).unwrap_or(false)
                 })
             }
+            (Value::Map(xs), Value::Map(ys)) => {
+                xs.len() == ys.len() && xs.iter().all(|(k, v)| {
+                    ys.get(k).map(|yv| Value::values_equal(v, yv)).unwrap_or(false)
+                })
+            }
             (Value::Constructor { name: n1, fields: f1 }, Value::Constructor { name: n2, fields: f2 }) => {
                 n1 == n2 && f1.len() == f2.len() && f1.iter().zip(f2.iter()).all(|(x, y)| Value::values_equal(x, y))
             }
@@ -285,6 +308,16 @@ impl TryFromValue for Vec<Value> {
     }
 }
 
+impl TryFromValue for HashMap<String, Value> {
+    const TYPE_NAME: &'static str = "Map";
+    fn try_from_value(value: &Value) -> Option<Self> {
+        match value {
+            Value::Map(m) => Some(m.clone()),
+            _ => None,
+        }
+    }
+}
+
 impl TryFromValue for Value {
     const TYPE_NAME: &'static str = "any";
     fn try_from_value(value: &Value) -> Option<Self> {
@@ -331,6 +364,18 @@ impl fmt::Display for Value {
                 }
                 write!(f, " }}")
             }
+            Value::Map(entries) => {
+                write!(f, "Map {{")?;
+                let mut sorted: Vec<_> = entries.iter().collect();
+                sorted.sort_by_key(|(k, _)| (*k).clone());
+                for (i, (key, value)) in sorted.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "\"{}\": {}", key, value)?;
+                }
+                write!(f, "}}")
+            }
             Value::Function(_) => write!(f, "<function>"),
             Value::Builtin(b) => write!(f, "<builtin:{:?}>", b),
             Value::Handler(_) => write!(f, "<handler>"),
@@ -1084,12 +1129,14 @@ impl Interpreter {
         // Int module
         let int_module = Value::Record(HashMap::from([
             ("toString".to_string(), Value::Builtin(BuiltinFn::IntToString)),
+            ("toFloat".to_string(), Value::Builtin(BuiltinFn::IntToFloat)),
         ]));
         env.define("Int", int_module);
 
         // Float module
         let float_module = Value::Record(HashMap::from([
             ("toString".to_string(), Value::Builtin(BuiltinFn::FloatToString)),
+            ("toInt".to_string(), Value::Builtin(BuiltinFn::FloatToInt)),
         ]));
         env.define("Float", float_module);
 
@@ -1116,6 +1163,23 @@ impl Interpreter {
             ("object".to_string(), Value::Builtin(BuiltinFn::JsonObject)),
         ]));
         env.define("Json", json_module);
+
+        // Map module
+        let map_module = Value::Record(HashMap::from([
+            ("new".to_string(), Value::Builtin(BuiltinFn::MapNew)),
+            ("set".to_string(), Value::Builtin(BuiltinFn::MapSet)),
+            ("get".to_string(), Value::Builtin(BuiltinFn::MapGet)),
+            ("contains".to_string(), Value::Builtin(BuiltinFn::MapContains)),
+            ("remove".to_string(), Value::Builtin(BuiltinFn::MapRemove)),
+            ("keys".to_string(), Value::Builtin(BuiltinFn::MapKeys)),
+            ("values".to_string(), Value::Builtin(BuiltinFn::MapValues)),
+            ("size".to_string(), Value::Builtin(BuiltinFn::MapSize)),
+            ("isEmpty".to_string(), Value::Builtin(BuiltinFn::MapIsEmpty)),
+            ("fromList".to_string(), Value::Builtin(BuiltinFn::MapFromList)),
+            ("toList".to_string(), Value::Builtin(BuiltinFn::MapToList)),
+            ("merge".to_string(), Value::Builtin(BuiltinFn::MapMerge)),
+        ]));
+        env.define("Map", map_module);
     }
 
     /// Execute a program
@@ -2364,6 +2428,26 @@ impl Interpreter {
                 }
             }
 
+            BuiltinFn::IntToFloat => {
+                if args.len() != 1 {
+                    return Err(err("Int.toFloat requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Int(n) => Ok(EvalResult::Value(Value::Float(*n as f64))),
+                    v => Err(err(&format!("Int.toFloat expects Int, got {}", v.type_name()))),
+                }
+            }
+
+            BuiltinFn::FloatToInt => {
+                if args.len() != 1 {
+                    return Err(err("Float.toInt requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Float(f) => Ok(EvalResult::Value(Value::Int(*f as i64))),
+                    v => Err(err(&format!("Float.toInt expects Float, got {}", v.type_name()))),
+                }
+            }
+
             BuiltinFn::TypeOf => {
                 if args.len() != 1 {
                     return Err(err("typeOf requires 1 argument"));
@@ -3068,6 +3152,128 @@ impl Interpreter {
                 }
                 Ok(EvalResult::Value(Value::Json(serde_json::Value::Object(map))))
             }
+
+            // Map operations
+            BuiltinFn::MapNew => {
+                Ok(EvalResult::Value(Value::Map(HashMap::new())))
+            }
+
+            BuiltinFn::MapSet => {
+                if args.len() != 3 {
+                    return Err(err("Map.set requires 3 arguments: map, key, value"));
+                }
+                let mut map = match &args[0] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.set expects Map as first argument, got {}", v.type_name()))),
+                };
+                let key = match &args[1] {
+                    Value::String(s) => s.clone(),
+                    v => return Err(err(&format!("Map.set expects String key, got {}", v.type_name()))),
+                };
+                map.insert(key, args[2].clone());
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapGet => {
+                let (map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.get", span)?;
+                match map.get(&key) {
+                    Some(v) => Ok(EvalResult::Value(Value::Constructor {
+                        name: "Some".to_string(),
+                        fields: vec![v.clone()],
+                    })),
+                    None => Ok(EvalResult::Value(Value::Constructor {
+                        name: "None".to_string(),
+                        fields: vec![],
+                    })),
+                }
+            }
+
+            BuiltinFn::MapContains => {
+                let (map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.contains", span)?;
+                Ok(EvalResult::Value(Value::Bool(map.contains_key(&key))))
+            }
+
+            BuiltinFn::MapRemove => {
+                let (mut map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.remove", span)?;
+                map.remove(&key);
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapKeys => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.keys", span)?;
+                let mut keys: Vec<String> = map.keys().cloned().collect();
+                keys.sort();
+                Ok(EvalResult::Value(Value::List(
+                    keys.into_iter().map(Value::String).collect(),
+                )))
+            }
+
+            BuiltinFn::MapValues => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.values", span)?;
+                let mut entries: Vec<(String, Value)> = map.into_iter().collect();
+                entries.sort_by(|(a, _), (b, _)| a.cmp(b));
+                Ok(EvalResult::Value(Value::List(
+                    entries.into_iter().map(|(_, v)| v).collect(),
+                )))
+            }
+
+            BuiltinFn::MapSize => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.size", span)?;
+                Ok(EvalResult::Value(Value::Int(map.len() as i64)))
+            }
+
+            BuiltinFn::MapIsEmpty => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.isEmpty", span)?;
+                Ok(EvalResult::Value(Value::Bool(map.is_empty())))
+            }
+
+            BuiltinFn::MapFromList => {
+                let list = Self::expect_arg_1::<Vec<Value>>(&args, "Map.fromList", span)?;
+                let mut map = HashMap::new();
+                for item in list {
+                    match item {
+                        Value::Tuple(fields) if fields.len() == 2 => {
+                            let key = match &fields[0] {
+                                Value::String(s) => s.clone(),
+                                v => return Err(err(&format!("Map.fromList expects (String, V) tuples, got {} key", v.type_name()))),
+                            };
+                            map.insert(key, fields[1].clone());
+                        }
+                        _ => return Err(err("Map.fromList expects List<(String, V)>")),
+                    }
+                }
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapToList => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.toList", span)?;
+                let mut entries: Vec<(String, Value)> = map.into_iter().collect();
+                entries.sort_by(|(a, _), (b, _)| a.cmp(b));
+                Ok(EvalResult::Value(Value::List(
+                    entries
+                        .into_iter()
+                        .map(|(k, v)| Value::Tuple(vec![Value::String(k), v]))
+                        .collect(),
+                )))
+            }
+
+            BuiltinFn::MapMerge => {
+                if args.len() != 2 {
+                    return Err(err("Map.merge requires 2 arguments: map1, map2"));
+                }
+                let mut map1 = match &args[0] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.merge expects Map as first argument, got {}", v.type_name()))),
+                };
+                let map2 = match &args[1] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.merge expects Map as second argument, got {}", v.type_name()))),
+                };
+                for (k, v) in map2 {
+                    map1.insert(k, v);
+                }
+                Ok(EvalResult::Value(Value::Map(map1)))
+            }
         }
     }
 
@@ -3233,6 +3439,11 @@ impl Interpreter {
                     b.get(k).map(|bv| self.values_equal(v, bv)).unwrap_or(false)
                 })
             }
+            (Value::Map(a), Value::Map(b)) => {
+                a.len() == b.len() && a.iter().all(|(k, v)| {
+                    b.get(k).map(|bv| self.values_equal(v, bv)).unwrap_or(false)
+                })
+            }
             (
                 Value::Constructor {
                     name: n1,
@@ -3653,6 +3864,30 @@ impl Interpreter {
                 }
             }
 
+            ("File", "copy") => {
+                let source = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string source path".to_string(),
+                        span: None,
+                    }),
+                };
+                let dest = match request.args.get(1) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string destination path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::copy(&source, &dest) {
+                    Ok(_) => Ok(Value::Unit),
+                    Err(e) => Err(RuntimeError {
+                        message: format!("Failed to copy '{}' to '{}': {}", source, dest, e),
+                        span: None,
+                    }),
+                }
+            }
+
             // ===== Process Effect =====
             ("Process", "exec") => {
                 use std::process::Command;

src/lexer.rs

@@ -42,6 +42,7 @@ pub enum TokenKind {
     Effect,
     Handler,
     Run,
+    Handle,
     Resume,
     Type,
     True,
@@ -140,6 +141,7 @@ impl fmt::Display for TokenKind {
             TokenKind::Effect => write!(f, "effect"),
             TokenKind::Handler => write!(f, "handler"),
             TokenKind::Run => write!(f, "run"),
+            TokenKind::Handle => write!(f, "handle"),
             TokenKind::Resume => write!(f, "resume"),
             TokenKind::Type => write!(f, "type"),
             TokenKind::Import => write!(f, "import"),
@@ -771,6 +773,7 @@ impl<'a> Lexer<'a> {
             "effect" => TokenKind::Effect,
             "handler" => TokenKind::Handler,
             "run" => TokenKind::Run,
+            "handle" => TokenKind::Handle,
             "resume" => TokenKind::Resume,
             "type" => TokenKind::Type,
             "import" => TokenKind::Import,
@@ -789,6 +792,8 @@ impl<'a> Lexer<'a> {
             "commutative" => TokenKind::Commutative,
             "where" => TokenKind::Where,
             "assume" => TokenKind::Assume,
+            "and" => TokenKind::And,
+            "or" => TokenKind::Or,
             "true" => TokenKind::Bool(true),
             "false" => TokenKind::Bool(false),
             _ => TokenKind::Ident(ident.to_string()),

src/main.rs

@@ -193,10 +193,12 @@ fn main() {
                     eprintln!("       lux compile <file.lux> --run");
                     eprintln!("       lux compile <file.lux> --emit-c [-o file.c]");
                     eprintln!("       lux compile <file.lux> --target js [-o file.js]");
+                    eprintln!("       lux compile <file.lux> --watch");
                     std::process::exit(1);
                 }
                 let run_after = args.iter().any(|a| a == "--run");
                 let emit_c = args.iter().any(|a| a == "--emit-c");
+                let watch = args.iter().any(|a| a == "--watch");
                 let target_js = args.iter()
                     .position(|a| a == "--target")
                     .and_then(|i| args.get(i + 1))
@@ -212,6 +214,16 @@ fn main() {
                 } else {
                     compile_to_c(&args[2], output_path, run_after, emit_c);
                 }
+
+                if watch {
+                    // Build the args to replay for each recompilation (without --watch)
+                    let compile_args: Vec<String> = args.iter()
+                        .skip(1)
+                        .filter(|a| a.as_str() != "--watch")
+                        .cloned()
+                        .collect();
+                    watch_and_rerun(&args[2], &compile_args);
+                }
             }
             "repl" => {
                 // Start REPL
@@ -1351,6 +1363,64 @@ fn watch_file(path: &str) {
     }
 }
 
+fn watch_and_rerun(path: &str, compile_args: &[String]) {
+    use std::time::{Duration, SystemTime};
+    use std::path::Path;
+
+    let file_path = Path::new(path);
+    if !file_path.exists() {
+        eprintln!("File not found: {}", path);
+        std::process::exit(1);
+    }
+
+    println!();
+    println!("Watching {} for changes (Ctrl+C to stop)...", path);
+
+    let mut last_modified = std::fs::metadata(file_path)
+        .and_then(|m| m.modified())
+        .unwrap_or(SystemTime::UNIX_EPOCH);
+
+    loop {
+        std::thread::sleep(Duration::from_millis(500));
+
+        let modified = match std::fs::metadata(file_path).and_then(|m| m.modified()) {
+            Ok(m) => m,
+            Err(_) => continue,
+        };
+
+        if modified > last_modified {
+            last_modified = modified;
+
+            // Clear screen
+            print!("\x1B[2J\x1B[H");
+
+            println!("=== Compiling {} ===", path);
+            println!();
+
+            let result = std::process::Command::new(std::env::current_exe().unwrap())
+                .args(compile_args)
+                .status();
+
+            match result {
+                Ok(status) if status.success() => {
+                    println!();
+                    println!("=== Success ===");
+                }
+                Ok(_) => {
+                    println!();
+                    println!("=== Failed ===");
+                }
+                Err(e) => {
+                    eprintln!("Error running compiler: {}", e);
+                }
+            }
+
+            println!();
+            println!("Watching for changes...");
+        }
+    }
+}
+
 fn serve_static_files(dir: &str, port: u16) {
     use std::io::{Write, BufRead, BufReader};
     use std::net::TcpListener;
@@ -5441,4 +5511,173 @@ c")"#;
             check_file("projects/rest-api/main.lux").unwrap();
         }
     }
+
+    // === Map type tests ===
+
+    #[test]
+    fn test_map_new_and_size() {
+        let source = r#"
+            let m = Map.new()
+            let result = Map.size(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "0");
+    }
+
+    #[test]
+    fn test_map_set_and_get() {
+        let source = r#"
+            let m = Map.new()
+            let m2 = Map.set(m, "name", "Alice")
+            let result = Map.get(m2, "name")
+        "#;
+        assert_eq!(eval(source).unwrap(), "Some(\"Alice\")");
+    }
+
+    #[test]
+    fn test_map_get_missing() {
+        let source = r#"
+            let m = Map.new()
+            let result = Map.get(m, "missing")
+        "#;
+        assert_eq!(eval(source).unwrap(), "None");
+    }
+
+    #[test]
+    fn test_map_contains() {
+        let source = r#"
+            let m = Map.set(Map.new(), "x", 1)
+            let result = (Map.contains(m, "x"), Map.contains(m, "y"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(true, false)");
+    }
+
+    #[test]
+    fn test_map_remove() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "a", 1), "b", 2)
+            let m2 = Map.remove(m, "a")
+            let result = (Map.size(m2), Map.contains(m2, "a"), Map.contains(m2, "b"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(1, false, true)");
+    }
+
+    #[test]
+    fn test_map_keys_and_values() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "b", 2), "a", 1)
+            let result = Map.keys(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "[\"a\", \"b\"]");
+    }
+
+    #[test]
+    fn test_map_from_list() {
+        let source = r#"
+            let m = Map.fromList([("x", 10), ("y", 20)])
+            let result = (Map.get(m, "x"), Map.size(m))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(Some(10), 2)");
+    }
+
+    #[test]
+    fn test_map_to_list() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "b", 2), "a", 1)
+            let result = Map.toList(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "[(\"a\", 1), (\"b\", 2)]");
+    }
+
+    #[test]
+    fn test_map_merge() {
+        let source = r#"
+            let m1 = Map.fromList([("a", 1), ("b", 2)])
+            let m2 = Map.fromList([("b", 3), ("c", 4)])
+            let merged = Map.merge(m1, m2)
+            let result = (Map.get(merged, "a"), Map.get(merged, "b"), Map.get(merged, "c"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(Some(1), Some(3), Some(4))");
+    }
+
+    #[test]
+    fn test_map_immutability() {
+        let source = r#"
+            let m1 = Map.fromList([("a", 1)])
+            let m2 = Map.set(m1, "b", 2)
+            let result = (Map.size(m1), Map.size(m2))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(1, 2)");
+    }
+
+    #[test]
+    fn test_map_is_empty() {
+        let source = r#"
+            let m1 = Map.new()
+            let m2 = Map.set(m1, "x", 1)
+            let result = (Map.isEmpty(m1), Map.isEmpty(m2))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(true, false)");
+    }
+
+    #[test]
+    fn test_map_type_annotation() {
+        let source = r#"
+            fn lookup(m: Map<String, Int>, key: String): Option<Int> =
+                Map.get(m, key)
+            let m = Map.fromList([("age", 30)])
+            let result = lookup(m, "age")
+        "#;
+        assert_eq!(eval(source).unwrap(), "Some(30)");
+    }
+
+    #[test]
+    fn test_file_copy() {
+        use std::io::Write;
+        // Create a temp file, copy it, verify contents
+        let dir = std::env::temp_dir().join("lux_test_file_copy");
+        let _ = std::fs::create_dir_all(&dir);
+        let src = dir.join("src.txt");
+        let dst = dir.join("dst.txt");
+        std::fs::File::create(&src).unwrap().write_all(b"hello copy").unwrap();
+        let _ = std::fs::remove_file(&dst);
+
+        let source = format!(r#"
+            fn main(): Unit with {{File}} =
+                File.copy("{}", "{}")
+            let _ = run main() with {{}}
+            let result = "done"
+        "#, src.display(), dst.display());
+        let result = eval(&source);
+        assert!(result.is_ok(), "File.copy failed: {:?}", result);
+        let contents = std::fs::read_to_string(&dst).unwrap();
+        assert_eq!(contents, "hello copy");
+
+        // Cleanup
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn test_effectful_callback_propagation() {
+        // WISH-7: effectful callbacks in List.forEach should propagate effects
+        // This should type-check successfully because Console effect is inferred
+        let source = r#"
+            fn printAll(items: List<String>): Unit =
+                List.forEach(items, fn(x: String): Unit => Console.print(x))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback should type-check: {:?}", result);
+    }
+
+    #[test]
+    fn test_effectful_callback_in_map() {
+        // Effectful callback in List.map should propagate effects
+        let source = r#"
+            fn readAll(paths: List<String>): List<String> =
+                List.map(paths, fn(p: String): String => File.read(p))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback in map should type-check: {:?}", result);
+    }
 }

src/parser.rs

@@ -245,6 +245,7 @@ impl Parser {
             TokenKind::Trait => Ok(Declaration::Trait(self.parse_trait_decl(visibility, doc)?)),
             TokenKind::Impl => Ok(Declaration::Impl(self.parse_impl_decl()?)),
             TokenKind::Run => Err(self.error("Bare 'run' expressions are not allowed at top level. Use 'let _ = run ...' or 'let result = run ...'")),
+            TokenKind::Handle => Err(self.error("Bare 'handle' expressions are not allowed at top level. Use 'let _ = handle ...' or 'let result = handle ...'")),
             _ => Err(self.error("Expected declaration (fn, effect, handler, type, trait, impl, or let)")),
         }
     }
@@ -1775,6 +1776,7 @@ impl Parser {
             TokenKind::Let => self.parse_let_expr(),
             TokenKind::Fn => self.parse_lambda_expr(),
             TokenKind::Run => self.parse_run_expr(),
+            TokenKind::Handle => self.parse_handle_expr(),
             TokenKind::Resume => self.parse_resume_expr(),
 
             // Delimiters
@@ -1792,6 +1794,7 @@ impl Parser {
 
         let condition = Box::new(self.parse_expr()?);
 
+        self.skip_newlines();
         self.expect(TokenKind::Then)?;
         self.skip_newlines();
         let then_branch = Box::new(self.parse_expr()?);
@@ -2150,6 +2153,40 @@ impl Parser {
         })
     }
 
+    fn parse_handle_expr(&mut self) -> Result<Expr, ParseError> {
+        let start = self.current_span();
+        self.expect(TokenKind::Handle)?;
+
+        let expr = Box::new(self.parse_call_expr()?);
+
+        self.expect(TokenKind::With)?;
+        self.expect(TokenKind::LBrace)?;
+        self.skip_newlines();
+
+        let mut handlers = Vec::new();
+        while !self.check(TokenKind::RBrace) {
+            let effect = self.parse_ident()?;
+            self.expect(TokenKind::Eq)?;
+            let handler = self.parse_expr()?;
+            handlers.push((effect, handler));
+
+            self.skip_newlines();
+            if self.check(TokenKind::Comma) {
+                self.advance();
+            }
+            self.skip_newlines();
+        }
+
+        let end = self.current_span();
+        self.expect(TokenKind::RBrace)?;
+
+        Ok(Expr::Run {
+            expr,
+            handlers,
+            span: start.merge(end),
+        })
+    }
+
     fn parse_resume_expr(&mut self) -> Result<Expr, ParseError> {
         let start = self.current_span();
         self.expect(TokenKind::Resume)?;

src/typechecker.rs

@@ -1951,6 +1951,17 @@ impl TypeChecker {
         let func_type = self.infer_expr(func);
         let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
 
+        // Propagate effects from callback arguments to enclosing scope
+        for arg_type in &arg_types {
+            if let Type::Function { effects, .. } = arg_type {
+                for effect in &effects.effects {
+                    if self.inferring_effects {
+                        self.inferred_effects.insert(effect.clone());
+                    }
+                }
+            }
+        }
+
         // Check property constraints from where clauses
         if let Expr::Var(func_id) = func {
             if let Some(constraints) = self.property_constraints.get(&func_id.name).cloned() {
@@ -2061,6 +2072,18 @@ impl TypeChecker {
                 if let Some((_, field_type)) = fields.iter().find(|(n, _)| n == &operation.name) {
                     // It's a function call on a module field
                     let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
+
+                    // Propagate effects from callback arguments to enclosing scope
+                    for arg_type in &arg_types {
+                        if let Type::Function { effects, .. } = arg_type {
+                            for effect in &effects.effects {
+                                if self.inferring_effects {
+                                    self.inferred_effects.insert(effect.clone());
+                                }
+                            }
+                        }
+                    }
+
                     let result_type = Type::var();
                     let expected_fn = Type::function(arg_types, result_type.clone());
 
@@ -2120,6 +2143,17 @@ impl TypeChecker {
                 // Check argument types
                 let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
 
+                // Propagate effects from callback arguments to enclosing scope
+                for arg_type in &arg_types {
+                    if let Type::Function { effects, .. } = arg_type {
+                        for effect in &effects.effects {
+                            if self.inferring_effects {
+                                self.inferred_effects.insert(effect.clone());
+                            }
+                        }
+                    }
+                }
+
                 if arg_types.len() != op.params.len() {
                     self.errors.push(TypeError {
                         message: format!(
@@ -2569,6 +2603,7 @@ impl TypeChecker {
         // Start with spread fields if present
         let mut field_types: Vec<(String, Type)> = if let Some(spread_expr) = spread {
             let spread_type = self.infer_expr(spread_expr);
+            let spread_type = self.env.expand_type_alias(&spread_type);
             match spread_type {
                 Type::Record(spread_fields) => spread_fields,
                 _ => {
@@ -2965,6 +3000,9 @@ impl TypeChecker {
                         "Option" if resolved_args.len() == 1 => {
                             return Type::Option(Box::new(resolved_args[0].clone()));
                         }
+                        "Map" if resolved_args.len() == 2 => {
+                            return Type::Map(Box::new(resolved_args[0].clone()), Box::new(resolved_args[1].clone()));
+                        }
                         _ => {}
                     }
                 }

src/types.rs

@@ -47,6 +47,8 @@ pub enum Type {
     List(Box<Type>),
     /// Option type (sugar for App(Option, [T]))
     Option(Box<Type>),
+    /// Map type (sugar for App(Map, [K, V]))
+    Map(Box<Type>, Box<Type>),
     /// Versioned type (e.g., User @v2)
     Versioned {
         base: Box<Type>,
@@ -119,6 +121,7 @@ impl Type {
             Type::Tuple(elements) => elements.iter().any(|e| e.contains_var(var)),
             Type::Record(fields) => fields.iter().any(|(_, t)| t.contains_var(var)),
             Type::List(inner) | Type::Option(inner) => inner.contains_var(var),
+            Type::Map(k, v) => k.contains_var(var) || v.contains_var(var),
             Type::Versioned { base, .. } => base.contains_var(var),
             _ => false,
         }
@@ -158,6 +161,7 @@ impl Type {
             ),
             Type::List(inner) => Type::List(Box::new(inner.apply(subst))),
             Type::Option(inner) => Type::Option(Box::new(inner.apply(subst))),
+            Type::Map(k, v) => Type::Map(Box::new(k.apply(subst)), Box::new(v.apply(subst))),
             Type::Versioned { base, version } => Type::Versioned {
                 base: Box::new(base.apply(subst)),
                 version: version.clone(),
@@ -208,6 +212,11 @@ impl Type {
                 vars
             }
             Type::List(inner) | Type::Option(inner) => inner.free_vars(),
+            Type::Map(k, v) => {
+                let mut vars = k.free_vars();
+                vars.extend(v.free_vars());
+                vars
+            }
             Type::Versioned { base, .. } => base.free_vars(),
             _ => HashSet::new(),
         }
@@ -279,6 +288,7 @@ impl fmt::Display for Type {
             }
             Type::List(inner) => write!(f, "List<{}>", inner),
             Type::Option(inner) => write!(f, "Option<{}>", inner),
+            Type::Map(k, v) => write!(f, "Map<{}, {}>", k, v),
             Type::Versioned { base, version } => {
                 write!(f, "{} {}", base, version)
             }
@@ -946,6 +956,14 @@ impl TypeEnv {
                         params: vec![("path".to_string(), Type::String)],
                         return_type: Type::Unit,
                     },
+                    EffectOpDef {
+                        name: "copy".to_string(),
+                        params: vec![
+                            ("source".to_string(), Type::String),
+                            ("dest".to_string(), Type::String),
+                        ],
+                        return_type: Type::Unit,
+                    },
                 ],
             },
         );
@@ -1775,6 +1793,73 @@ impl TypeEnv {
         ]);
         env.bind("Option", TypeScheme::mono(option_module_type));
 
+        // Map module
+        let map_v = || Type::var();
+        let map_type = || Type::Map(Box::new(Type::String), Box::new(Type::var()));
+        let map_module_type = Type::Record(vec![
+            (
+                "new".to_string(),
+                Type::function(vec![], map_type()),
+            ),
+            (
+                "set".to_string(),
+                Type::function(
+                    vec![map_type(), Type::String, map_v()],
+                    map_type(),
+                ),
+            ),
+            (
+                "get".to_string(),
+                Type::function(
+                    vec![map_type(), Type::String],
+                    Type::Option(Box::new(map_v())),
+                ),
+            ),
+            (
+                "contains".to_string(),
+                Type::function(vec![map_type(), Type::String], Type::Bool),
+            ),
+            (
+                "remove".to_string(),
+                Type::function(vec![map_type(), Type::String], map_type()),
+            ),
+            (
+                "keys".to_string(),
+                Type::function(vec![map_type()], Type::List(Box::new(Type::String))),
+            ),
+            (
+                "values".to_string(),
+                Type::function(vec![map_type()], Type::List(Box::new(map_v()))),
+            ),
+            (
+                "size".to_string(),
+                Type::function(vec![map_type()], Type::Int),
+            ),
+            (
+                "isEmpty".to_string(),
+                Type::function(vec![map_type()], Type::Bool),
+            ),
+            (
+                "fromList".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::Tuple(vec![Type::String, map_v()])))],
+                    map_type(),
+                ),
+            ),
+            (
+                "toList".to_string(),
+                Type::function(
+                    vec![map_type()],
+                    Type::List(Box::new(Type::Tuple(vec![Type::String, map_v()]))),
+                ),
+            ),
+            (
+                "merge".to_string(),
+                Type::function(vec![map_type(), map_type()], map_type()),
+            ),
+        ]);
+        env.bind("Map", TypeScheme::mono(map_module_type));
+
         // Result module
         let result_type = Type::App {
             constructor: Box::new(Type::Named("Result".to_string())),
@@ -1908,6 +1993,10 @@ impl TypeEnv {
                 "toString".to_string(),
                 Type::function(vec![Type::Int], Type::String),
             ),
+            (
+                "toFloat".to_string(),
+                Type::function(vec![Type::Int], Type::Float),
+            ),
         ]);
         env.bind("Int", TypeScheme::mono(int_module_type));
 
@@ -1917,6 +2006,10 @@ impl TypeEnv {
                 "toString".to_string(),
                 Type::function(vec![Type::Float], Type::String),
             ),
+            (
+                "toInt".to_string(),
+                Type::function(vec![Type::Float], Type::Int),
+            ),
         ]);
         env.bind("Float", TypeScheme::mono(float_module_type));
 
@@ -2003,6 +2096,9 @@ impl TypeEnv {
             Type::Option(inner) => {
                 Type::Option(Box::new(self.expand_type_alias(inner)))
             }
+            Type::Map(k, v) => {
+                Type::Map(Box::new(self.expand_type_alias(k)), Box::new(self.expand_type_alias(v)))
+            }
             Type::Versioned { base, version } => {
                 Type::Versioned {
                     base: Box::new(self.expand_type_alias(base)),
@@ -2163,6 +2259,13 @@ pub fn unify(t1: &Type, t2: &Type) -> Result<Substitution, String> {
         // Option
         (Type::Option(a), Type::Option(b)) => unify(a, b),
 
+        // Map
+        (Type::Map(k1, v1), Type::Map(k2, v2)) => {
+            let s1 = unify(k1, k2)?;
+            let s2 = unify(&v1.apply(&s1), &v2.apply(&s1))?;
+            Ok(s1.compose(&s2))
+        }
+
         // Versioned types
         (
             Type::Versioned {