Index: ulex-trials/Makefile
==================================================================
--- ulex-trials/Makefile
+++ ulex-trials/Makefile
@@ -1,8 +1,8 @@
-ulex-test : ulex-test.scm
+ulex-test : ulex-test.scm ../ulex/ulex.scm
 	csc ulex-test.scm
 
 test : ulex-test
-	./ulex-test do-test
+	for x in $$(seq 9);do export NBFAKE_LOG=NBFAKE_$$x;sleep 1;nbfake ./ulex-test run 828$$x;echo $$cmd;$$cmd;done
 
 clean :
 	rm -f .runners/* NBFAKE*

Index: ulex-trials/ulex-test.scm
==================================================================
--- ulex-trials/ulex-test.scm
+++ ulex-trials/ulex-test.scm
@@ -24,74 +24,16 @@
 	ulex
 	)
 
 (define help "Usage: ulex-test COMMAND
   where COMMAND is one of:
-    do-test              : run the basic req/rep test
-    run tcp://host:port  : start test server - start several in same dir
+    run host:port  : start test server - start several in same dir
 ")
 
-(define address-tcp-1 "tcp://localhost:5555")
-(define address-tcp-2 "tcp://localhost:6666")
-
-(define address-inproc-1 "inproc://local1")
-(define address-inproc-2 "inproc://local2")
-
-;;;
-;;; Req-Rep
-;;;
-(define (make-listening-reply-socket address)
-  (let ((socket (make-rep-socket)))
-    (socket-set! socket 'nng/recvtimeo 2000)
-    (nng-listen socket address)
-    socket))
-
-(define (make-dialed-request-socket address)
-  (let ((socket (make-req-socket)))
-    (socket-set! socket 'nng/recvtimeo 2000)
-    (nng-dial socket address)
-    socket))
-
-(define (req-rep-test address)
-  (let ((rep (make-listening-reply-socket address))
-        (req (make-dialed-request-socket address)))
-    (nng-send req "message 1")
-    (nng-recv rep)
-    (nng-send rep "message")
-    (begin0
-     (nng-recv req)
-     (nng-close! rep))))
-
-(define (do-test)
-  (test-group "nng"
-              (test "tcp req-rep"
-                    "message"
-                    (req-rep-test address-tcp-1))
-              (test "inproc req-rep"
-                    "message"
-                    (req-rep-test address-inproc-1)))
-  (test-exit))
-
-;; this should be run in a thread
-(define (run-listener-responder socket myaddr)
-  (let loop ((status 'running))
-    (let* ((msg (nng-recv socket))
-	   (response (process-message msg)))
-      (if (not (eq? response 'done))
-	  (begin
-	    (nng-send socket response)
-	    (loop status))))))
-
-(define *channels* (make-hash-table))
-
-(define (call channels msg addr)
-  (let* ((csocket (hash-table-ref/default channels addr #f))
-	 (socket  (or csocket (make-dialed-request-socket addr))))
-    (nng-send socket msg)
-    (print "Sent: "msg", received: "(nng-recv socket))
-    (if (not (hash-table-exists? channels addr))
-	(hash-table-set! channels addr socket))))
+(define (call uconn msg addr)
+  (print "Sent: "msg", received: "
+	 (send-receive uconn addr 'hello msg)))
 
 ;; start    => hello 0
 ;; hello 0  => hello 1
 ;; hello 1  => hello 2
 ;;  ...
@@ -112,32 +54,29 @@
       "hello 0"))))
 
 (define (main)
   (match
    (command-line-arguments)
-   (("do-test")(do-test))
-   ((run myaddr)
+   ((run myport)
     ;; start listener
     ;; put myaddr into file by host-pid in .runners
     ;; for 1 minute
     ;;     get all in .runners
     ;;     call each with a message
     ;;
-    (let* ((endtimes (+ (current-seconds) 20)) ;; run for 20 seconds
-	   (socket (make-listening-reply-socket myaddr))
-	   (rfile  (conc ".runners/"(get-host-name)"-"(current-process-id)))
-	   (th1    (make-thread (lambda ()
-				  (run-listener-responder socket myaddr)
-				  )
-				"responder")))
+    (let* ((port     (string->number myport))
+	   (endtimes (+ (current-seconds) 20)) ;; run for 20 seconds
+	   (handler  (lambda (rem-host-port qrykey cmd params)
+		       (process-message params)))
+	   (uconn    (run-listener handler myport))
+	   (rfile    (conc ".runners/"(get-host-name)"-"(current-process-id))))
       (if (not (and (file-exists? ".runners")
 		    (directory? ".runners")))
 	  (create-directory ".runners" #t))
       (with-output-to-file rfile
 	(lambda ()
-	  (print myaddr)))
-      (thread-start! th1)
+	  (print myport)))
       (let loop ((entries '()))
 	(if (> (current-seconds) endtimes)
 	    (begin
 	      (delete-file* rfile)
 	      (sleep 1)
@@ -144,18 +83,18 @@
 	      (exit))
 	    (if (null? entries)
 		(loop (glob ".runners/*"))
 		(let* ((entry (car entries))
 		       (destaddr (with-input-from-file entry read-line)))
-		  (call *channels* (conc "hello-from-"destaddr)  destaddr)
+		  (call uconn (conc "hello-from-"myport"to-"destaddr) destaddr)
 		  ;; (thread-sleep! 0.025)
 		  (loop (cdr entries))))))))
    ((cmd)(print "ERROR: command "cmd", not recognised.\n\n"help))
    (else
     (print help))))
 
 ) ;; end module
 
-(import nng-test)
+(import ulex-test)
 (main)
 
 

Index: ulex.scm
==================================================================
--- ulex.scm
+++ ulex.scm
@@ -18,7 +18,7 @@
 
 ;;======================================================================
 
 (declare (unit ulex))
 
-;; (include "ulex/ulex.scm")
-(include "ulex-simple/ulex.scm")
+(include "ulex/ulex.scm")
+;; (include "ulex-simple/ulex.scm")

Index: ulex/ulex.scm
==================================================================
--- ulex/ulex.scm
+++ ulex/ulex.scm
@@ -24,11 +24,12 @@
 ;;   Why sql-de-lite and not say, dbi?  - performance mostly, then simplicity.
 ;;
 ;;======================================================================
 
 (module ulex
-    (
+	*
+	#;(
      
      ;; NOTE: looking for the handler proc - find the run-listener :)
      
      run-listener     ;; (run-listener handler-proc [port]) => uconn
 
@@ -107,18 +108,18 @@
   ) 
 
 ;; Parameters
 
 ;; work-method:
-(define work-method (make-parameter 'direct))
+(define work-method (make-parameter 'mailbox))
 ;;    mailbox - all rdat goes through mailbox
 ;;    threads - all rdat immediately executed in new thread
 ;;    direct  - no queuing
 ;;
 
 ;; return-method, return the result to waiting send-receive:
-(define return-method (make-parameter 'direct))
+(define return-method (make-parameter 'mailbox))
 ;;    mailbox - create a mailbox and use it for passing returning results to send-receive
 ;;    polling - put the result in a hash table keyed by qrykey and send-receive can poll it for result
 ;;    direct  - no queuing, result is passed back in single tcp connection
 ;;