Index: api.scm
==================================================================
--- api.scm
+++ api.scm
@@ -21,68 +21,40 @@
     ((get-key-val-pairs)            (apply db:get-key-val-pairs db params))
     ((get-keys)                     (db:get-keys db))
 
     ;; TESTS
     ;; json doesn't do vectors, convert to list
-    ((get-test-info-by-id)	       (let ((res (apply db:get-test-info-by-id db params)))
-					 (if (vector? res)(vector->list res) res)))
+    ((get-test-info-by-id)	       (apply db:get-test-info-by-id db params))
     ((test-get-rundir-from-test-id)    (apply db:test-get-rundir-from-test-id db params))
     ((test-set-state-status-by-id)     (apply db:test-set-state-status-by-id db params))
     ((get-count-tests-running)         (db:get-count-tests-running db))
     ((get-count-tests-running-in-jobgroup) (apply db:get-count-tests-running-in-jobgroup db params))
     ((delete-test-records)             (apply db:delete-test-records db params))
     ((delete-old-deleted-test-records) (db:delete-old-deleted-test-records db))
     ((test-set-status-state)           (apply db:test-set-status-state db params))
     ((get-previous-test-run-record)    (apply db:get-previous-test-run-record db params))
-    ((get-matching-previous-test-run-records)(map vector->list (apply db:get-matching-previous-test-run-records db params)))
+    ((get-matching-previous-test-run-records)(apply db:get-matching-previous-test-run-records db params))
     ((db:test-get-logfile-info)        (apply db:test-get-logfile-info db params))
     ((test-get-records-for-index-file  (apply db:test-get-records-for-index-file db params)))
-    ((get-testinfo-state-status)       (let ((res (apply db:get-testinfo-state-status db params)))
-					 (if (vector? res)
-					     (vector->list res)
-					     res)))
+    ((get-testinfo-state-status)       (apply db:get-testinfo-state-status db params))
     ((test-get-paths-matching-keynames-target-new) (apply db:test-get-paths-matching-keynames-target-new db params))
-    ((get-prereqs-not-met)             (let ((res (apply db:get-prereqs-not-met db params)))
-					 (map (lambda (x)
-						(if (vector? x)
-						    (vector->list x)
-						    x))
-					      res)))
+    ((get-prereqs-not-met)             (apply db:get-prereqs-not-met db params))
     ((roll-up-pass-fail-counts)        (apply db:roll-up-pass-fail-counts db params))
     ((update-fail-pass-counts)         (apply db:general-call db 'update-pass-fail-counts params))
     ((get-count-tests-running-for-run-id) (apply db:get-count-tests-running-for-run-id db params))
 
     ;; RUNS
-    ((get-run-info)                 (let ((res (apply db:get-run-info db params)))
-				      (list (vector-ref res 0)
-					    (vector->list (vector-ref res 1)))))
+    ((get-run-info)                 (apply db:get-run-info db params))
     ((register-run)                 (apply db:register-run db params))
     ((set-tests-state-status)       (apply db:set-tests-state-status db params))
-    ((get-tests-for-run)            (let ((res  (apply db:get-tests-for-run db params)))
-				      (if (list? res)
-					  (map (lambda (x)
-						 (if (list? x)
-						     (vector->list x)
-						     (begin
-						       (debug:print 0 "ERROR in remote of get-tests-for-run, not a vector")
-						       x)))
-					       res)
-					  (begin
-					    (debug:print 0 "ERROR in remote of get-tests-for-run, not a list")
-					    res))))
+    ((get-tests-for-run)            (apply db:get-tests-for-run db params))
     ((get-test-id)                  (apply db:get-test-id-not-cached db params))
-    ((get-tests-for-runs-mindata)   (map vector->list (apply db:get-tests-for-runs-mindata db params)))
+    ((get-tests-for-runs-mindata)   (apply db:get-tests-for-runs-mindata db params))
     ((get-run-name-from-id)         (apply db:get-run-name-from-id db params))
     ((delete-run)                   (apply db:delete-run db params))
-    ((get-runs)                     (let* ((res  (apply db:get-runs db params))
-					   (hedr (vector-ref res 0))
-					   (data (vector-ref res 1)))
-				      (list hedr (map vector->list data))))
-    ((get-runs-by-patt)             (let* ((res  (apply db:get-runs-by-patt db params))
-					   (hedr (vector-ref res 0))
-					   (data (vector-ref res 1)))
-				      (list hedr (map vector->list data))))
+    ((get-runs)                     (apply db:get-runs db params))
+    ((get-runs-by-patt)             (apply db:get-runs-by-patt db params))
     ((lock/unlock-run)              (apply db:lock/unlock-run db params))
     ((update-run-event_time)        (apply db:update-run-event_time db params))
 
     ;; MISC
     ((login)                        (apply db:login db params))
@@ -107,14 +79,11 @@
 	   (process-signal pid signal/kill)
 	   (thread-start! th1))
        '(#t "exit process started")))
 
     ;; TESTMETA
-    ((testmeta-get-record)       (let ((res (apply db:testmeta-get-record db params)))
-				   (if (vector? res)
-				       (vector->list res)
-				       res)))
+    ((testmeta-get-record)       (apply db:testmeta-get-record db params))
     ((testmeta-add-record)       (apply db:testmeta-add-record db params))
     ((testmeta-update-field)     (apply db:testmeta-update-field db params))
     (else
      (list "ERROR" 0))))
 

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -105,14 +105,11 @@
 
 (define (rmt:get-test-id run-id testname item-path)
   (rmt:send-receive 'get-test-id (list run-id testname item-path)))
 
 (define (rmt:get-test-info-by-id test-id)
-  (let ((res (rmt:send-receive 'get-test-info-by-id (list test-id))))
-    (if (list? res)
-	(list->vector res)
-	res)))
+  (rmt:send-receive 'get-test-info-by-id (list test-id)))
 
 (define (rmt:test-get-rundir-from-test-id test-id)
   (rmt:send-receive 'test-get-rundir-from-test-id (list test-id)))
 
 (define (rmt:open-test-db-by-test-id test-id #!key (work-area #f))
@@ -124,25 +121,18 @@
 
 ;; WARNING: This currently bypasses the transaction wrapped writes system
 (define (rmt:test-set-state-status-by-id test-id newstate newstatus newcomment)
   (rmt:send-receive 'test-set-state-status-by-id (list test-id newstate newstatus newcomment)))
 
-
 (define (rmt:set-tests-state-status run-id testnames currstate currstatus newstate newstatus)
   (rmt:send-receive 'set-tests-state-status (list run-id testnames currstate currstatus newstate newstatus)))
 
 (define (rmt:get-tests-for-run run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals)
-  (let ((res  (rmt:send-receive 'get-tests-for-run (list run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals))))
-    (if (list? res)
-	(map list->vector res)
-	res)))
+  (rmt:send-receive 'get-tests-for-run (list run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals)))
 
 (define (rmt:get-tests-for-runs-mindata run-ids testpatt states status not-in)
-  (let ((res (rmt:send-receive 'get-tests-for-runs-mindata (list run-ids testpatt states status not-in))))
-    (cond 
-     ((list? res)(map list->vector res))
-     (else res))))
+  (rmt:send-receive 'get-tests-for-runs-mindata (list run-ids testpatt states status not-in)))
 
 (define (rmt:delete-test-records test-id)
   (rmt:send-receive 'delete-test-records (list test-id)))
 
 (define (rmt:test-set-status-state test-id status state msg)
@@ -150,38 +140,29 @@
 
 (define (rmt:get-previous-test-run-record run-id test-name item-path)
   (rmt:send-receive 'get-previous-test-run-record (list run-id test-name item-path)))
 
 (define (rmt:get-matching-previous-test-run-records run-id test-name item-path)
-  (map list->vector 
-       (rmt:send-receive 'get-matching-previous-test-run-records (list run-id test-name item-path))))
+  (rmt:send-receive 'get-matching-previous-test-run-records (list run-id test-name item-path)))
 
 (define (rmt:test-get-logfile-info run-id test-name)
   (rmt:send-receive 'test-get-logfile-info (list run-id test-name)))
 
 (define (rmt:test-get-records-for-index-file run-id test-name)
   (rmt:send-receive 'test-get-records-for-index-file (list  run-id test-name)))
 
 (define (rmt:get-testinfo-state-status test-id)
-  (let ((res (rmt:send-receive 'get-testinfo-state-status (list test-id))))
-    (if (list? res)
-	(list->vector res)
-	res)))
+  (rmt:send-receive 'get-testinfo-state-status (list test-id)))
 
 (define (rmt:test-set-log! test-id logf)
   (if (string? logf)(rmt:general-call 'test-set-log logf test-id)))
 
 (define (rmt:test-get-paths-matching-keynames-target-new keynames target res testpatt statepatt statuspatt runname)
   (rmt:send-receive 'test-get-paths-matching-keynames-target-new (list keynames target res testpatt statepatt statuspatt runname)))
 
 (define (rmt:get-prereqs-not-met run-id waitons ref-item-path #!key (mode 'normal))
-  (let ((res (rmt:send-receive 'get-prereqs-not-met (list run-id waitons ref-item-path mode))))
-    (map (lambda (x)
-	   (if (list? x)
-	       (list->vector x)
-	       x))
-	 res)))
+  (rmt:send-receive 'get-prereqs-not-met (list run-id waitons ref-item-path mode)))
 
 (define (rmt:get-count-tests-running-for-run-id run-id)
   (rmt:send-receive 'get-count-tests-running-for-run-id (list run-id)))
 
 ;; Statistical queries
@@ -201,13 +182,11 @@
 ;;======================================================================
 ;;  R U N S
 ;;======================================================================
 
 (define (rmt:get-run-info run-id)
-  (let ((res (rmt:send-receive 'get-run-info (list run-id))))
-    (vector (car res)
-	    (list->vector (cadr res)))))
+  (rmt:send-receive 'get-run-info (list run-id)))
 
 (define (rmt:register-run keyvals runname state status user)
   (rmt:send-receive 'register-run (list keyvals runname state status user)))
     
 (define (rmt:get-run-name-from-id run-id)
@@ -218,20 +197,14 @@
 
 (define (rmt:delete-old-deleted-test-records)
   (rmt:send-receive 'delete-old-deleted-test-records '()))
 
 (define (rmt:get-runs runpatt count offset keypatts)
-  (let* ((res  (rmt:send-receive 'get-runs (list runpatt count offset keypatts)))
-	 (hedr (car res))
-	 (data (cadr res)))
-    (vector hedr (map list->vector data))))
+  (rmt:send-receive 'get-runs (list runpatt count offset keypatts)))
 
 (define (rmt:get-runs-by-patt keys runnamepatt targpatt offset limit)
-  (let* ((res  (rmt:send-receive 'get-runs-by-patt (list keys runnamepatt targpatt offset limit)))
-	 (hedr (car res))
-	 (data (cadr res)))
-    (vector hedr (map list->vector data))))
+  (rmt:send-receive 'get-runs-by-patt (list keys runnamepatt targpatt offset limit)))
 
 (define (rmt:lock/unlock-run run-id lock unlock user)
   (rmt:send-receive 'lock/unlock-run (list run-id lock unlock user)))
 
 (define (rmt:update-run-event_time run-id)
@@ -268,12 +241,9 @@
 
 (define (rmt:testmeta-add-record testname)
   (rmt:send-receive 'testmeta-add-record (list testname)))
 
 (define (rmt:testmeta-get-record testname)
-  (let ((res (rmt:send-receive 'testmeta-get-record (list testname))))
-    (if (list? res)
-	(list->vector res)
-	res)))
+  (rmt:send-receive 'testmeta-get-record (list testname)))
 
 (define (rmt:testmeta-update-field test-name fld val)
   (rmt:send-receive 'testmeta-update-field (list test-name fld val)))

Index: tests/fullrun/tests/priority_8/main.sh
==================================================================
--- tests/fullrun/tests/priority_8/main.sh
+++ tests/fullrun/tests/priority_8/main.sh
@@ -1,10 +1,14 @@
 #!/bin/bash
 
 # a bunch of steps in 2 second increments
 for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17;do
+  echo "start step before $i: `date`"
   $MT_MEGATEST -step step$i :state start :status running -setlog results$i.html
+  echo "start step after $i: `date`"
   sleep 2
+  echo "end step before $i: `date`"
   $MT_MEGATEST -step step$i :state end :status 0
+  echo "end step after $i: `date`"
 done
 
 exit 0