Auto-compile: lambdas → bytecode VM at load time

After loading .sx files, (vm-compile) iterates all named lambdas,
compiles each body to bytecode, replaces with NativeFn VM wrapper.

Results: 3/109 functions compiled (compiler needs more features).
CEK steps: 49911 → 38083 (23% fewer) for home page.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

hosts/ocaml/bin/sx_server.ml

@@ -206,6 +206,50 @@ let setup_io_env env =
     | [key] -> io_request "ctx" [key]
     | _ -> raise (Eval_error "ctx: expected 1 arg"));
 
+  (* ---- VM auto-compilation ---- *)
+  (* After all .sx files are loaded, compile top-level lambdas to bytecode.
+     Called from the load handler after each file. *)
+  let vm_compile_count = ref 0 in
+  let vm_compile_env () =
+    if not (Hashtbl.mem env.bindings "compile") then ()
+    else begin
+      let compile_fn = Hashtbl.find env.bindings "compile" in
+      let to_compile = Hashtbl.fold (fun name value acc ->
+        match value with
+        | Lambda lam when lam.l_name <> None -> (name, lam) :: acc
+        | _ -> acc
+      ) env.bindings [] in
+      List.iter (fun (name, lam) ->
+        (try
+          let quoted = List [Symbol "quote"; lam.l_body] in
+          let result = Sx_ref.eval_expr (List [compile_fn; quoted]) (Env env) in
+          match result with
+          | Dict d when Hashtbl.mem d "bytecode" ->
+            let code = Sx_vm.code_from_value result in
+            let globals = Hashtbl.create 256 in
+            Hashtbl.iter (fun k v -> Hashtbl.replace globals k v) env.bindings;
+            Hashtbl.iter (fun k v -> Hashtbl.replace globals k v) lam.l_closure.bindings;
+            let fn = NativeFn ("vm:" ^ name, fun args ->
+              Sx_vm.execute_closure { Sx_vm.code; name = lam.l_name } args globals) in
+            Hashtbl.replace env.bindings name fn;
+            incr vm_compile_count
+          | _ -> ()
+        with _ -> () (* silently skip compilation failures *))
+      ) to_compile;
+      if !vm_compile_count > 0 then
+        Printf.eprintf "[vm] Compiled %d functions to bytecode\n%!" !vm_compile_count
+    end
+  in
+  ignore vm_compile_env;  (* suppress unused warning — called from load handler *)
+
+  bind "call-lambda" (fun args ->
+    match args with
+    | [fn_val; List call_args; Env e] ->
+      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env e)
+    | [fn_val; List call_args] ->
+      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env env)
+    | _ -> raise (Eval_error "call-lambda: expected (fn args env?)"));
+
   (* Generic helper call — dispatches to Python page helpers *)
   bind "helper" (fun args ->
     io_request "helper" args)
@@ -792,6 +836,45 @@ let dispatch env cmd =
     | Eval_error msg -> send_error msg
     | exn -> send_error (Printexc.to_string exn))
 
+  | List [Symbol "vm-compile"] ->
+    (* Compile all named lambdas in env to bytecode.
+       Called after all .sx files are loaded. *)
+    (try
+      if not (Hashtbl.mem env.bindings "compile") then
+        send_error "compiler not loaded"
+      else begin
+        let compile_fn = Hashtbl.find env.bindings "compile" in
+        let count = ref 0 in
+        let failed = ref 0 in
+        let names = Hashtbl.fold (fun k _ acc -> k :: acc) env.bindings [] in
+        List.iter (fun name ->
+          match Hashtbl.find_opt env.bindings name with
+          | Some (Lambda lam) when lam.l_name <> None ->
+            (try
+              let quoted = List [Symbol "quote"; lam.l_body] in
+              let result = Sx_ref.eval_expr (List [compile_fn; quoted]) (Env env) in
+              match result with
+              | Dict d when Hashtbl.mem d "bytecode" ->
+                let code = Sx_vm.code_from_value result in
+                let globals_snapshot = Hashtbl.copy env.bindings in
+                Hashtbl.iter (fun k v ->
+                  Hashtbl.replace globals_snapshot k v) lam.l_closure.bindings;
+                let fn = NativeFn ("vm:" ^ name, fun args ->
+                  Sx_vm.execute_closure
+                    { Sx_vm.code; name = lam.l_name } args globals_snapshot) in
+                Hashtbl.replace env.bindings name fn;
+                incr count
+              | _ -> incr failed
+            with _ -> incr failed)
+          | _ -> ()
+        ) names;
+        Printf.eprintf "[vm] Compiled %d functions (%d failed)\n%!" !count !failed;
+        send_ok_value (Number (float_of_int !count))
+      end
+    with
+    | Eval_error msg -> send_error msg
+    | exn -> send_error (Printexc.to_string exn))
+
   | List [Symbol "reset"] ->
     (* Clear all bindings and rebuild env.
        We can't reassign env, so clear and re-populate. *)