VM/tree-walk parity: mutable closures + imports + array mutation; + log analyzer demo

Three latent bugs prevented OMC programs that use the closure pattern
from working identically under OMC_VM=1. All three surface together as
soon as you try to write something non-trivial (here: a real CSV log
analyzer).

* Op::AssignVar — `x = e` in bytecode now walks scopes outward for an
  existing binding (mirrors tree-walk's assign_var); Op::StoreVar is
  still used for `h x = e` declarations. Fixes mutable closures: the
  bank-account pattern now produces 100, 150, 120, 120 under VM
  instead of shadowing balance on every write.

* Interpreter.process_imports — main.rs now walks top-level
  Statement::Import before VM dispatch and merges each module's
  functions into interp.functions. The bytecode compiler treats
  imports as no-ops; without the pre-pass, `math.fib_up_to(...)`
  failed with "Undefined function" under VM only.

* arr_push / arr_set use assign_var, not set_var (both engines).
  Pushes from inside a closure body now land in the captured env
  where the array actually lives, not the throwaway call scope.
  Same change applied to Op::ArrPushNamed, Op::ArrSetNamed,
  Op::SafeArrSetNamed, Op::ArrayIndexAssign.

Verified: 40/40 functional examples produce byte-identical output
under tree-walk and VM. (benchmarks.omc differs only in ns/op
measurements, with VM ~2.2x faster on recursive_fib as expected.)

examples/log_analyzer.omc — first non-trivial OMC program. 24-row
access log, computes standard stats (mean/peak latency, error rate,
per-endpoint breakdown via mutable-closure counter table) and three
OMC-distinctive harmonic analyses: harmonic_sort by HIM,
Fibonacci-attractor latency clustering, and attractor-based outlier
detection that correctly isolates the 500-error spikes at
2100/2900/3400 ms (all fold to the 610 attractor).

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

Author: RandomCoder-lab

examples/log_analyzer.omc

@@ -0,0 +1,215 @@
+# =============================================================================
+# Web log analyzer — a non-trivial OMC program
+# =============================================================================
+# Reads a CSV access log, computes standard summary statistics, then runs
+# OMC-distinctive harmonic analyses (Fibonacci-attractor partitioning of
+# latencies, harmonic_sort by HIM, attractor-grouped outlier detection).
+#
+# Demonstrates: file I/O, CSV parsing, first-class functions (arr_map /
+# arr_filter / arr_reduce), HOF composition, mutable closures for stats
+# accumulators, and the harmonic_* builtins as the OMC-native pivot.
+#
+# Run:
+#   ./target/release/omnimcode-standalone examples/log_analyzer.omc
+#   OMC_VM=1 ./target/release/omnimcode-standalone examples/log_analyzer.omc
+# =============================================================================
+
+# ---- 1. Generate sample log ------------------------------------------------
+# We embed the sample directly so the demo is self-contained — no
+# external file needed. 24 fake requests across four endpoints. The
+# `/api/search` endpoint deliberately has heavier-tailed latencies so
+# the harmonic-partition step has something interesting to show.
+
+h log_lines = [
+    "1715000001,/api/users,200,12",
+    "1715000002,/api/users,200,8",
+    "1715000003,/api/users,200,15",
+    "1715000004,/api/orders,200,22",
+    "1715000005,/api/orders,200,19",
+    "1715000006,/api/orders,500,2100",
+    "1715000007,/api/orders,200,21",
+    "1715000008,/api/search,200,89",
+    "1715000009,/api/search,200,144",
+    "1715000010,/api/search,200,55",
+    "1715000011,/api/search,200,233",
+    "1715000012,/api/search,200,90",
+    "1715000013,/api/search,500,3400",
+    "1715000014,/api/login,200,34",
+    "1715000015,/api/login,401,55",
+    "1715000016,/api/login,200,21",
+    "1715000017,/api/login,200,13",
+    "1715000018,/api/orders,200,17",
+    "1715000019,/api/users,200,9",
+    "1715000020,/api/users,200,11",
+    "1715000021,/api/search,200,87",
+    "1715000022,/api/search,500,2900",
+    "1715000023,/api/login,200,28",
+    "1715000024,/api/orders,200,18"
+];
+h sample = str_join(log_lines, "\n");
+
+write_file("/tmp/access.log", sample);
+
+# ---- 2. Read + parse -------------------------------------------------------
+
+h raw = read_file("/tmp/access.log");
+h lines = str_split(raw, "\n");
+
+# Each line → array [ts, endpoint, status, latency_ms]. We carry latency
+# as HInt so resonance / HIM math works on it downstream.
+fn parse_line(ln) {
+    h parts = str_split(ln, ",");
+    return [
+        to_int(arr_get(parts, 0)),
+        arr_get(parts, 1),
+        to_int(arr_get(parts, 2)),
+        to_int(arr_get(parts, 3))
+    ];
+}
+
+h rows = arr_map(lines, parse_line);
+
+# ---- 3. Standard summary stats --------------------------------------------
+
+fn get_status(row)   { return arr_get(row, 2); }
+fn get_latency(row)  { return arr_get(row, 3); }
+fn get_endpoint(row) { return arr_get(row, 1); }
+
+fn is_error(row) {
+    return get_status(row) >= 400;
+}
+
+h total = arr_len(rows);
+h errors = arr_filter(rows, is_error);
+h error_count = arr_len(errors);
+
+# Sum-of-latencies via reduce — exercises first-class fn closure
+fn add_latency(acc, row) { return acc + get_latency(row); }
+h total_latency = arr_reduce(rows, add_latency, 0);
+h mean_latency = total_latency / total;
+
+# Max via reduce
+fn max_latency(acc, row) {
+    h l = get_latency(row);
+    if l > acc { return l; }
+    return acc;
+}
+h peak_latency = arr_reduce(rows, max_latency, 0);
+
+println("=== Standard summary =====================================");
+println(concat_many("  total requests: ", total));
+println(concat_many("  errors (>=400): ", error_count));
+println(concat_many("  mean latency:   ", mean_latency, " ms"));
+println(concat_many("  peak latency:   ", peak_latency, " ms"));
+println("");
+
+# ---- 4. Per-endpoint breakdown via mutable-closure accumulator ------------
+# Build an endpoint→count map by hand (OMC has no dict yet, so we use two
+# parallel arrays and a small helper). The accumulator is a closure that
+# captures the parallel arrays — sibling closures share state, which is
+# exactly the mutable-closure case our recent VM work fixed.
+
+fn make_counter_table() {
+    h keys = [];
+    h vals = [];
+
+    h bump = fn(k) {
+        h i = 0;
+        while i < arr_len(keys) {
+            if arr_get(keys, i) == k {
+                arr_set(vals, i, arr_get(vals, i) + 1);
+                return 0;
+            }
+            i = i + 1;
+        }
+        # First time seeing this key — append.
+        arr_push(keys, k);
+        arr_push(vals, 1);
+        return 0;
+    };
+
+    h dump = fn() {
+        return [keys, vals];
+    };
+
+    return [bump, dump];
+}
+
+h tbl = make_counter_table();
+h bump = arr_get(tbl, 0);
+h dump = arr_get(tbl, 1);
+
+fn count_endpoint(row) {
+    bump(get_endpoint(row));
+    return 0;
+}
+arr_map(rows, count_endpoint);
+
+h pair = dump();
+h endpoints = arr_get(pair, 0);
+h counts = arr_get(pair, 1);
+
+println("=== Per-endpoint counts (via mutable closures) ============");
+h i = 0;
+while i < arr_len(endpoints) {
+    println(concat_many("  ", arr_get(endpoints, i), " : ", arr_get(counts, i)));
+    i = i + 1;
+}
+println("");
+
+# ---- 5. Harmonic statistics ------------------------------------------------
+# This is the OMC-distinctive part. We pull out just the latencies and
+# feed them through the harmonic_* builtins. The Fibonacci-attractor
+# partitioning gives us a free, semantically-meaningful histogram —
+# /api/search clumps near 89/144/233 (its natural latency band), while
+# the 500-error rows land in the 2300+ outlier bucket all by themselves.
+
+h latencies = arr_map(rows, get_latency);
+h harmonic_sorted = harmonic_sort(latencies);
+
+println("=== Harmonic-sort (by HIM score) ==========================");
+println("  Top 5 by harmonic dominance:");
+h j = 0;
+while j < 5 {
+    println(concat_many("    ", arr_get(harmonic_sorted, j), " ms"));
+    j = j + 1;
+}
+println("");
+
+h partitioned = harmonic_partition(latencies);
+
+println("=== Latency clustering on Fibonacci attractors ============");
+h k = 0;
+while k < arr_len(partitioned) {
+    h bucket = arr_get(partitioned, k);
+    h bucket_len = arr_len(bucket);
+    # Attractor-id = fold(first element) — cheap label.
+    h label = fold(arr_get(bucket, 0));
+    println(concat_many("  attractor ~", label, " : ", bucket_len, " request(s)"));
+    k = k + 1;
+}
+println("");
+
+# ---- 6. Outlier detection: high-attractor latencies -----------------------
+# An outlier is any latency landing on a Fibonacci attractor >= 377
+# (one φ-octave above the natural search-endpoint band). The 500-error
+# rows at 2100 / 2900 / 3400 ms all fold onto the 610 attractor, so
+# this surfaces them cleanly without arbitrary z-score thresholds.
+
+fn is_outlier(lat) {
+    if fold(lat) >= 377 { return 1; }
+    return 0;
+}
+
+h spikes = arr_filter(latencies, is_outlier);
+
+println("=== Outliers (latency >= 377-attractor) ===================");
+h m = 0;
+while m < arr_len(spikes) {
+    h s = arr_get(spikes, m);
+    println(concat_many("  spike: ", s, " ms (folds to attractor ", fold(s), ")"));
+    m = m + 1;
+}
+
+println("");
+println("=== Done ==================================================");

omnimcode-core/src/bytecode.rs

@@ -127,6 +127,17 @@ pub enum Op {
     /// call_first_class_function → tree-walk semantics for the body.
     /// Fast bytecode-VM execution of closure bodies is future work.
     Lambda(String),
+    /// Assignment to an EXISTING binding. Walks scopes from inner to
+    /// outer looking for the name; mutates in-place where found.
+    /// Falls back to innermost on miss (implicit declaration).
+    ///
+    /// Distinguishes `x = ...` (assignment) from `h x = ...`
+    /// (declaration via StoreVar). Without this distinction the VM
+    /// couldn't support mutable closures — `balance = balance + n`
+    /// inside a closure would shadow rather than mutate the captured
+    /// `balance`. Tree-walk has the same split via `assign_var` vs
+    /// `set_var`.
+    AssignVar(String),
 
     // Special harmonic operations (short-circuit to built-in semantics
     // without the call overhead — these are the hot ones).

omnimcode-core/src/compiler.rs

@@ -595,7 +595,7 @@ impl Compiler {
                     self.var_types.insert(name.clone(), t);
                 }
                 self.compile_expr(value)?;
-                self.emit(Op::StoreVar(name.clone()));
+                self.emit(Op::AssignVar(name.clone()));
             }
             Statement::IndexAssignment { name, index, value } => {
                 self.compile_expr(value)?;

omnimcode-core/src/disasm.rs

@@ -77,6 +77,7 @@ fn op_mnemonic(op: &Op, ip: usize, constants: &[Const]) -> String {
         Op::ArrSetNamed(name) => format!("ARR_SET_NAMED   {}", name),
         Op::SafeArrSetNamed(name) => format!("SAFE_ARR_SET_NAMED {}", name),
         Op::Lambda(name) => format!("LAMBDA          {}", name),
+        Op::AssignVar(name) => format!("ASSIGN_VAR      {}", name),
 
         Op::Resonance => "RESONANCE".to_string(),
         Op::Fold1 => "FOLD".to_string(),

omnimcode-core/src/interpreter.rs

@@ -2066,11 +2066,16 @@ impl Interpreter {
                     return Err("arr_push requires (array_name, value)".to_string());
                 }
                 // Mutates by name. First arg must be a Variable reference so we can write back.
+                // Use assign_var (walks outward for existing binding) instead of
+                // set_var (always innermost) — otherwise pushes inside a closure
+                // body would land in the closure's call scope, not the captured
+                // env where the array actually lives, and the mutation would be
+                // discarded on return.
                 let val = self.eval_expr(&args[1])?;
                 if let Expression::Variable(name) = &args[0] {
                     if let Some(Value::Array(mut arr)) = self.get_var(name) {
                         arr.items.push(val);
-                        self.set_var(name.clone(), Value::Array(arr));
+                        self.assign_var(name.clone(), Value::Array(arr));
                         return Ok(Value::Null);
                     }
                 }
@@ -2108,7 +2113,10 @@ impl Interpreter {
                             ));
                         }
                         arr.items[idx] = val;
-                        self.set_var(name.clone(), Value::Array(arr));
+                        // assign_var (not set_var) so mutations from inside a
+                        // closure body propagate into the captured env. Same
+                        // rationale as arr_push above.
+                        self.assign_var(name.clone(), Value::Array(arr));
                         return Ok(Value::Null);
                     }
                 }
@@ -3245,6 +3253,14 @@ impl Interpreter {
         self.set_var(name.to_string(), value);
     }
 
+    /// VM-facing wrapper around assign_var — walks scopes outward for
+    /// an existing binding, mutates there. See `assign_var` for the
+    /// rules. Used by Op::AssignVar (introduced for mutable closure
+    /// support).
+    pub fn vm_assign_var(&mut self, name: &str, value: Value) {
+        self.assign_var(name.to_string(), value);
+    }
+
     /// Return an Rc clone of the topmost local scope frame, for closure
     /// capture in Op::Lambda. The Rc is shared — multiple lambdas in
     /// the same scope get the same underlying RefCell, so mutations
@@ -3261,6 +3277,27 @@ impl Interpreter {
     /// the same function bodies. Tree-walks the body if reached this
     /// way; the user pays a slight cost for reflective dispatch in
     /// VM mode, but the regular Op::Call path stays bytecode-fast.
+    /// Process every top-level `Statement::Import` in `statements`,
+    /// registering the imported module's functions into self.functions.
+    /// Used by main.rs under OMC_VM=1, since the bytecode compiler
+    /// treats imports as no-ops and the VM never enters `execute_stmt`
+    /// for top-level statements (its execution model is bytecode, not
+    /// AST). Without this pre-pass, `math.fib_up_to(...)` calls in VM
+    /// mode would fail with "Undefined function" even though the
+    /// import line is there.
+    ///
+    /// Imports are deduplicated via `imported_modules`, so calling
+    /// this twice (e.g. once during pre-pass, once via execute) is
+    /// safe — the second call is a no-op.
+    pub fn process_imports(&mut self, statements: &[Statement]) -> Result<(), String> {
+        for stmt in statements {
+            if let Statement::Import { module, alias } = stmt {
+                self.import_module_with_alias(module, alias.as_deref())?;
+            }
+        }
+        Ok(())
+    }
+
     pub fn register_user_functions(&mut self, statements: &[Statement]) {
         // Walks every FunctionDef anywhere in the AST — including those
         // nested inside other fn bodies, if-branches, while bodies, etc.
@@ -3312,6 +3349,15 @@ impl Interpreter {
         None
     }
 
+    /// Same as vm_get_var but WITHOUT the function-table fallback. The VM's
+    /// Op::Call dispatch uses this to check "is `name` a variable holding
+    /// a Value::Function" — without falling back to a Function-ref from
+    /// the function table itself (which would be redundant; the is_user
+    /// branch above already handles that).
+    pub fn vm_get_var_local_only(&self, name: &str) -> Option<Value> {
+        self.get_var(name)
+    }
+
     /// Call a built-in (or user-defined) function with already-evaluated args.
     /// The VM uses this when it encounters Op::Call and the function isn't
     /// a compiled function in the current module.

omnimcode-core/src/main.rs

@@ -192,6 +192,13 @@ fn execute_program(source: &str) -> Result<(), String> {
         // dispatch paths can resolve them. The VM still uses its own
         // compiled function table for direct Op::Call dispatch; this
         // duplication only kicks in for first-class function reflection.
+        // Imports are no-ops in the bytecode compiler, so the VM
+        // never wires up `math.fib_up_to`-style aliased calls on its
+        // own. Run a pre-pass that walks top-level Statement::Import
+        // and merges each module's functions into interp.functions.
+        // Dot-namespaced calls then route through call_module_function
+        // and resolve normally.
+        vm.interp_mut().process_imports(&statements)?;
         vm.interp_mut().register_user_functions(&statements);
         // Also register every lambda body the compiler collected. Lambda
         // invocation routes through call_first_class_function → the