Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -641,10 +641,18 @@
 		    ))))))
 
 ;;======================================================================
 ;; S Y S T E M   S T U F F
 ;;======================================================================
+
+;; lazy-safe get file mod time. on any error (file not existing etc.) return 0
+;;
+(define (common:lazy-modification-time fpath)
+  (handle-exceptions
+   exn
+   0
+   (file-modification-time fpath)))
 
 ;; return a nice clean pathname made absolute
 (define (common:nice-path dir)
   (let ((match (string-match "^(~[^\\/]*)(\\/.*|)$" dir)))
     (if match ;; using ~ for home?

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -524,11 +524,11 @@
 			  (let* ((db-dir (tasks:get-task-db-path))
 				 (db-pth (conc db-dir "/" run-id ".db")))
 			    (dboard:rundat-db-path-set! run-dat db-pth)
 			    db-pth)))
 	 (tmptests    (if (or do-not-use-db-file-timestamps
-			      (>= (file-modification-time db-path) last-update))
+			      (>=  (common:lazy-modification-time db-path) last-update))
                           (rmt:get-tests-for-run run-id testnamepatt states statuses  ;; run-id testpatt states statuses
 						 (dboard:rundat-run-data-offset run-dat)
 						 num-to-get
 						 (dboard:tabdat-hide-not-hide tabdat) ;; no-in
 						 sort-by                              ;; sort-by

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -14,11 +14,11 @@
 ;;======================================================================
 
 ;; dbstruct vector containing all the relevant dbs like main.db, megatest.db, run.db etc
 
 (require-extension (srfi 18) extras tcp) ;; RADT => use of require-extension?
-(use sqlite3 srfi-1 posix regex regex-case srfi-69 csv-xml s11n md5 message-digest base64 format dot-locking z3)
+(use sqlite3 srfi-1 posix regex regex-case srfi-69 csv-xml s11n md5 message-digest base64 format dot-locking z3 typed-records)
 (import (prefix sqlite3 sqlite3:))
 (import (prefix base64 base64:)) ;; RADT => prefix??
 
 (declare (unit db))
 (declare (uses common))
@@ -33,10 +33,29 @@
 (include "run_records.scm")
 
 (define *rundb-mutex* (make-mutex)) ;; prevent problems opening/closing rundb's
 (define *number-of-writes* 0)
 (define *number-non-write-queries* 0)
+
+;;======================================================================
+;;  R E C O R D S
+;;======================================================================
+
+(defstruct dbr:dbstruct 
+  main
+  strdb
+  ((path #f)  : string)
+  ((local #f) : boolean)
+  rundb
+  inmem
+  mtime
+  rtime 
+  stime
+  inuse
+  refdb
+  ((locdbs (make-hash-table)) : hash-table)
+  olddb)
 
 ;;======================================================================
 ;; SQLITE3 HELPERS
 ;;======================================================================
 
@@ -45,11 +64,12 @@
     ;; check for (exn sqlite3) ((condition-property-accessor 'exn 'message) exn)
     (print "err-status: " err-status)
     (debug:print-error 0 *default-log-port* " query " stmt " failed, params: " params ", error: " ((condition-property-accessor 'exn 'message) exn))
     (print-call-chain (current-error-port))))
 
-;; convert to -inline RADT => how inline?
+;; convert to -inline
+;;
 (define (db:first-result-default db stmt default . params)
   (handle-exceptions
    exn
    (let ((err-status ((condition-property-accessor 'sqlite3 'status #f) exn)))
      ;; check for (exn sqlite3) ((condition-property-accessor 'exn 'message) exn)
@@ -66,11 +86,11 @@
 ;;    if #f     => get main db
 ;;    if db already open - return inmem
 ;;    if db not open, open inmem, rundb and sync then return inmem
 ;;    inuse gets set automatically for rundb's
 ;;
-(define (db:get-db dbstruct run-id) ;; RADT => Where is dbstruct defined?
+(define (db:get-db dbstruct run-id) 
   (if (sqlite3:database? dbstruct) ;; pass sqlite3 databases on through
       dbstruct
       (begin
 	(let ((dbdat (if (or (not run-id)
 			     (eq? run-id 0))
@@ -77,11 +97,11 @@
 			 (db:open-main dbstruct)
 			 (db:open-rundb dbstruct run-id)
 			 )))
 	  dbdat))))
 
-;;RADT => Purpose of dbdat?
+;; legacy handling of structure for managing db's. Refactor this into dbr:?
 ;;
 (define (db:dbdat-get-db dbdat)
   (if (pair? dbdat)
       (car dbdat)
       dbdat))
@@ -99,31 +119,30 @@
 (define (db:done-with dbstruct run-id mod-read)
   (if (not (sqlite3:database? dbstruct))
       (begin
 	(mutex-lock! *rundb-mutex*)
 	(if (eq? mod-read 'mod)
-	    (dbr:dbstruct-set-mtime! dbstruct (current-milliseconds))
-	    (dbr:dbstruct-set-rtime! dbstruct (current-milliseconds)))
-	(dbr:dbstruct-set-inuse! dbstruct #f)
+	    (dbr:dbstruct-mtime-set! dbstruct (current-milliseconds))
+	    (dbr:dbstruct-rtime-set! dbstruct (current-milliseconds)))
+	(dbr:dbstruct-inuse-set! dbstruct #f)
 	(mutex-unlock! *rundb-mutex*))))
 
 ;; (db:with-db dbstruct run-id sqlite3:exec "select blah from blaz;")
 ;; r/w is a flag to indicate if the db is modified by this query #t = yes, #f = no
 ;;
 (define (db:with-db dbstruct run-id r/w proc . params)
-  (let* ((dbdat (if (vector? dbstruct)
+  (let* ((dbdat (if (dbr:dbstruct? dbstruct)
 		    (db:get-db dbstruct run-id)
 		    dbstruct)) ;; cheat, allow for passing in a dbdat
-	 (db    (db:dbdat-get-db dbdat))) ;;RADT => dbdat should already be a database, why need this function
-    (db:delay-if-busy dbdat)
+	 (db    (db:dbdat-get-db dbdat)))
     (handle-exceptions
      exn
      (begin
        (debug:print-error 0 *default-log-port* "sqlite3 issue in db:with-db, dbstruct=" dbstruct ", run-id=" run-id ", proc=" proc ", params=" params " error: " ((condition-property-accessor 'exn 'message) exn))
        (print-call-chain (current-error-port)))
      (let ((res (apply proc db params)))
-       (if (vector? dbstruct)(db:done-with dbstruct run-id r/w)) ;; RA => Mark timestamp on defstruct RADT => How come 'mod not passed instead of r/w 
+       (if (vector? dbstruct)(db:done-with dbstruct run-id r/w))
        res))))
 
 ;;======================================================================
 ;; K E E P   F I L E D B   I N   dbstruct
 ;;======================================================================
@@ -148,24 +167,26 @@
 ;;   (let ((fdb (db:get-filedb dbstruct)))
 ;;     (filedb:get-path db id)))
 
 ;; NB// #f => return dbdir only
 ;;      (was planned to be;  zeroth db with name=main.db)
+;; 
+;; If run-id is #f return to create and retrieve the path where the db will live.
 ;;
 (define (db:dbfile-path run-id)
   (let* ((dbdir           (db:get-dbdir))
 	 (fname           (if run-id
-			      (if (eq? run-id 0) "main.db" (conc run-id ".db")) ;;main.db is assigned if run-id 0; does it mean main.db same as 1.db???
+			      (if (eq? run-id 0) "main.db" (conc run-id ".db"))
 			      #f)))
     (handle-exceptions
      exn
      (begin
        (debug:print-error 0 *default-log-port* "Couldn't create path to " dbdir)
        (exit 1))
      (if (not (directory? dbdir))(create-directory dbdir #t)))
     (if fname
-	(conc dbdir "/" fname) ;;RADT => why not creating fname db if does not exist here 
+	(conc dbdir "/" fname)
 	dbdir)))
 
 ;; Returns the database location as specified in config file
 ;;
 (define (db:get-dbdir)
@@ -172,11 +193,11 @@
   (or (configf:lookup *configdat* "setup" "dbdir")
       (conc (configf:lookup *configdat* "setup" "linktree") "/.db")))
 	       
 (define (db:set-sync db)
   (let ((syncprag (configf:lookup *configdat* "setup" "sychronous")))
-    (sqlite3:execute db (conc "PRAGMA synchronous = " (or syncprag 1) ";")))) ;; RADT => advantage of PRAGMA here??
+    (sqlite3:execute db (conc "PRAGMA synchronous = " (or syncprag 1) ";")))) 
 
 ;; open an sql database inside a file lock
 ;; returns: db existed-prior-to-opening
 ;; RA => Returns a db handler; sets the lock if opened in writable mode
 ;;
@@ -205,14 +226,14 @@
 	  (sqlite3:open-database fname))))) ;; )
 
 ;; This routine creates the db. It is only called if the db is not already opened
 ;; 
 (define (db:open-rundb dbstruct run-id #!key (attemptnum 0)(do-not-open #f)) ;;  (conc *toppath* "/megatest.db") (car *configinfo*)))
-  (let* ((local  (dbr:dbstruct-get-local dbstruct))
+  (let* ((local  (dbr:dbstruct-local dbstruct))
 	 (rdb    (if local
-		     (dbr:dbstruct-get-localdb dbstruct run-id)
-		     (dbr:dbstruct-get-inmem dbstruct)))) ;; (dbr:dbstruct-get-runrec dbstruct run-id 'inmem)))
+		     (dbr:dbstruct-localdb dbstruct run-id)
+		     (dbr:dbstruct-inmem dbstruct)))) ;; (dbr:dbstruct-runrec dbstruct run-id 'inmem)))
     (if (or rdb
 	    do-not-open)
 	rdb
 	(begin
 	  (mutex-lock! *rundb-mutex*)
@@ -247,36 +268,36 @@
 		 (write-access (file-write-access? dbpath))
 		 ;; (handler      (make-busy-timeout 136000))
 		 )
 	    (if (and dbexists (not write-access))
 		(set! *db-write-access* #f)) ;; only unset so other db's also can use this control
-	    (dbr:dbstruct-set-rundb!  dbstruct (cons db dbpath))
-	    (dbr:dbstruct-set-inuse!  dbstruct #t)
-	    (dbr:dbstruct-set-olddb!  dbstruct olddb)
-	    ;; (dbr:dbstruct-set-run-id! dbstruct run-id)
+	    (dbr:dbstruct-rundb-set!  dbstruct (cons db dbpath))
+	    (dbr:dbstruct-inuse-set!  dbstruct #t)
+	    (dbr:dbstruct-olddb-set!  dbstruct olddb)
+	    ;; (dbr:dbstruct-run-id-set! dbstruct run-id)
 	    (mutex-unlock! *rundb-mutex*)
 	    (if local
 		(begin
-		  (dbr:dbstruct-set-localdb! dbstruct run-id db) ;; (dbr:dbstruct-set-inmem! dbstruct db) ;; direct access ...
+		  (dbr:dbstruct-localdb-set! dbstruct run-id db) ;; (dbr:dbstruct-inmem-set! dbstruct db) ;; direct access ...
 		  db)
 		(begin
-		  (dbr:dbstruct-set-inmem!  dbstruct inmem)
+		  (dbr:dbstruct-inmem-set!  dbstruct inmem)
 		  ;; dec 14, 2014 - keep deleted records available. hunch is that they are needed for id placeholders
 		  ;; (sqlite3:execute db "DELETE FROM tests WHERE state='DELETED';") ;; they just slow us down in this context
 		  (db:sync-tables db:sync-tests-only db inmem)
 		  (db:delay-if-busy refdb) ;; dbpath: (db:dbdat-get-path refdb)) ;; What does delaying here achieve? 
-		  (dbr:dbstruct-set-refdb!  dbstruct refdb)
+		  (dbr:dbstruct-refdb-set!  dbstruct refdb)
 		  (db:sync-tables db:sync-tests-only inmem refdb) ;; use inmem as the reference, don't read again from db
 		  ;; sync once more to deal with delays?
 		  ;; (db:sync-tables db:sync-tests-only db inmem)
 		  ;; (db:sync-tables db:sync-tests-only inmem refdb)
 		  inmem)))))))
 
 ;; This routine creates the db if not already present. It is only called if the db is not already ls opened
 ;;
 (define (db:open-main dbstruct) ;;  (conc *toppath* "/megatest.db") (car *configinfo*))) 
-  (let ((mdb (dbr:dbstruct-get-main dbstruct))) ;; RA => Returns the first reference in dbstruct
+  (let ((mdb (dbr:dbstruct-main dbstruct))) ;; RA => Returns the first reference in dbstruct
     (if mdb
 	mdb
 	(begin
 	  (mutex-lock! *rundb-mutex*)
 	  (let* ((dbpath       (db:dbfile-path 0))
@@ -285,12 +306,12 @@
 		 (olddb        (db:open-megatest-db))
 		 (write-access (file-write-access? dbpath))
 		 (dbdat        (cons db dbpath)))
 	    (if (and dbexists (not write-access))
 		(set! *db-write-access* #f))
-	    (dbr:dbstruct-set-main!   dbstruct dbdat)
-	    (dbr:dbstruct-set-olddb!  dbstruct olddb) ;; olddb is already a (cons db path)
+	    (dbr:dbstruct-main-set!   dbstruct dbdat)
+	    (dbr:dbstruct-olddb-set!  dbstruct olddb) ;; olddb is already a (cons db path)
 	    (mutex-unlock! *rundb-mutex*)
 	    (if (and (not dbexists)
 		     *db-write-access*) ;; did not have a prior db and do have write access
 		(db:multi-db-sync #f 'old2new))  ;; migrate data from megatest.db automatically
 	    dbdat)))))
@@ -317,18 +338,18 @@
     (cons db dbpath)))
 
 ;; sync run to disk if touched
 ;;
 (define (db:sync-touched dbstruct run-id #!key (force-sync #f))
-  (let ((mtime  (dbr:dbstruct-get-mtime dbstruct))
-	(stime  (dbr:dbstruct-get-stime dbstruct))
-	(rundb  (dbr:dbstruct-get-rundb dbstruct))
-	(inmem  (dbr:dbstruct-get-inmem dbstruct))
-	(maindb (dbr:dbstruct-get-main  dbstruct))
-	(refdb  (dbr:dbstruct-get-refdb dbstruct))
-	(olddb  (dbr:dbstruct-get-olddb dbstruct))
-	;; (runid  (dbr:dbstruct-get-run-id dbstruct))
+  (let ((mtime  (dbr:dbstruct-mtime dbstruct))
+	(stime  (dbr:dbstruct-stime dbstruct))
+	(rundb  (dbr:dbstruct-rundb dbstruct))
+	(inmem  (dbr:dbstruct-inmem dbstruct))
+	(maindb (dbr:dbstruct-main  dbstruct))
+	(refdb  (dbr:dbstruct-refdb dbstruct))
+	(olddb  (dbr:dbstruct-olddb dbstruct))
+	;; (runid  (dbr:dbstruct-run-id dbstruct))
 	)
     (debug:print-info 4 *default-log-port* "Syncing for run-id: " run-id)
     ;; (mutex-lock! *http-mutex*)
     (if (eq? run-id 0)
 	;; runid equal to 0 is main.db
@@ -339,11 +360,11 @@
 		    force-sync)
 		(begin
 		  (db:delay-if-busy maindb)
 		  (db:delay-if-busy olddb)
 		  (let ((num-synced (db:sync-tables (db:sync-main-list maindb) maindb olddb)))
-		    (dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
+		    (dbr:dbstruct-stime-set! dbstruct (current-milliseconds))
 		    num-synced)
 		  0))
 	    (begin
 	      ;; this can occur when using local access (i.e. not in a server)
 	      ;; need a flag to turn it off.
@@ -356,33 +377,33 @@
 		(> mtime stime)
 		force-sync)
 	    (begin
 	      (db:delay-if-busy rundb)
 	      (db:delay-if-busy olddb)
-	      (dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
+	      (dbr:dbstruct-stime-set! dbstruct (current-milliseconds))
 	      (let ((num-synced (db:sync-tables db:sync-tests-only inmem refdb rundb olddb)))
 		;; (mutex-unlock! *http-mutex*)
 		num-synced)
 	      (begin
 		;; (mutex-unlock! *http-mutex*)
 		0))))))
 
 (define (db:close-main dbstruct)
-  (let ((maindb (dbr:dbstruct-get-main dbstruct)))
+  (let ((maindb (dbr:dbstruct-main dbstruct)))
     (if maindb
 	(begin
 	  (sqlite3:finalize! (db:dbdat-get-db maindb))
-	  (dbr:dbstruct-set-main! dbstruct #f)))))
+	  (dbr:dbstruct-main-set! dbstruct #f)))))
 
 (define (db:close-run-db dbstruct run-id)
   (let ((rdb (db:open-rundb dbstruct run-id do-not-open: #t)))
     (if (and rdb
 	     (sqlite3:database? rdb))
 	(begin
 	  (sqlite3:finalize! rdb)
-	  (dbr:dbstruct-set-localdb! dbstruct run-id #f)
-	  (dbr:dbstruct-set-inmem! dbstruct #f)))))
+	  (dbr:dbstruct-localdb-set! dbstruct run-id #f)
+	  (dbr:dbstruct-inmem-set! dbstruct #f)))))
 
 ;; close all opened run-id dbs
 (define (db:close-all dbstruct)
   ;; finalize main.db
   (db:sync-touched dbstruct 0 force-sync: #t)
@@ -389,11 +410,11 @@
   ;;(common:db-block-further-queries)
   ;; (mutex-lock! *db-sync-mutex*) ;; with this perhaps it isn't necessary to use the block-further-queries mechanism?
 
   (db:close-main dbstruct)
   
-  (let ((locdbs (dbr:dbstruct-get-locdbs dbstruct)))
+  (let ((locdbs (dbr:dbstruct-locdbs dbstruct)))
     (if (hash-table? locdbs)
 	(for-each (lambda (run-id)
 		    (db:close-run-db dbstruct run-id))
 		  (hash-table-keys locdbs)))))
 
@@ -756,11 +777,11 @@
 	     (db:delay-if-busy mtdb)
 	     (let ((testrecs (db:get-all-tests-info-by-run-id mtdb run-id))
 		   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t) #f)))
 	       (debug:print 0 *default-log-port* "INFO: Propagating " (length testrecs) " records for run-id=" run-id " to run specific db")
 	       (db:replace-test-records dbstruct run-id testrecs)
-	       (sqlite3:finalize! (db:dbdat-get-db (dbr:dbstruct-get-rundb dbstruct)))))
+	       (sqlite3:finalize! (db:dbdat-get-db (dbr:dbstruct-rundb dbstruct)))))
 	   run-ids)))
 
     ;; now ensure all newdb data are synced to megatest.db
     ;; do not use the run-ids list passed in to the function
     ;;
@@ -3357,10 +3378,11 @@
 		  (if (null? tal)
 		      (map cdr (hash-table->alist tests-hash)) ;; return a list of the most recent tests
 		      (loop (car tal)(cdr tal))))))))))
 
 ;; Function recursively checks if <db>.journal exists; if yes means db busy; call itself after delayed interval
+;; return the sqlite3 db handle if possible
 ;; 
 (define (db:delay-if-busy dbdat #!key (count 6))
   (if (not (configf:lookup *configdat* "server" "delay-on-busy")) ;;RADT => two conditions in a if block?? also understand what config looked up
       (and dbdat (db:dbdat-get-db dbdat))
       (if dbdat
@@ -3370,11 +3392,11 @@
 	    (if (handle-exceptions
 		 exn
 		 (begin
 		   (debug:print-info 0 *default-log-port* "WARNING: failed to test for existance of " dbfj)
 		   (thread-sleep! 1)
-		   (db:delay-if-busy count (- count 1))) ;; RADT => Don't we need to sent a dbstruct here?
+		   (db:delay-if-busy count (- count 1)))
 		 (file-exists? dbfj))
 		(case count
 		  ((6)
 		   (thread-sleep! 0.2)
 		   (db:delay-if-busy count: 5))

Index: db_records.scm
==================================================================
--- db_records.scm
+++ db_records.scm
@@ -13,61 +13,61 @@
 ;;
 ;;
 ;; Accessors for a dbstruct
 ;;
 
-(define-inline (dbr:dbstruct-get-main    vec)    (vector-ref  vec 0)) ;; ( db path )
-(define-inline (dbr:dbstruct-get-strdb   vec)    (vector-ref  vec 1)) ;; ( db path )
-(define-inline (dbr:dbstruct-get-path    vec)    (vector-ref  vec 2)) 
-(define-inline (dbr:dbstruct-get-local   vec)    (vector-ref  vec 3))
-(define-inline (dbr:dbstruct-get-rundb   vec)    (vector-ref  vec 4)) ;; ( db path )
-(define-inline (dbr:dbstruct-get-inmem   vec)    (vector-ref  vec 5)) ;; ( db #f )
-(define-inline (dbr:dbstruct-get-mtime   vec)    (vector-ref  vec 6))
-(define-inline (dbr:dbstruct-get-rtime   vec)    (vector-ref  vec 7))
-(define-inline (dbr:dbstruct-get-stime   vec)    (vector-ref  vec 8))
-(define-inline (dbr:dbstruct-get-inuse   vec)    (vector-ref  vec 9))
-(define-inline (dbr:dbstruct-get-refdb   vec)    (vector-ref  vec 10)) ;; ( db path )
-(define-inline (dbr:dbstruct-get-locdbs  vec)    (vector-ref  vec 11))
-(define-inline (dbr:dbstruct-get-olddb   vec)    (vector-ref  vec 12)) ;; ( db path )
-;; (define-inline (dbr:dbstruct-get-main-path vec)  (vector-ref  vec 13))
-;; (define-inline (dbr:dbstruct-get-rundb-path vec) (vector-ref  vec 14))
-;; (define-inline (dbr:dbstruct-get-run-id  vec)    (vector-ref  vec 13))
-
-(define-inline (dbr:dbstruct-set-main!   vec val)(vector-set! vec 0 val))
-(define-inline (dbr:dbstruct-set-strdb!  vec val)(vector-set! vec 1 val))
-(define-inline (dbr:dbstruct-set-path!   vec val)(vector-set! vec 2 val))
-(define-inline (dbr:dbstruct-set-local!  vec val)(vector-set! vec 3 val))
-(define-inline (dbr:dbstruct-set-rundb!  vec val)(vector-set! vec 4 val))
-(define-inline (dbr:dbstruct-set-inmem!  vec val)(vector-set! vec 5 val))
-(define-inline (dbr:dbstruct-set-mtime!  vec val)(vector-set! vec 6 val))
-(define-inline (dbr:dbstruct-set-rtime!  vec val)(vector-set! vec 7 val))
-(define-inline (dbr:dbstruct-set-stime!  vec val)(vector-set! vec 8 val))
-(define-inline (dbr:dbstruct-set-inuse!  vec val)(vector-set! vec 9 val))
-(define-inline (dbr:dbstruct-set-refdb!  vec val)(vector-set! vec 10 val))
-(define-inline (dbr:dbstruct-set-locdbs! vec val)(vector-set! vec 11 val))
-(define-inline (dbr:dbstruct-set-olddb!  vec val)(vector-set! vec 12 val))
-(define-inline (dbr:dbstruct-set-main-path! vec val)(vector-set! vec 13 val))
-(define-inline (dbr:dbstruct-set-rundb-path! vec val)(vector-set! vec 14 val))
-
-; (define-inline (dbr:dbstruct-set-run-id! vec val)(vector-set! vec 13 val))
+;; (define-inline (dbr:dbstruct-main    vec)    (vector-ref  vec 0)) ;; ( db path )
+;; (define-inline (dbr:dbstruct-strdb   vec)    (vector-ref  vec 1)) ;; ( db path )
+;; (define-inline (dbr:dbstruct-path    vec)    (vector-ref  vec 2)) 
+;; (define-inline (dbr:dbstruct-local   vec)    (vector-ref  vec 3))
+;; (define-inline (dbr:dbstruct-rundb   vec)    (vector-ref  vec 4)) ;; ( db path )
+;; (define-inline (dbr:dbstruct-inmem   vec)    (vector-ref  vec 5)) ;; ( db #f )
+;; (define-inline (dbr:dbstruct-mtime   vec)    (vector-ref  vec 6))
+;; (define-inline (dbr:dbstruct-rtime   vec)    (vector-ref  vec 7))
+;; (define-inline (dbr:dbstruct-stime   vec)    (vector-ref  vec 8))
+;; (define-inline (dbr:dbstruct-inuse   vec)    (vector-ref  vec 9))
+;; (define-inline (dbr:dbstruct-refdb   vec)    (vector-ref  vec 10)) ;; ( db path )
+;; (define-inline (dbr:dbstruct-locdbs  vec)    (vector-ref  vec 11))
+;; (define-inline (dbr:dbstruct-olddb   vec)    (vector-ref  vec 12)) ;; ( db path )
+;; ;; (define-inline (dbr:dbstruct-main-path vec)  (vector-ref  vec 13))
+;; ;; (define-inline (dbr:dbstruct-rundb-path vec) (vector-ref  vec 14))
+;; ;; (define-inline (dbr:dbstruct-run-id  vec)    (vector-ref  vec 13))
+;; 
+;; (define-inline (dbr:dbstruct-main-set!   vec val)(vector-set! vec 0 val))
+;; (define-inline (dbr:dbstruct-strdb-set!  vec val)(vector-set! vec 1 val))
+;; (define-inline (dbr:dbstruct-path-set!   vec val)(vector-set! vec 2 val))
+;; (define-inline (dbr:dbstruct-local-set!  vec val)(vector-set! vec 3 val))
+;; (define-inline (dbr:dbstruct-rundb-set!  vec val)(vector-set! vec 4 val))
+;; (define-inline (dbr:dbstruct-inmem-set!  vec val)(vector-set! vec 5 val))
+;; (define-inline (dbr:dbstruct-mtime-set!  vec val)(vector-set! vec 6 val))
+;; (define-inline (dbr:dbstruct-rtime-set!  vec val)(vector-set! vec 7 val))
+;; (define-inline (dbr:dbstruct-stime-set!  vec val)(vector-set! vec 8 val))
+;; (define-inline (dbr:dbstruct-inuse-set!  vec val)(vector-set! vec 9 val))
+;; (define-inline (dbr:dbstruct-refdb-set!  vec val)(vector-set! vec 10 val))
+;; (define-inline (dbr:dbstruct-locdbs-set! vec val)(vector-set! vec 11 val))
+;; (define-inline (dbr:dbstruct-olddb-set!  vec val)(vector-set! vec 12 val))
+;; (define-inline (dbr:dbstruct-main-path-set! vec val)(vector-set! vec 13 val))
+;; (define-inline (dbr:dbstruct-rundb-path-set! vec val)(vector-set! vec 14 val))
+;; 
+; (define-inline (dbr:dbstruct-run-id-set! vec val)(vector-set! vec 13 val))
 
 ;; constructor for dbstruct
 ;;
-(define (make-dbr:dbstruct #!key (path #f)(local #f))
-  (let ((v (make-vector 15 #f)))
-    (dbr:dbstruct-set-path! v path)
-    (dbr:dbstruct-set-local! v local)
-    (dbr:dbstruct-set-locdbs! v (make-hash-table))
-    v))
+;; (define (make-dbr:dbstruct #!key (path #f)(local #f))
+;;   (let ((v (make-vector 15 #f)))
+;;     (dbr:dbstruct-path-set! v path)
+;;     (dbr:dbstruct-local-set! v local)
+;;     (dbr:dbstruct-locdbs-set! v (make-hash-table))
+;;     v))
 
 ;; Returns the database for a particular run-id fron the dbstruct:localdbs
 ;;
-(define (dbr:dbstruct-get-localdb v run-id)
-  (hash-table-ref/default (dbr:dbstruct-get-locdbs v) run-id #f))
+(define (dbr:dbstruct-localdb v run-id)
+  (hash-table-ref/default (dbr:dbstruct-locdbs v) run-id #f))
 
-(define (dbr:dbstruct-set-localdb! v run-id db)
-  (hash-table-set! (dbr:dbstruct-get-locdbs v) run-id db))
+(define (dbr:dbstruct-localdb-set! v run-id db)
+  (hash-table-set! (dbr:dbstruct-locdbs v) run-id db))
 
 
 (define (make-db:test)(make-vector 20))
 (define-inline (db:test-get-id           vec) (vector-ref vec 0))
 (define-inline (db:test-get-run_id       vec) (vector-ref vec 1))

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -12,11 +12,11 @@
 (use format)
 (require-library iup)
 (import (prefix iup iup:))
 (use canvas-draw)
 (import canvas-draw-iup)
-(use regex defstruct)
+(use regex typed-records)
 
 (declare (unit dcommon))
 
 (declare (uses megatest-version))
 (declare (uses gutils))

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -12,11 +12,11 @@
 ;; launch a task - this runs on the originating host, tests themselves
 ;;
 ;;======================================================================
 
 (use regex regex-case base64 sqlite3 srfi-18 directory-utils posix-extras z3 call-with-environment-variables csv)
-(use defstruct pathname-expand)
+(use typed-records pathname-expand)
 
 (import (prefix base64 base64:))
 (import (prefix sqlite3 sqlite3:))
 
 (declare (unit launch))